]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wxSscanf() and friends are now Unicode+ANSI friendly wrappers instead of defines...
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDouble swig_types[33]
2500 #define SWIGTYPE_p_wxDropFilesEvent swig_types[34]
2501 #define SWIGTYPE_p_wxDuplexMode swig_types[35]
2502 #define SWIGTYPE_p_wxEraseEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEvent swig_types[37]
2504 #define SWIGTYPE_p_wxEventBlocker swig_types[38]
2505 #define SWIGTYPE_p_wxEventLoop swig_types[39]
2506 #define SWIGTYPE_p_wxEventLoopActivator swig_types[40]
2507 #define SWIGTYPE_p_wxEvtHandler swig_types[41]
2508 #define SWIGTYPE_p_wxFSFile swig_types[42]
2509 #define SWIGTYPE_p_wxFileSystem swig_types[43]
2510 #define SWIGTYPE_p_wxFileSystemHandler swig_types[44]
2511 #define SWIGTYPE_p_wxFlexGridSizer swig_types[45]
2512 #define SWIGTYPE_p_wxFocusEvent swig_types[46]
2513 #define SWIGTYPE_p_wxFont swig_types[47]
2514 #define SWIGTYPE_p_wxFrame swig_types[48]
2515 #define SWIGTYPE_p_wxGBPosition swig_types[49]
2516 #define SWIGTYPE_p_wxGBSizerItem swig_types[50]
2517 #define SWIGTYPE_p_wxGBSpan swig_types[51]
2518 #define SWIGTYPE_p_wxGIFHandler swig_types[52]
2519 #define SWIGTYPE_p_wxGridBagSizer swig_types[53]
2520 #define SWIGTYPE_p_wxGridSizer swig_types[54]
2521 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[55]
2522 #define SWIGTYPE_p_wxICOHandler swig_types[56]
2523 #define SWIGTYPE_p_wxIconizeEvent swig_types[57]
2524 #define SWIGTYPE_p_wxIdleEvent swig_types[58]
2525 #define SWIGTYPE_p_wxImage swig_types[59]
2526 #define SWIGTYPE_p_wxImageHandler swig_types[60]
2527 #define SWIGTYPE_p_wxImageHistogram swig_types[61]
2528 #define SWIGTYPE_p_wxImage_HSVValue swig_types[62]
2529 #define SWIGTYPE_p_wxImage_RGBValue swig_types[63]
2530 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[64]
2531 #define SWIGTYPE_p_wxInitDialogEvent swig_types[65]
2532 #define SWIGTYPE_p_wxInputStream swig_types[66]
2533 #define SWIGTYPE_p_wxInternetFSHandler swig_types[67]
2534 #define SWIGTYPE_p_wxItemContainer swig_types[68]
2535 #define SWIGTYPE_p_wxJPEGHandler swig_types[69]
2536 #define SWIGTYPE_p_wxKeyEvent swig_types[70]
2537 #define SWIGTYPE_p_wxLayoutConstraints swig_types[71]
2538 #define SWIGTYPE_p_wxMaximizeEvent swig_types[72]
2539 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[73]
2540 #define SWIGTYPE_p_wxMenu swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBar swig_types[75]
2542 #define SWIGTYPE_p_wxMenuBarBase swig_types[76]
2543 #define SWIGTYPE_p_wxMenuEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMenuItem swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMouseEvent swig_types[81]
2548 #define SWIGTYPE_p_wxMoveEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNcPaintEvent swig_types[84]
2551 #define SWIGTYPE_p_wxNotifyEvent swig_types[85]
2552 #define SWIGTYPE_p_wxObject swig_types[86]
2553 #define SWIGTYPE_p_wxOutputStream swig_types[87]
2554 #define SWIGTYPE_p_wxPCXHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNGHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPNMHandler swig_types[90]
2557 #define SWIGTYPE_p_wxPaintEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[92]
2559 #define SWIGTYPE_p_wxPaperSize swig_types[93]
2560 #define SWIGTYPE_p_wxPoint swig_types[94]
2561 #define SWIGTYPE_p_wxPoint2D swig_types[95]
2562 #define SWIGTYPE_p_wxPosition swig_types[96]
2563 #define SWIGTYPE_p_wxPropagateOnce swig_types[97]
2564 #define SWIGTYPE_p_wxPropagationDisabler swig_types[98]
2565 #define SWIGTYPE_p_wxPyApp swig_types[99]
2566 #define SWIGTYPE_p_wxPyCommandEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyDropTarget swig_types[101]
2568 #define SWIGTYPE_p_wxPyEvent swig_types[102]
2569 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[103]
2570 #define SWIGTYPE_p_wxPyImageHandler swig_types[104]
2571 #define SWIGTYPE_p_wxPyInputStream swig_types[105]
2572 #define SWIGTYPE_p_wxPySizer swig_types[106]
2573 #define SWIGTYPE_p_wxPyValidator swig_types[107]
2574 #define SWIGTYPE_p_wxQuantize swig_types[108]
2575 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[109]
2576 #define SWIGTYPE_p_wxRealPoint swig_types[110]
2577 #define SWIGTYPE_p_wxRect swig_types[111]
2578 #define SWIGTYPE_p_wxRect2D swig_types[112]
2579 #define SWIGTYPE_p_wxRegion swig_types[113]
2580 #define SWIGTYPE_p_wxScrollEvent swig_types[114]
2581 #define SWIGTYPE_p_wxScrollWinEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSetCursorEvent swig_types[116]
2583 #define SWIGTYPE_p_wxShowEvent swig_types[117]
2584 #define SWIGTYPE_p_wxSize swig_types[118]
2585 #define SWIGTYPE_p_wxSizeEvent swig_types[119]
2586 #define SWIGTYPE_p_wxSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSizerFlags swig_types[121]
2588 #define SWIGTYPE_p_wxSizerItem swig_types[122]
2589 #define SWIGTYPE_p_wxStaticBox swig_types[123]
2590 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[124]
2591 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[125]
2592 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[126]
2593 #define SWIGTYPE_p_wxTGAHandler swig_types[127]
2594 #define SWIGTYPE_p_wxTIFFHandler swig_types[128]
2595 #define SWIGTYPE_p_wxToolTip swig_types[129]
2596 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[130]
2597 #define SWIGTYPE_p_wxValidator swig_types[131]
2598 #define SWIGTYPE_p_wxVisualAttributes swig_types[132]
2599 #define SWIGTYPE_p_wxWindow swig_types[133]
2600 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[134]
2601 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[135]
2602 #define SWIGTYPE_p_wxXPMHandler swig_types[136]
2603 #define SWIGTYPE_p_wxZipFSHandler swig_types[137]
2604 static swig_type_info *swig_types[139];
2605 static swig_module_info swig_module = {swig_types, 138, 0, 0, 0, 0};
2606 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2607 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2608
2609 /* -------- TYPES TABLE (END) -------- */
2610
2611 #if (PY_VERSION_HEX <= 0x02000000)
2612 # if !defined(SWIG_PYTHON_CLASSIC)
2613 # error "This python version requires to use swig with the '-classic' option"
2614 # endif
2615 #endif
2616 #if (PY_VERSION_HEX <= 0x02020000)
2617 # error "This python version requires to use swig with the '-nomodern' option"
2618 #endif
2619 #if (PY_VERSION_HEX <= 0x02020000)
2620 # error "This python version requires to use swig with the '-nomodernargs' option"
2621 #endif
2622 #ifndef METH_O
2623 # error "This python version requires to use swig with the '-nofastunpack' option"
2624 #endif
2625
2626 /*-----------------------------------------------
2627 @(target):= _core_.so
2628 ------------------------------------------------*/
2629 #define SWIG_init init_core_
2630
2631 #define SWIG_name "_core_"
2632
2633 #define SWIGVERSION 0x010329
2634
2635
2636 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2637 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2638
2639
2640 #include <stdexcept>
2641
2642
2643 namespace swig {
2644 class PyObject_ptr {
2645 protected:
2646 PyObject *_obj;
2647
2648 public:
2649 PyObject_ptr() :_obj(0)
2650 {
2651 }
2652
2653 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2654 {
2655 Py_XINCREF(_obj);
2656 }
2657
2658 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2659 {
2660 if (initial_ref) Py_XINCREF(_obj);
2661 }
2662
2663 PyObject_ptr & operator=(const PyObject_ptr& item)
2664 {
2665 Py_XINCREF(item._obj);
2666 Py_XDECREF(_obj);
2667 _obj = item._obj;
2668 return *this;
2669 }
2670
2671 ~PyObject_ptr()
2672 {
2673 Py_XDECREF(_obj);
2674 }
2675
2676 operator PyObject *() const
2677 {
2678 return _obj;
2679 }
2680
2681 PyObject *operator->() const
2682 {
2683 return _obj;
2684 }
2685 };
2686 }
2687
2688
2689 namespace swig {
2690 struct PyObject_var : PyObject_ptr {
2691 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2692
2693 PyObject_var & operator = (PyObject* obj)
2694 {
2695 Py_XDECREF(_obj);
2696 _obj = obj;
2697 return *this;
2698 }
2699 };
2700 }
2701
2702
2703 #include "wx/wxPython/wxPython_int.h"
2704 #include "wx/wxPython/pyclasses.h"
2705 #include "wx/wxPython/twoitem.h"
2706
2707
2708 #ifndef wxPyUSE_EXPORT
2709 // Helper functions for dealing with SWIG objects and such. These are
2710 // located here so they know about the SWIG types and functions declared
2711 // in the wrapper code.
2712
2713 #include <wx/hashmap.h>
2714 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2715
2716
2717 // Maintains a hashmap of className to swig_type_info pointers. Given the
2718 // name of a class either looks up the type info in the cache, or scans the
2719 // SWIG tables for it.
2720 extern PyObject* wxPyPtrTypeMap;
2721 static
2722 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2723
2724 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2725
2726 if (typeInfoCache == NULL)
2727 typeInfoCache = new wxPyTypeInfoHashMap;
2728
2729 wxString name(className);
2730 swig_type_info* swigType = (*typeInfoCache)[name];
2731
2732 if (! swigType) {
2733 // it wasn't in the cache, so look it up from SWIG
2734 name.Append(wxT(" *"));
2735 swigType = SWIG_TypeQuery(name.mb_str());
2736
2737 // if it still wasn't found, try looking for a mapped name
2738 if (!swigType) {
2739 PyObject* item;
2740 name = className;
2741
2742 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2743 (char*)(const char*)name.mbc_str())) != NULL) {
2744 name = wxString(PyString_AsString(item), *wxConvCurrent);
2745 name.Append(wxT(" *"));
2746 swigType = SWIG_TypeQuery(name.mb_str());
2747 }
2748 }
2749 if (swigType) {
2750 // and add it to the map if found
2751 (*typeInfoCache)[className] = swigType;
2752 }
2753 }
2754 return swigType;
2755 }
2756
2757
2758 // Check if a class name is a type known to SWIG
2759 bool wxPyCheckSwigType(const wxChar* className) {
2760
2761 swig_type_info* swigType = wxPyFindSwigType(className);
2762 return swigType != NULL;
2763 }
2764
2765
2766 // Given a pointer to a C++ object and a class name, construct a Python proxy
2767 // object for it.
2768 PyObject* wxPyConstructObject(void* ptr,
2769 const wxChar* className,
2770 int setThisOwn) {
2771
2772 swig_type_info* swigType = wxPyFindSwigType(className);
2773 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2774
2775 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2776 }
2777
2778
2779 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2780 // Ensures that the proxy object is of the specified (or derived) type. If
2781 // not able to perform the conversion then a Python exception is set and the
2782 // error should be handled properly in the caller. Returns True on success.
2783 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2784 const wxChar* className) {
2785
2786 swig_type_info* swigType = wxPyFindSwigType(className);
2787 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2788
2789 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2790 }
2791
2792
2793
2794 // Make a SWIGified pointer object suitable for a .this attribute
2795 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2796
2797 PyObject* robj = NULL;
2798
2799 swig_type_info* swigType = wxPyFindSwigType(className);
2800 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2801
2802 robj = PySwigObject_New(ptr, swigType, 0);
2803 return robj;
2804 }
2805
2806
2807 // Python's PyInstance_Check does not return True for instances of new-style
2808 // classes. This should get close enough for both new and old classes but I
2809 // should re-evaluate the need for doing instance checks...
2810 bool wxPyInstance_Check(PyObject* obj) {
2811 return PyObject_HasAttrString(obj, "__class__") != 0;
2812 }
2813
2814
2815 // This one checks if the object is an instance of a SWIG proxy class (it has
2816 // a .this attribute, and the .this attribute is a PySwigObject.)
2817 bool wxPySwigInstance_Check(PyObject* obj) {
2818 static PyObject* this_str = NULL;
2819 if (this_str == NULL)
2820 this_str = PyString_FromString("this");
2821
2822 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2823 if (this_attr) {
2824 bool retval = (PySwigObject_Check(this_attr) != 0);
2825 Py_DECREF(this_attr);
2826 return retval;
2827 }
2828
2829 PyErr_Clear();
2830 return false;
2831 }
2832
2833
2834 // Export a C API in a struct. Other modules will be able to load this from
2835 // the wx._core_ module and will then have safe access to these functions,
2836 // even if they are located in another shared library.
2837 static wxPyCoreAPI API = {
2838
2839 wxPyCheckSwigType,
2840 wxPyConstructObject,
2841 wxPyConvertSwigPtr,
2842 wxPyMakeSwigPtr,
2843
2844 wxPyBeginAllowThreads,
2845 wxPyEndAllowThreads,
2846 wxPyBeginBlockThreads,
2847 wxPyEndBlockThreads,
2848
2849 wxPy_ConvertList,
2850
2851 wxString_in_helper,
2852 Py2wxString,
2853 wx2PyString,
2854
2855 byte_LIST_helper,
2856 int_LIST_helper,
2857 long_LIST_helper,
2858 string_LIST_helper,
2859 wxPoint_LIST_helper,
2860 wxBitmap_LIST_helper,
2861 wxString_LIST_helper,
2862 wxAcceleratorEntry_LIST_helper,
2863
2864 wxSize_helper,
2865 wxPoint_helper,
2866 wxRealPoint_helper,
2867 wxRect_helper,
2868 wxColour_helper,
2869 wxPoint2D_helper,
2870
2871 wxPySimple_typecheck,
2872 wxColour_typecheck,
2873
2874 wxPyCBH_setCallbackInfo,
2875 wxPyCBH_findCallback,
2876 wxPyCBH_callCallback,
2877 wxPyCBH_callCallbackObj,
2878 wxPyCBH_delete,
2879
2880 wxPyMake_wxObject,
2881 wxPyMake_wxSizer,
2882 wxPyPtrTypeMap_Add,
2883 wxPy2int_seq_helper,
2884 wxPy4int_seq_helper,
2885 wxArrayString2PyList_helper,
2886 wxArrayInt2PyList_helper,
2887
2888 wxPyClientData_dtor,
2889 wxPyUserData_dtor,
2890 wxPyOORClientData_dtor,
2891
2892 wxPyCBInputStream_create,
2893 wxPyCBInputStream_copy,
2894
2895 wxPyInstance_Check,
2896 wxPySwigInstance_Check,
2897
2898 wxPyCheckForApp,
2899
2900 wxArrayDouble2PyList_helper,
2901 wxPoint2D_LIST_helper,
2902 wxRect2D_helper,
2903 wxPosition_helper,
2904
2905 };
2906
2907 #endif
2908
2909
2910 #if !WXWIN_COMPATIBILITY_2_4
2911 #define wxHIDE_READONLY 0
2912 #endif
2913
2914
2915 #define SWIG_From_long PyInt_FromLong
2916
2917
2918 SWIGINTERNINLINE PyObject *
2919 SWIG_From_int (int value)
2920 {
2921 return SWIG_From_long (value);
2922 }
2923
2924 static const wxString wxPyEmptyString(wxEmptyString);
2925 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2926 return self->GetClassInfo()->GetClassName();
2927 }
2928 SWIGINTERN void wxObject_Destroy(wxObject *self){
2929 delete self;
2930 }
2931
2932 #ifndef __WXMAC__
2933 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2934 #endif
2935
2936
2937 #include <limits.h>
2938 #ifndef LLONG_MIN
2939 # define LLONG_MIN LONG_LONG_MIN
2940 #endif
2941 #ifndef LLONG_MAX
2942 # define LLONG_MAX LONG_LONG_MAX
2943 #endif
2944 #ifndef ULLONG_MAX
2945 # define ULLONG_MAX ULONG_LONG_MAX
2946 #endif
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_long (PyObject* obj, long* val)
2951 {
2952 if (PyNumber_Check(obj)) {
2953 if (val) *val = PyInt_AsLong(obj);
2954 return SWIG_OK;
2955 }
2956 return SWIG_TypeError;
2957 }
2958
2959
2960 SWIGINTERN int
2961 SWIG_AsVal_int (PyObject * obj, int *val)
2962 {
2963 long v;
2964 int res = SWIG_AsVal_long (obj, &v);
2965 if (SWIG_IsOK(res)) {
2966 if ((v < INT_MIN || v > INT_MAX)) {
2967 return SWIG_OverflowError;
2968 } else {
2969 if (val) *val = static_cast< int >(v);
2970 }
2971 }
2972 return res;
2973 }
2974
2975 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2976 wxSize temp, *obj = &temp;
2977 if ( other == Py_None ) return false;
2978 if ( ! wxSize_helper(other, &obj) ) {
2979 PyErr_Clear();
2980 return false;
2981 }
2982 return self->operator==(*obj);
2983 }
2984 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2985 wxSize temp, *obj = &temp;
2986 if ( other == Py_None ) return true;
2987 if ( ! wxSize_helper(other, &obj)) {
2988 PyErr_Clear();
2989 return true;
2990 }
2991 return self->operator!=(*obj);
2992 }
2993
2994 #include <float.h>
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_double (PyObject *obj, double* val)
2999 {
3000 if (PyNumber_Check(obj)) {
3001 if (val) *val = PyFloat_AsDouble(obj);
3002 return SWIG_OK;
3003 }
3004 return SWIG_TypeError;
3005 }
3006
3007
3008 SWIGINTERN int
3009 SWIG_AsVal_float (PyObject * obj, float *val)
3010 {
3011 double v;
3012 int res = SWIG_AsVal_double (obj, &v);
3013 if (SWIG_IsOK(res)) {
3014 if ((v < -FLT_MAX || v > FLT_MAX)) {
3015 return SWIG_OverflowError;
3016 } else {
3017 if (val) *val = static_cast< float >(v);
3018 }
3019 }
3020 return res;
3021 }
3022
3023 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3024 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3025 PyObject* tup = PyTuple_New(2);
3026 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3027 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3028 //wxPyEndBlockThreads(blocked);
3029 return tup;
3030 }
3031
3032 #define SWIG_From_double PyFloat_FromDouble
3033
3034 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3035 wxRealPoint temp, *obj = &temp;
3036 if ( other == Py_None ) return false;
3037 if ( ! wxRealPoint_helper(other, &obj) ) {
3038 PyErr_Clear();
3039 return false;
3040 }
3041 return self->operator==(*obj);
3042 }
3043 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3044 wxRealPoint temp, *obj = &temp;
3045 if ( other == Py_None ) return true;
3046 if ( ! wxRealPoint_helper(other, &obj)) {
3047 PyErr_Clear();
3048 return true;
3049 }
3050 return self->operator!=(*obj);
3051 }
3052 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3053 self->x = x;
3054 self->y = y;
3055 }
3056 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3057 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3058 PyObject* tup = PyTuple_New(2);
3059 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3060 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3061 //PyEndBlockThreads(blocked);
3062 return tup;
3063 }
3064 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3065 wxPoint temp, *obj = &temp;
3066 if ( other == Py_None ) return false;
3067 if ( ! wxPoint_helper(other, &obj) ) {
3068 PyErr_Clear();
3069 return false;
3070 }
3071 return self->operator==(*obj);
3072 }
3073 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3074 wxPoint temp, *obj = &temp;
3075 if ( other == Py_None ) return true;
3076 if ( ! wxPoint_helper(other, &obj)) {
3077 PyErr_Clear();
3078 return true;
3079 }
3080 return self->operator!=(*obj);
3081 }
3082 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3083 self->x = x;
3084 self->y = y;
3085 }
3086 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3087 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3088 PyObject* tup = PyTuple_New(2);
3089 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3090 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3091 //wxPyEndBlockThreads(blocked);
3092 return tup;
3093 }
3094 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3095 wxRect temp, *obj = &temp;
3096 if ( other == Py_None ) return false;
3097 if ( ! wxRect_helper(other, &obj) ) {
3098 PyErr_Clear();
3099 return false;
3100 }
3101 return self->operator==(*obj);
3102 }
3103 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3104 wxRect temp, *obj = &temp;
3105 if ( other == Py_None ) return true;
3106 if ( ! wxRect_helper(other, &obj)) {
3107 PyErr_Clear();
3108 return true;
3109 }
3110 return self->operator!=(*obj);
3111 }
3112 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3113 self->x = x;
3114 self->y = y;
3115 self->width = width;
3116 self->height = height;
3117 }
3118 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3119 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3120 PyObject* tup = PyTuple_New(4);
3121 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3122 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3123 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3124 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3125 //wxPyEndBlockThreads(blocked);
3126 return tup;
3127 }
3128
3129 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3130 wxRegion reg1(*r1);
3131 wxRegion reg2(*r2);
3132 wxRect dest(0,0,0,0);
3133 PyObject* obj;
3134
3135 reg1.Intersect(reg2);
3136 dest = reg1.GetBox();
3137
3138 if (dest != wxRect(0,0,0,0)) {
3139 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3140 wxRect* newRect = new wxRect(dest);
3141 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3142 //wxPyEndBlockThreads(blocked);
3143 return obj;
3144 }
3145 Py_INCREF(Py_None);
3146 return Py_None;
3147 }
3148
3149 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3150 wxPoint2D temp, *obj = &temp;
3151 if ( other == Py_None ) return false;
3152 if ( ! wxPoint2D_helper(other, &obj) ) {
3153 PyErr_Clear();
3154 return false;
3155 }
3156 return self->operator==(*obj);
3157 }
3158 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3159 wxPoint2D temp, *obj = &temp;
3160 if ( other == Py_None ) return true;
3161 if ( ! wxPoint2D_helper(other, &obj)) {
3162 PyErr_Clear();
3163 return true;
3164 }
3165 return self->operator!=(*obj);
3166 }
3167 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3168 self->m_x = x;
3169 self->m_y = y;
3170 }
3171 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3172 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3173 PyObject* tup = PyTuple_New(2);
3174 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3175 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3176 //wxPyEndBlockThreads(blocked);
3177 return tup;
3178 }
3179 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3180 wxRect2D temp, *obj = &temp;
3181 if ( other == Py_None ) return false;
3182 if ( ! wxRect2D_helper(other, &obj) ) {
3183 PyErr_Clear();
3184 return false;
3185 }
3186 return self->operator==(*obj);
3187 }
3188 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3189 wxRect2D temp, *obj = &temp;
3190 if ( other == Py_None ) return true;
3191 if ( ! wxRect2D_helper(other, &obj)) {
3192 PyErr_Clear();
3193 return true;
3194 }
3195 return self->operator!=(*obj);
3196 }
3197 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3198 self->m_x = x;
3199 self->m_y = y;
3200 self->m_width = width;
3201 self->m_height = height;
3202 }
3203 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3204 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3205 PyObject* tup = PyTuple_New(4);
3206 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3207 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3208 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3209 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3210 //wxPyEndBlockThreads(blocked);
3211 return tup;
3212 }
3213 SWIGINTERN bool wxPosition___eq__(wxPosition *self,PyObject *other){
3214 wxPosition temp, *obj = &temp;
3215 if ( other == Py_None ) return false;
3216 if ( ! wxPosition_helper(other, &obj) ) {
3217 PyErr_Clear();
3218 return false;
3219 }
3220 return self->operator==(*obj);
3221 }
3222 SWIGINTERN bool wxPosition___ne__(wxPosition *self,PyObject *other){
3223 wxPosition temp, *obj = &temp;
3224 if ( other == Py_None ) return true;
3225 if ( ! wxPosition_helper(other, &obj)) {
3226 PyErr_Clear();
3227 return true;
3228 }
3229 return self->operator!=(*obj);
3230 }
3231
3232 #include "wx/wxPython/pyistream.h"
3233
3234 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3235 wxInputStream* wxis = wxPyCBInputStream::create(p);
3236 if (wxis)
3237 return new wxPyInputStream(wxis);
3238 else
3239 return NULL;
3240 }
3241
3242 SWIGINTERN swig_type_info*
3243 SWIG_pchar_descriptor()
3244 {
3245 static int init = 0;
3246 static swig_type_info* info = 0;
3247 if (!init) {
3248 info = SWIG_TypeQuery("_p_char");
3249 init = 1;
3250 }
3251 return info;
3252 }
3253
3254
3255 SWIGINTERNINLINE PyObject *
3256 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3257 {
3258 if (carray) {
3259 if (size > INT_MAX) {
3260 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3261 return pchar_descriptor ?
3262 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3263 } else {
3264 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3265 }
3266 } else {
3267 return SWIG_Py_Void();
3268 }
3269 }
3270
3271
3272 SWIGINTERNINLINE PyObject *
3273 SWIG_From_char (char c)
3274 {
3275 return SWIG_FromCharPtrAndSize(&c,1);
3276 }
3277
3278
3279 SWIGINTERNINLINE PyObject*
3280 SWIG_From_unsigned_SS_long (unsigned long value)
3281 {
3282 return (value > LONG_MAX) ?
3283 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3284 }
3285
3286
3287 SWIGINTERNINLINE PyObject *
3288 SWIG_From_size_t (size_t value)
3289 {
3290 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3291 }
3292
3293
3294 SWIGINTERN int
3295 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3296 {
3297 if (PyString_Check(obj)) {
3298 char *cstr; Py_ssize_t len;
3299 PyString_AsStringAndSize(obj, &cstr, &len);
3300 if (cptr) {
3301 if (alloc) {
3302 /*
3303 In python the user should not be able to modify the inner
3304 string representation. To warranty that, if you define
3305 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3306 buffer is always returned.
3307
3308 The default behavior is just to return the pointer value,
3309 so, be careful.
3310 */
3311 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3312 if (*alloc != SWIG_OLDOBJ)
3313 #else
3314 if (*alloc == SWIG_NEWOBJ)
3315 #endif
3316 {
3317 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3318 *alloc = SWIG_NEWOBJ;
3319 }
3320 else {
3321 *cptr = cstr;
3322 *alloc = SWIG_OLDOBJ;
3323 }
3324 } else {
3325 *cptr = PyString_AsString(obj);
3326 }
3327 }
3328 if (psize) *psize = len + 1;
3329 return SWIG_OK;
3330 } else {
3331 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3332 if (pchar_descriptor) {
3333 void* vptr = 0;
3334 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3335 if (cptr) *cptr = (char *) vptr;
3336 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3337 if (alloc) *alloc = SWIG_OLDOBJ;
3338 return SWIG_OK;
3339 }
3340 }
3341 }
3342 return SWIG_TypeError;
3343 }
3344
3345
3346 SWIGINTERN int
3347 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3348 {
3349 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3350 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3351 if (SWIG_IsOK(res)) {
3352 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3353 if (csize <= size) {
3354 if (val) {
3355 if (csize) memcpy(val, cptr, csize*sizeof(char));
3356 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3357 }
3358 if (alloc == SWIG_NEWOBJ) {
3359 delete[] cptr;
3360 res = SWIG_DelNewMask(res);
3361 }
3362 return res;
3363 }
3364 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3365 }
3366 return SWIG_TypeError;
3367 }
3368
3369
3370 SWIGINTERN int
3371 SWIG_AsVal_char (PyObject * obj, char *val)
3372 {
3373 int res = SWIG_AsCharArray(obj, val, 1);
3374 if (!SWIG_IsOK(res)) {
3375 long v;
3376 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3377 if (SWIG_IsOK(res)) {
3378 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3379 if (val) *val = static_cast< char >(v);
3380 } else {
3381 res = SWIG_OverflowError;
3382 }
3383 }
3384 }
3385 return res;
3386 }
3387
3388 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3389 // We use only strings for the streams, not unicode
3390 PyObject* str = PyObject_Str(obj);
3391 if (! str) {
3392 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3393 return;
3394 }
3395 self->Write(PyString_AS_STRING(str),
3396 PyString_GET_SIZE(str));
3397 Py_DECREF(str);
3398 }
3399
3400 #include "wx/wxPython/pyistream.h"
3401
3402
3403 class wxPyFileSystemHandler : public wxFileSystemHandler
3404 {
3405 public:
3406 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3407
3408 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3409 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3410 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3411 DEC_PYCALLBACK_STRING__pure(FindNext);
3412
3413 wxString GetProtocol(const wxString& location) {
3414 return wxFileSystemHandler::GetProtocol(location);
3415 }
3416
3417 wxString GetLeftLocation(const wxString& location) {
3418 return wxFileSystemHandler::GetLeftLocation(location);
3419 }
3420
3421 wxString GetAnchor(const wxString& location) {
3422 return wxFileSystemHandler::GetAnchor(location);
3423 }
3424
3425 wxString GetRightLocation(const wxString& location) {
3426 return wxFileSystemHandler::GetRightLocation(location);
3427 }
3428
3429 wxString GetMimeTypeFromExt(const wxString& location) {
3430 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3431 }
3432
3433 PYPRIVATE;
3434 };
3435
3436
3437 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3438 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3439 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3440 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3441
3442
3443 SWIGINTERN int
3444 SWIG_AsVal_bool (PyObject *obj, bool *val)
3445 {
3446 if (obj == Py_True) {
3447 if (val) *val = true;
3448 return SWIG_OK;
3449 } else if (obj == Py_False) {
3450 if (val) *val = false;
3451 return SWIG_OK;
3452 } else {
3453 long v = 0;
3454 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3455 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3456 return res;
3457 }
3458 }
3459
3460 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3461 wxFileName fname = wxFileSystem::URLToFileName(url);
3462 return fname.GetFullPath();
3463 }
3464
3465 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3466 wxImage& image,
3467 long type) {
3468 wxMemoryFSHandler::AddFile(filename, image, type);
3469 }
3470
3471 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3472 const wxBitmap& bitmap,
3473 long type) {
3474 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3475 }
3476
3477 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3478 PyObject* data) {
3479 if (! PyString_Check(data)) {
3480 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3481 "Expected string object"));
3482 return;
3483 }
3484
3485 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3486 void* ptr = (void*)PyString_AsString(data);
3487 size_t size = PyString_Size(data);
3488 wxPyEndBlockThreads(blocked);
3489
3490 wxMemoryFSHandler::AddFile(filename, ptr, size);
3491 }
3492
3493
3494 #include "wx/wxPython/pyistream.h"
3495
3496
3497 SWIGINTERN int
3498 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3499 {
3500 long v = 0;
3501 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3502 return SWIG_TypeError;
3503 }
3504 else if (val)
3505 *val = (unsigned long)v;
3506 return SWIG_OK;
3507 }
3508
3509
3510 SWIGINTERN int
3511 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3512 {
3513 unsigned long v;
3514 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3515 if (SWIG_IsOK(res)) {
3516 if ((v > UCHAR_MAX)) {
3517 return SWIG_OverflowError;
3518 } else {
3519 if (val) *val = static_cast< unsigned char >(v);
3520 }
3521 }
3522 return res;
3523 }
3524
3525
3526 SWIGINTERNINLINE PyObject *
3527 SWIG_From_unsigned_SS_char (unsigned char value)
3528 {
3529 return SWIG_From_unsigned_SS_long (value);
3530 }
3531
3532 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3533 wxImageHistogramEntry e = (*self)[key];
3534 return e.value;
3535 }
3536 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3537 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3538 wxImageHistogramEntry e = (*self)[key];
3539 return e.value;
3540 }
3541 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3542 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3543 colour.Green(),
3544 colour.Blue());
3545 wxImageHistogramEntry e = (*self)[key];
3546 return e.value;
3547 }
3548
3549 // Pull the nested class out to the top level for SWIG's sake
3550 #define wxImage_RGBValue wxImage::RGBValue
3551 #define wxImage_HSVValue wxImage::HSVValue
3552
3553 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3554 if (width > 0 && height > 0)
3555 return new wxImage(width, height, clear);
3556 else
3557 return new wxImage;
3558 }
3559 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3560 return new wxImage(bitmap.ConvertToImage());
3561 }
3562 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3563 if (DATASIZE != width*height*3) {
3564 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3565 return NULL;
3566 }
3567
3568 // Copy the source data so the wxImage can clean it up later
3569 buffer copy = (buffer)malloc(DATASIZE);
3570 if (copy == NULL) {
3571 wxPyBLOCK_THREADS(PyErr_NoMemory());
3572 return NULL;
3573 }
3574 memcpy(copy, data, DATASIZE);
3575 return new wxImage(width, height, copy, false);
3576 }
3577 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3578 if (DATASIZE != width*height*3) {
3579 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3580 return NULL;
3581 }
3582 if (ALPHASIZE != width*height) {
3583 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3584 return NULL;
3585 }
3586
3587 // Copy the source data so the wxImage can clean it up later
3588 buffer dcopy = (buffer)malloc(DATASIZE);
3589 if (dcopy == NULL) {
3590 wxPyBLOCK_THREADS(PyErr_NoMemory());
3591 return NULL;
3592 }
3593 memcpy(dcopy, data, DATASIZE);
3594
3595 buffer acopy = (buffer)malloc(ALPHASIZE);
3596 if (acopy == NULL) {
3597 wxPyBLOCK_THREADS(PyErr_NoMemory());
3598 return NULL;
3599 }
3600 memcpy(acopy, alpha, ALPHASIZE);
3601
3602 return new wxImage(width, height, dcopy, acopy, false);
3603 }
3604 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3605 wxSize size(self->GetWidth(), self->GetHeight());
3606 return size;
3607 }
3608 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3609 buffer data = self->GetData();
3610 int len = self->GetWidth() * self->GetHeight() * 3;
3611 PyObject* rv;
3612 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3613 return rv;
3614 }
3615 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3616 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3617 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3618 return;
3619 }
3620 buffer copy = (buffer)malloc(DATASIZE);
3621 if (copy == NULL) {
3622 wxPyBLOCK_THREADS(PyErr_NoMemory());
3623 return;
3624 }
3625 memcpy(copy, data, DATASIZE);
3626 self->SetData(copy, false);
3627 // wxImage takes ownership of copy...
3628 }
3629 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3630 buffer data = self->GetData();
3631 int len = self->GetWidth() * self->GetHeight() * 3;
3632 PyObject* rv;
3633 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3634 return rv;
3635 }
3636 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3637 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return;
3640 }
3641 self->SetData(data, true);
3642 }
3643 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3644 buffer data = self->GetAlpha();
3645 if (! data) {
3646 RETURN_NONE();
3647 } else {
3648 int len = self->GetWidth() * self->GetHeight();
3649 PyObject* rv;
3650 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3651 return rv;
3652 }
3653 }
3654 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3655 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3656 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3657 return;
3658 }
3659 buffer acopy = (buffer)malloc(ALPHASIZE);
3660 if (acopy == NULL) {
3661 wxPyBLOCK_THREADS(PyErr_NoMemory());
3662 return;
3663 }
3664 memcpy(acopy, alpha, ALPHASIZE);
3665 self->SetAlpha(acopy, false);
3666 // wxImage takes ownership of acopy...
3667 }
3668 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3669 buffer data = self->GetAlpha();
3670 int len = self->GetWidth() * self->GetHeight();
3671 PyObject* rv;
3672 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3673 return rv;
3674 }
3675 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3676 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3677 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3678 return;
3679 }
3680 self->SetAlpha(alpha, true);
3681 }
3682 SWIGINTERN PyObject *wxImage_GetHandlers(){
3683 wxList& list = wxImage::GetHandlers();
3684 return wxPy_ConvertList(&list);
3685 }
3686 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3687 wxBitmap bitmap(*self, depth);
3688 return bitmap;
3689 }
3690 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3691 wxImage mono = self->ConvertToMono( red, green, blue );
3692 wxBitmap bitmap( mono, 1 );
3693 return bitmap;
3694 }
3695
3696 wxImage* _ImageFromBuffer(int width, int height,
3697 buffer data, int DATASIZE,
3698 buffer alpha=NULL, int ALPHASIZE=0)
3699 {
3700 if (DATASIZE != width*height*3) {
3701 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3702 return NULL;
3703 }
3704 if (alpha != NULL) {
3705 if (ALPHASIZE != width*height) {
3706 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3707 return NULL;
3708 }
3709 return new wxImage(width, height, data, alpha, true);
3710 }
3711 return new wxImage(width, height, data, true);
3712 }
3713
3714 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3715 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3716 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3717 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3718 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3719 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3720 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3721 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3722 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3723 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3724 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3725 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3726 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3727 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3728 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3729
3730 #include <wx/imagtga.h>
3731
3732
3733 #include <wx/quantize.h>
3734
3735 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3736 return wxQuantize::Quantize(src, dest,
3737 //NULL, // palette
3738 desiredNoColours,
3739 NULL, // eightBitData
3740 flags);
3741 }
3742 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3743 if (PyCallable_Check(func)) {
3744 self->Connect(id, lastId, eventType,
3745 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3746 new wxPyCallback(func));
3747 }
3748 else if (func == Py_None) {
3749 self->Disconnect(id, lastId, eventType,
3750 (wxObjectEventFunction)
3751 &wxPyCallback::EventThunker);
3752 }
3753 else {
3754 wxPyBLOCK_THREADS(
3755 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3756 }
3757 }
3758 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3759 return self->Disconnect(id, lastId, eventType,
3760 (wxObjectEventFunction)
3761 &wxPyCallback::EventThunker);
3762 }
3763 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3764 if (_self && _self != Py_None) {
3765 self->SetClientObject(new wxPyOORClientData(_self, incref));
3766 }
3767 else {
3768 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3769 if (data) {
3770 self->SetClientObject(NULL); // This will delete it too
3771 }
3772 }
3773 }
3774
3775 #if ! wxUSE_HOTKEY
3776 #define wxEVT_HOTKEY -9999
3777 #endif
3778
3779 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3780 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3781 if (data) {
3782 Py_INCREF(data->m_obj);
3783 return data->m_obj;
3784 } else {
3785 Py_INCREF(Py_None);
3786 return Py_None;
3787 }
3788 }
3789 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3790 wxPyClientData* data = new wxPyClientData(clientData);
3791 self->SetClientObject(data);
3792 }
3793 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3794 #if wxUSE_UNICODE
3795 return self->GetUnicodeKey();
3796 #else
3797 return 0;
3798 #endif
3799 }
3800 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3801 #if wxUSE_UNICODE
3802 self->m_uniChar = uniChar;
3803 #endif
3804 }
3805
3806 SWIGINTERNINLINE PyObject *
3807 SWIG_From_unsigned_SS_int (unsigned int value)
3808 {
3809 return SWIG_From_unsigned_SS_long (value);
3810 }
3811
3812
3813 SWIGINTERN int
3814 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3815 {
3816 unsigned long v;
3817 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3818 if (SWIG_IsOK(res)) {
3819 if ((v > UINT_MAX)) {
3820 return SWIG_OverflowError;
3821 } else {
3822 if (val) *val = static_cast< unsigned int >(v);
3823 }
3824 }
3825 return res;
3826 }
3827
3828 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3829 self->m_size = size;
3830 }
3831 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3832 int count = self->GetNumberOfFiles();
3833 wxString* files = self->GetFiles();
3834 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3835 PyObject* list = PyList_New(count);
3836
3837 if (!list) {
3838 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3839 wxPyEndBlockThreads(blocked);
3840 return NULL;
3841 }
3842
3843 for (int i=0; i<count; i++) {
3844 PyList_SetItem(list, i, wx2PyString(files[i]));
3845 }
3846 wxPyEndBlockThreads(blocked);
3847 return list;
3848 }
3849
3850
3851 SWIGINTERN wxPyApp *new_wxPyApp(){
3852 wxPythonApp = new wxPyApp();
3853 return wxPythonApp;
3854 }
3855 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3856 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3857 return wxPyTestDisplayAvailable();
3858 }
3859
3860 void wxApp_CleanUp() {
3861 __wxPyCleanup();
3862 }
3863
3864
3865 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3866
3867
3868
3869
3870
3871 SWIGINTERNINLINE PyObject *
3872 SWIG_FromCharPtr(const char *cptr)
3873 {
3874 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3875 }
3876
3877
3878 #if 0 // #ifdef __WXMAC__
3879
3880 // A dummy class that raises an exception if used...
3881 class wxEventLoop
3882 {
3883 public:
3884 wxEventLoop() { wxPyRaiseNotImplemented(); }
3885 int Run() { return 0; }
3886 void Exit(int rc = 0) {}
3887 bool Pending() const { return false; }
3888 bool Dispatch() { return false; }
3889 bool IsRunning() const { return false; }
3890 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3891 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3892 };
3893
3894 #else
3895
3896 #include <wx/evtloop.h>
3897
3898 #endif
3899
3900
3901
3902 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3903 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3904 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3905 SWIGINTERN wxFont wxVisualAttributes__get_font(wxVisualAttributes *self){ return self->font; }
3906 SWIGINTERN wxColour wxVisualAttributes__get_colFg(wxVisualAttributes *self){ return self->colFg; }
3907 SWIGINTERN wxColour wxVisualAttributes__get_colBg(wxVisualAttributes *self){ return self->colBg; }
3908 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3909 wxWindowList& list = self->GetChildren();
3910 return wxPy_ConvertList(&list);
3911 }
3912 SWIGINTERN wxWindow *wxWindow_GetTopLevelParent(wxWindow *self){
3913 return wxGetTopLevelParent(self);
3914 }
3915 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3916 #if wxUSE_HOTKEY
3917 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3918 #else
3919 return false;
3920 #endif
3921 }
3922 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3923
3924
3925
3926 return false;
3927
3928 }
3929 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3930 return wxPyGetWinHandle(self);
3931 }
3932 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3933 self->AssociateHandle((WXWidget)handle);
3934 }
3935 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3936
3937 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3938 return wxWindow::FindWindowById(id, parent);
3939 }
3940
3941 wxWindow* wxFindWindowByName( const wxString& name,
3942 const wxWindow *parent = NULL ) {
3943 return wxWindow::FindWindowByName(name, parent);
3944 }
3945
3946 wxWindow* wxFindWindowByLabel( const wxString& label,
3947 const wxWindow *parent = NULL ) {
3948 return wxWindow::FindWindowByLabel(label, parent);
3949 }
3950
3951
3952 #ifdef __WXMSW__
3953 #include <wx/msw/private.h> // to get wxGetWindowId
3954 #endif
3955
3956
3957 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3958 #ifdef __WXMSW__
3959 WXHWND hWnd = (WXHWND)_hWnd;
3960 long id = wxGetWindowId(hWnd);
3961 wxWindow* win = new wxWindow;
3962 if (parent)
3963 parent->AddChild(win);
3964 win->SetEventHandler(win);
3965 win->SetHWND(hWnd);
3966 win->SetId(id);
3967 win->SubclassWin(hWnd);
3968 win->AdoptAttributesFromHWND();
3969 win->SetupColours();
3970 return win;
3971 #else
3972 wxPyRaiseNotImplemented();
3973 return NULL;
3974 #endif
3975 }
3976
3977
3978 PyObject* GetTopLevelWindows() {
3979 return wxPy_ConvertList(&wxTopLevelWindows);
3980 }
3981
3982
3983 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3984 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3985 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3986
3987 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3988
3989
3990 SWIGINTERNINLINE int
3991 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3992 {
3993 unsigned long v;
3994 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3995 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3996 return res;
3997 }
3998
3999 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
4000 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
4001 wxMenuItemList& list = self->GetMenuItems();
4002 return wxPy_ConvertList(&list);
4003 }
4004 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
4005 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
4006 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
4007 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
4008 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
4009 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
4010 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
4011 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
4012 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
4013 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
4014 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
4015 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
4016 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
4017 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
4018 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
4019 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
4020 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
4021 static const wxString wxPyControlNameStr(wxControlNameStr);
4022 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
4023 if (clientData) {
4024 wxPyClientData* data = new wxPyClientData(clientData);
4025 return self->Append(item, data);
4026 } else
4027 return self->Append(item);
4028 }
4029 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
4030 if (clientData) {
4031 wxPyClientData* data = new wxPyClientData(clientData);
4032 return self->Insert(item, pos, data);
4033 } else
4034 return self->Insert(item, pos);
4035 }
4036 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
4037 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4038 if (data) {
4039 Py_INCREF(data->m_obj);
4040 return data->m_obj;
4041 } else {
4042 Py_INCREF(Py_None);
4043 return Py_None;
4044 }
4045 }
4046 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
4047 wxPyClientData* data = new wxPyClientData(clientData);
4048 self->SetClientObject(n, data);
4049 }
4050
4051
4052 SWIGINTERN wxSizerFlags &wxSizerFlags_Border(wxSizerFlags *self,int direction=wxALL,int borderInPixels=-1){
4053 if (borderInPixels == -1)
4054 return self->Border(direction);
4055 else
4056 return self->Border(direction, borderInPixels);
4057 }
4058 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4059 wxPyUserData* data = NULL;
4060 if ( userData ) {
4061 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4062 data = new wxPyUserData(userData);
4063 wxPyEndBlockThreads(blocked);
4064 }
4065 return new wxSizerItem(window, proportion, flag, border, data);
4066 }
4067 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4068 wxPyUserData* data = NULL;
4069 if ( userData ) {
4070 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4071 data = new wxPyUserData(userData);
4072 wxPyEndBlockThreads(blocked);
4073 }
4074 return new wxSizerItem(width, height, proportion, flag, border, data);
4075 }
4076 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4077 wxPyUserData* data = NULL;
4078 if ( userData ) {
4079 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4080 data = new wxPyUserData(userData);
4081 wxPyEndBlockThreads(blocked);
4082 }
4083 return new wxSizerItem(sizer, proportion, flag, border, data);
4084 }
4085
4086 SWIGINTERNINLINE PyObject *
4087 SWIG_From_float (float value)
4088 {
4089 return SWIG_From_double (value);
4090 }
4091
4092 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4093 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4094 if (data) {
4095 Py_INCREF(data->m_obj);
4096 return data->m_obj;
4097 } else {
4098 Py_INCREF(Py_None);
4099 return Py_None;
4100 }
4101 }
4102 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4103 wxPyUserData* data = NULL;
4104 if ( userData ) {
4105 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4106 data = new wxPyUserData(userData);
4107 wxPyEndBlockThreads(blocked);
4108 }
4109 self->SetUserData(data);
4110 }
4111
4112 // Figure out the type of the sizer item
4113
4114 struct wxPySizerItemInfo {
4115 wxPySizerItemInfo()
4116 : window(NULL), sizer(NULL), gotSize(false),
4117 size(wxDefaultSize), gotPos(false), pos(-1)
4118 {}
4119
4120 wxWindow* window;
4121 wxSizer* sizer;
4122 bool gotSize;
4123 wxSize size;
4124 bool gotPos;
4125 int pos;
4126 };
4127
4128 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4129
4130 wxPySizerItemInfo info;
4131 wxSize size;
4132 wxSize* sizePtr = &size;
4133
4134 // Find out what the type of the item is
4135 // try wxWindow
4136 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4137 PyErr_Clear();
4138 info.window = NULL;
4139
4140 // try wxSizer
4141 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4142 PyErr_Clear();
4143 info.sizer = NULL;
4144
4145 // try wxSize or (w,h)
4146 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4147 info.size = *sizePtr;
4148 info.gotSize = true;
4149 }
4150
4151 // or a single int
4152 if (checkIdx && PyInt_Check(item)) {
4153 info.pos = PyInt_AsLong(item);
4154 info.gotPos = true;
4155 }
4156 }
4157 }
4158
4159 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4160 // no expected type, figure out what kind of error message to generate
4161 if ( !checkSize && !checkIdx )
4162 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4163 else if ( checkSize && !checkIdx )
4164 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4165 else if ( !checkSize && checkIdx)
4166 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4167 else
4168 // can this one happen?
4169 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4170 }
4171
4172 return info;
4173 }
4174
4175 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4176 if (!self->GetClientObject())
4177 self->SetClientObject(new wxPyOORClientData(_self));
4178 }
4179 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4180
4181 wxPyUserData* data = NULL;
4182 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4183 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4184 if ( userData && (info.window || info.sizer || info.gotSize) )
4185 data = new wxPyUserData(userData);
4186 if ( info.sizer )
4187 PyObject_SetAttrString(item,"thisown",Py_False);
4188 wxPyEndBlockThreads(blocked);
4189
4190 // Now call the real Add method if a valid item type was found
4191 if ( info.window )
4192 return self->Add(info.window, proportion, flag, border, data);
4193 else if ( info.sizer )
4194 return self->Add(info.sizer, proportion, flag, border, data);
4195 else if (info.gotSize)
4196 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4197 proportion, flag, border, data);
4198 else
4199 return NULL;
4200 }
4201 SWIGINTERN wxSizerItem *wxSizer_AddF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4202
4203 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4204 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4205 if ( info.sizer )
4206 PyObject_SetAttrString(item,"thisown",Py_False);
4207 wxPyEndBlockThreads(blocked);
4208
4209 // Now call the real Add method if a valid item type was found
4210 if ( info.window )
4211 return self->Add(info.window, flags);
4212 else if ( info.sizer )
4213 return self->Add(info.sizer, flags);
4214 else if (info.gotSize)
4215 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4216 flags.GetProportion(),
4217 flags.GetFlags(),
4218 flags.GetBorderInPixels());
4219 else
4220 return NULL;
4221 }
4222 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4223
4224 wxPyUserData* data = NULL;
4225 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4226 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4227 if ( userData && (info.window || info.sizer || info.gotSize) )
4228 data = new wxPyUserData(userData);
4229 if ( info.sizer )
4230 PyObject_SetAttrString(item,"thisown",Py_False);
4231 wxPyEndBlockThreads(blocked);
4232
4233 // Now call the real Insert method if a valid item type was found
4234 if ( info.window )
4235 return self->Insert(before, info.window, proportion, flag, border, data);
4236 else if ( info.sizer )
4237 return self->Insert(before, info.sizer, proportion, flag, border, data);
4238 else if (info.gotSize)
4239 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4240 proportion, flag, border, data);
4241 else
4242 return NULL;
4243 }
4244 SWIGINTERN wxSizerItem *wxSizer_InsertF(wxSizer *self,int before,PyObject *item,wxSizerFlags &flags){
4245
4246 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4247 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4248 if ( info.sizer )
4249 PyObject_SetAttrString(item,"thisown",Py_False);
4250 wxPyEndBlockThreads(blocked);
4251
4252 // Now call the real Insert method if a valid item type was found
4253 if ( info.window )
4254 return self->Insert(before, info.window, flags);
4255 else if ( info.sizer )
4256 return self->Insert(before, info.sizer, flags);
4257 else if (info.gotSize)
4258 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4259 flags.GetProportion(),
4260 flags.GetFlags(),
4261 flags.GetBorderInPixels());
4262 else
4263 return NULL;
4264 }
4265 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4266
4267 wxPyUserData* data = NULL;
4268 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4269 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4270 if ( userData && (info.window || info.sizer || info.gotSize) )
4271 data = new wxPyUserData(userData);
4272 if ( info.sizer )
4273 PyObject_SetAttrString(item,"thisown",Py_False);
4274 wxPyEndBlockThreads(blocked);
4275
4276 // Now call the real Prepend method if a valid item type was found
4277 if ( info.window )
4278 return self->Prepend(info.window, proportion, flag, border, data);
4279 else if ( info.sizer )
4280 return self->Prepend(info.sizer, proportion, flag, border, data);
4281 else if (info.gotSize)
4282 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4283 proportion, flag, border, data);
4284 else
4285 return NULL;
4286 }
4287 SWIGINTERN wxSizerItem *wxSizer_PrependF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4288
4289 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4290 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4291 if ( info.sizer )
4292 PyObject_SetAttrString(item,"thisown",Py_False);
4293 wxPyEndBlockThreads(blocked);
4294
4295 // Now call the real Add method if a valid item type was found
4296 if ( info.window )
4297 return self->Prepend(info.window, flags);
4298 else if ( info.sizer )
4299 return self->Prepend(info.sizer, flags);
4300 else if (info.gotSize)
4301 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4302 flags.GetProportion(),
4303 flags.GetFlags(),
4304 flags.GetBorderInPixels());
4305 else
4306 return NULL;
4307 }
4308 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4309 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4310 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4311 wxPyEndBlockThreads(blocked);
4312 if ( info.window )
4313 return false; //self->Remove(info.window);
4314 else if ( info.sizer )
4315 return self->Remove(info.sizer);
4316 else if ( info.gotPos )
4317 return self->Remove(info.pos);
4318 else
4319 return false;
4320 }
4321 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4322 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4323 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4324 wxPyEndBlockThreads(blocked);
4325 if ( info.window )
4326 return self->Detach(info.window);
4327 else if ( info.sizer )
4328 return self->Detach(info.sizer);
4329 else if ( info.gotPos )
4330 return self->Detach(info.pos);
4331 else
4332 return false;
4333 }
4334 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item,bool recursive=false){
4335 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4336 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4337 wxPyEndBlockThreads(blocked);
4338 if ( info.window )
4339 return self->GetItem(info.window, recursive);
4340 else if ( info.sizer )
4341 return self->GetItem(info.sizer, recursive);
4342 else if ( info.gotPos )
4343 return self->GetItem(info.pos);
4344 else
4345 return NULL;
4346 }
4347 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4348 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4349 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4350 wxPyEndBlockThreads(blocked);
4351 if ( info.window )
4352 self->SetItemMinSize(info.window, size);
4353 else if ( info.sizer )
4354 self->SetItemMinSize(info.sizer, size);
4355 else if ( info.gotPos )
4356 self->SetItemMinSize(info.pos, size);
4357 }
4358 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4359 wxSizerItemList& list = self->GetChildren();
4360 return wxPy_ConvertList(&list);
4361 }
4362 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4363 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4364 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4365 wxPyEndBlockThreads(blocked);
4366 if ( info.window )
4367 return self->Show(info.window, show, recursive);
4368 else if ( info.sizer )
4369 return self->Show(info.sizer, show, recursive);
4370 else if ( info.gotPos )
4371 return self->Show(info.pos, show);
4372 else
4373 return false;
4374 }
4375 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4376 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4377 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4378 wxPyEndBlockThreads(blocked);
4379 if ( info.window )
4380 return self->IsShown(info.window);
4381 else if ( info.sizer )
4382 return self->IsShown(info.sizer);
4383 else if ( info.gotPos )
4384 return self->IsShown(info.pos);
4385 else
4386 return false;
4387 }
4388
4389 // See pyclasses.h
4390 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4391 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4392 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4393
4394
4395
4396
4397 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4398 {
4399 if (source == Py_None) {
4400 **obj = wxGBPosition(-1,-1);
4401 return true;
4402 }
4403 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4404 }
4405
4406 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4407 {
4408 if (source == Py_None) {
4409 **obj = wxGBSpan(-1,-1);
4410 return true;
4411 }
4412 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4413 }
4414
4415
4416 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4417 wxGBPosition temp, *obj = &temp;
4418 if ( other == Py_None ) return false;
4419 if ( ! wxGBPosition_helper(other, &obj) ) {
4420 PyErr_Clear();
4421 return false;
4422 }
4423 return self->operator==(*obj);
4424 }
4425 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4426 wxGBPosition temp, *obj = &temp;
4427 if ( other == Py_None ) return true;
4428 if ( ! wxGBPosition_helper(other, &obj)) {
4429 PyErr_Clear();
4430 return true;
4431 }
4432 return self->operator!=(*obj);
4433 }
4434 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4435 self->SetRow(row);
4436 self->SetCol(col);
4437 }
4438 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4439 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4440 PyObject* tup = PyTuple_New(2);
4441 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4442 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4443 wxPyEndBlockThreads(blocked);
4444 return tup;
4445 }
4446 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4447 wxGBSpan temp, *obj = &temp;
4448 if ( other == Py_None ) return false;
4449 if ( ! wxGBSpan_helper(other, &obj) ) {
4450 PyErr_Clear();
4451 return false;
4452 }
4453 return self->operator==(*obj);
4454 }
4455 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4456 wxGBSpan temp, *obj = &temp;
4457 if ( other == Py_None ) return true;
4458 if ( ! wxGBSpan_helper(other, &obj)) {
4459 PyErr_Clear();
4460 return true;
4461 }
4462 return self->operator!=(*obj);
4463 }
4464 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4465 self->SetRowspan(rowspan);
4466 self->SetColspan(colspan);
4467 }
4468 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4469 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4470 PyObject* tup = PyTuple_New(2);
4471 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4472 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4473 wxPyEndBlockThreads(blocked);
4474 return tup;
4475 }
4476 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4477 wxPyUserData* data = NULL;
4478 if ( userData ) {
4479 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4480 data = new wxPyUserData(userData);
4481 wxPyEndBlockThreads(blocked);
4482 }
4483 return new wxGBSizerItem(window, pos, span, flag, border, data);
4484 }
4485 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4486 wxPyUserData* data = NULL;
4487 if ( userData ) {
4488 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4489 data = new wxPyUserData(userData);
4490 wxPyEndBlockThreads(blocked);
4491 }
4492 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4493 }
4494 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4495 wxPyUserData* data = NULL;
4496 if ( userData ) {
4497 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4498 data = new wxPyUserData(userData);
4499 wxPyEndBlockThreads(blocked);
4500 }
4501 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4502 }
4503 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4504 int row, col;
4505 self->GetEndPos(row, col);
4506 return wxGBPosition(row, col);
4507 }
4508 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4509
4510 wxPyUserData* data = NULL;
4511 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4512 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4513 if ( userData && (info.window || info.sizer || info.gotSize) )
4514 data = new wxPyUserData(userData);
4515 if ( info.sizer )
4516 PyObject_SetAttrString(item,"thisown",Py_False);
4517 wxPyEndBlockThreads(blocked);
4518
4519 // Now call the real Add method if a valid item type was found
4520 if ( info.window )
4521 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4522 else if ( info.sizer )
4523 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4524 else if (info.gotSize)
4525 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4526 pos, span, flag, border, data);
4527 return NULL;
4528 }
4529
4530
4531 #ifdef __cplusplus
4532 extern "C" {
4533 #endif
4534 SWIGINTERN int EmptyString_set(PyObject *) {
4535 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4536 return 1;
4537 }
4538
4539
4540 SWIGINTERN PyObject *EmptyString_get(void) {
4541 PyObject *pyobj = 0;
4542
4543 {
4544 #if wxUSE_UNICODE
4545 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4546 #else
4547 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4548 #endif
4549 }
4550 return pyobj;
4551 }
4552
4553
4554 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4555 PyObject *resultobj = 0;
4556 wxObject *arg1 = (wxObject *) 0 ;
4557 wxString result;
4558 void *argp1 = 0 ;
4559 int res1 = 0 ;
4560 PyObject *swig_obj[1] ;
4561
4562 if (!args) SWIG_fail;
4563 swig_obj[0] = args;
4564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4565 if (!SWIG_IsOK(res1)) {
4566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4567 }
4568 arg1 = reinterpret_cast< wxObject * >(argp1);
4569 {
4570 PyThreadState* __tstate = wxPyBeginAllowThreads();
4571 result = wxObject_GetClassName(arg1);
4572 wxPyEndAllowThreads(__tstate);
4573 if (PyErr_Occurred()) SWIG_fail;
4574 }
4575 {
4576 #if wxUSE_UNICODE
4577 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4578 #else
4579 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4580 #endif
4581 }
4582 return resultobj;
4583 fail:
4584 return NULL;
4585 }
4586
4587
4588 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4589 PyObject *resultobj = 0;
4590 wxObject *arg1 = (wxObject *) 0 ;
4591 void *argp1 = 0 ;
4592 int res1 = 0 ;
4593 PyObject *swig_obj[1] ;
4594
4595 if (!args) SWIG_fail;
4596 swig_obj[0] = args;
4597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4598 if (!SWIG_IsOK(res1)) {
4599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4600 }
4601 arg1 = reinterpret_cast< wxObject * >(argp1);
4602 {
4603 PyThreadState* __tstate = wxPyBeginAllowThreads();
4604 wxObject_Destroy(arg1);
4605 wxPyEndAllowThreads(__tstate);
4606 if (PyErr_Occurred()) SWIG_fail;
4607 }
4608 resultobj = SWIG_Py_Void();
4609 return resultobj;
4610 fail:
4611 return NULL;
4612 }
4613
4614
4615 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4616 PyObject *resultobj = 0;
4617 wxObject *arg1 = (wxObject *) 0 ;
4618 wxObject *arg2 = 0 ;
4619 bool result;
4620 void *argp1 = 0 ;
4621 int res1 = 0 ;
4622 void *argp2 = 0 ;
4623 int res2 = 0 ;
4624 PyObject * obj0 = 0 ;
4625 PyObject * obj1 = 0 ;
4626 char * kwnames[] = {
4627 (char *) "self",(char *) "p", NULL
4628 };
4629
4630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4632 if (!SWIG_IsOK(res1)) {
4633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4634 }
4635 arg1 = reinterpret_cast< wxObject * >(argp1);
4636 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4637 if (!SWIG_IsOK(res2)) {
4638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4639 }
4640 if (!argp2) {
4641 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4642 }
4643 arg2 = reinterpret_cast< wxObject * >(argp2);
4644 {
4645 PyThreadState* __tstate = wxPyBeginAllowThreads();
4646 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4647 wxPyEndAllowThreads(__tstate);
4648 if (PyErr_Occurred()) SWIG_fail;
4649 }
4650 {
4651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4652 }
4653 return resultobj;
4654 fail:
4655 return NULL;
4656 }
4657
4658
4659 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4660 PyObject *obj;
4661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4662 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4663 return SWIG_Py_Void();
4664 }
4665
4666 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4667 PyObject *resultobj = 0;
4668 wxSize *arg1 = (wxSize *) 0 ;
4669 int arg2 ;
4670 void *argp1 = 0 ;
4671 int res1 = 0 ;
4672 int val2 ;
4673 int ecode2 = 0 ;
4674 PyObject *swig_obj[2] ;
4675
4676 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4678 if (!SWIG_IsOK(res1)) {
4679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4680 }
4681 arg1 = reinterpret_cast< wxSize * >(argp1);
4682 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4683 if (!SWIG_IsOK(ecode2)) {
4684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4685 }
4686 arg2 = static_cast< int >(val2);
4687 if (arg1) (arg1)->x = arg2;
4688
4689 resultobj = SWIG_Py_Void();
4690 return resultobj;
4691 fail:
4692 return NULL;
4693 }
4694
4695
4696 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4697 PyObject *resultobj = 0;
4698 wxSize *arg1 = (wxSize *) 0 ;
4699 int result;
4700 void *argp1 = 0 ;
4701 int res1 = 0 ;
4702 PyObject *swig_obj[1] ;
4703
4704 if (!args) SWIG_fail;
4705 swig_obj[0] = args;
4706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4707 if (!SWIG_IsOK(res1)) {
4708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4709 }
4710 arg1 = reinterpret_cast< wxSize * >(argp1);
4711 result = (int) ((arg1)->x);
4712 resultobj = SWIG_From_int(static_cast< int >(result));
4713 return resultobj;
4714 fail:
4715 return NULL;
4716 }
4717
4718
4719 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4720 PyObject *resultobj = 0;
4721 wxSize *arg1 = (wxSize *) 0 ;
4722 int arg2 ;
4723 void *argp1 = 0 ;
4724 int res1 = 0 ;
4725 int val2 ;
4726 int ecode2 = 0 ;
4727 PyObject *swig_obj[2] ;
4728
4729 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4731 if (!SWIG_IsOK(res1)) {
4732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4733 }
4734 arg1 = reinterpret_cast< wxSize * >(argp1);
4735 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4736 if (!SWIG_IsOK(ecode2)) {
4737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4738 }
4739 arg2 = static_cast< int >(val2);
4740 if (arg1) (arg1)->y = arg2;
4741
4742 resultobj = SWIG_Py_Void();
4743 return resultobj;
4744 fail:
4745 return NULL;
4746 }
4747
4748
4749 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4750 PyObject *resultobj = 0;
4751 wxSize *arg1 = (wxSize *) 0 ;
4752 int result;
4753 void *argp1 = 0 ;
4754 int res1 = 0 ;
4755 PyObject *swig_obj[1] ;
4756
4757 if (!args) SWIG_fail;
4758 swig_obj[0] = args;
4759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4760 if (!SWIG_IsOK(res1)) {
4761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4762 }
4763 arg1 = reinterpret_cast< wxSize * >(argp1);
4764 result = (int) ((arg1)->y);
4765 resultobj = SWIG_From_int(static_cast< int >(result));
4766 return resultobj;
4767 fail:
4768 return NULL;
4769 }
4770
4771
4772 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4773 PyObject *resultobj = 0;
4774 int arg1 = (int) 0 ;
4775 int arg2 = (int) 0 ;
4776 wxSize *result = 0 ;
4777 int val1 ;
4778 int ecode1 = 0 ;
4779 int val2 ;
4780 int ecode2 = 0 ;
4781 PyObject * obj0 = 0 ;
4782 PyObject * obj1 = 0 ;
4783 char * kwnames[] = {
4784 (char *) "w",(char *) "h", NULL
4785 };
4786
4787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4788 if (obj0) {
4789 ecode1 = SWIG_AsVal_int(obj0, &val1);
4790 if (!SWIG_IsOK(ecode1)) {
4791 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4792 }
4793 arg1 = static_cast< int >(val1);
4794 }
4795 if (obj1) {
4796 ecode2 = SWIG_AsVal_int(obj1, &val2);
4797 if (!SWIG_IsOK(ecode2)) {
4798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4799 }
4800 arg2 = static_cast< int >(val2);
4801 }
4802 {
4803 result = (wxSize *)new wxSize(arg1,arg2);
4804 if (PyErr_Occurred()) SWIG_fail;
4805 }
4806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4807 return resultobj;
4808 fail:
4809 return NULL;
4810 }
4811
4812
4813 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4814 PyObject *resultobj = 0;
4815 wxSize *arg1 = (wxSize *) 0 ;
4816 void *argp1 = 0 ;
4817 int res1 = 0 ;
4818 PyObject *swig_obj[1] ;
4819
4820 if (!args) SWIG_fail;
4821 swig_obj[0] = args;
4822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4823 if (!SWIG_IsOK(res1)) {
4824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4825 }
4826 arg1 = reinterpret_cast< wxSize * >(argp1);
4827 {
4828 delete arg1;
4829
4830 if (PyErr_Occurred()) SWIG_fail;
4831 }
4832 resultobj = SWIG_Py_Void();
4833 return resultobj;
4834 fail:
4835 return NULL;
4836 }
4837
4838
4839 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4840 PyObject *resultobj = 0;
4841 wxSize *arg1 = (wxSize *) 0 ;
4842 PyObject *arg2 = (PyObject *) 0 ;
4843 bool result;
4844 void *argp1 = 0 ;
4845 int res1 = 0 ;
4846 PyObject * obj0 = 0 ;
4847 PyObject * obj1 = 0 ;
4848 char * kwnames[] = {
4849 (char *) "self",(char *) "other", NULL
4850 };
4851
4852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4854 if (!SWIG_IsOK(res1)) {
4855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4856 }
4857 arg1 = reinterpret_cast< wxSize * >(argp1);
4858 arg2 = obj1;
4859 {
4860 result = (bool)wxSize___eq__(arg1,arg2);
4861 if (PyErr_Occurred()) SWIG_fail;
4862 }
4863 {
4864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4865 }
4866 return resultobj;
4867 fail:
4868 return NULL;
4869 }
4870
4871
4872 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4873 PyObject *resultobj = 0;
4874 wxSize *arg1 = (wxSize *) 0 ;
4875 PyObject *arg2 = (PyObject *) 0 ;
4876 bool result;
4877 void *argp1 = 0 ;
4878 int res1 = 0 ;
4879 PyObject * obj0 = 0 ;
4880 PyObject * obj1 = 0 ;
4881 char * kwnames[] = {
4882 (char *) "self",(char *) "other", NULL
4883 };
4884
4885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4887 if (!SWIG_IsOK(res1)) {
4888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4889 }
4890 arg1 = reinterpret_cast< wxSize * >(argp1);
4891 arg2 = obj1;
4892 {
4893 result = (bool)wxSize___ne__(arg1,arg2);
4894 if (PyErr_Occurred()) SWIG_fail;
4895 }
4896 {
4897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4898 }
4899 return resultobj;
4900 fail:
4901 return NULL;
4902 }
4903
4904
4905 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4906 PyObject *resultobj = 0;
4907 wxSize *arg1 = (wxSize *) 0 ;
4908 wxSize *arg2 = 0 ;
4909 wxSize result;
4910 void *argp1 = 0 ;
4911 int res1 = 0 ;
4912 wxSize temp2 ;
4913 PyObject * obj0 = 0 ;
4914 PyObject * obj1 = 0 ;
4915 char * kwnames[] = {
4916 (char *) "self",(char *) "sz", NULL
4917 };
4918
4919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) 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___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4923 }
4924 arg1 = reinterpret_cast< wxSize * >(argp1);
4925 {
4926 arg2 = &temp2;
4927 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4928 }
4929 {
4930 result = (arg1)->operator +((wxSize const &)*arg2);
4931 if (PyErr_Occurred()) SWIG_fail;
4932 }
4933 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4934 return resultobj;
4935 fail:
4936 return NULL;
4937 }
4938
4939
4940 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4941 PyObject *resultobj = 0;
4942 wxSize *arg1 = (wxSize *) 0 ;
4943 wxSize *arg2 = 0 ;
4944 wxSize result;
4945 void *argp1 = 0 ;
4946 int res1 = 0 ;
4947 wxSize temp2 ;
4948 PyObject * obj0 = 0 ;
4949 PyObject * obj1 = 0 ;
4950 char * kwnames[] = {
4951 (char *) "self",(char *) "sz", NULL
4952 };
4953
4954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4956 if (!SWIG_IsOK(res1)) {
4957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4958 }
4959 arg1 = reinterpret_cast< wxSize * >(argp1);
4960 {
4961 arg2 = &temp2;
4962 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4963 }
4964 {
4965 result = (arg1)->operator -((wxSize const &)*arg2);
4966 if (PyErr_Occurred()) SWIG_fail;
4967 }
4968 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4969 return resultobj;
4970 fail:
4971 return NULL;
4972 }
4973
4974
4975 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4976 PyObject *resultobj = 0;
4977 wxSize *arg1 = (wxSize *) 0 ;
4978 wxSize *arg2 = 0 ;
4979 void *argp1 = 0 ;
4980 int res1 = 0 ;
4981 wxSize temp2 ;
4982 PyObject * obj0 = 0 ;
4983 PyObject * obj1 = 0 ;
4984 char * kwnames[] = {
4985 (char *) "self",(char *) "sz", NULL
4986 };
4987
4988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4990 if (!SWIG_IsOK(res1)) {
4991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4992 }
4993 arg1 = reinterpret_cast< wxSize * >(argp1);
4994 {
4995 arg2 = &temp2;
4996 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4997 }
4998 {
4999 (arg1)->IncTo((wxSize const &)*arg2);
5000 if (PyErr_Occurred()) SWIG_fail;
5001 }
5002 resultobj = SWIG_Py_Void();
5003 return resultobj;
5004 fail:
5005 return NULL;
5006 }
5007
5008
5009 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5010 PyObject *resultobj = 0;
5011 wxSize *arg1 = (wxSize *) 0 ;
5012 wxSize *arg2 = 0 ;
5013 void *argp1 = 0 ;
5014 int res1 = 0 ;
5015 wxSize temp2 ;
5016 PyObject * obj0 = 0 ;
5017 PyObject * obj1 = 0 ;
5018 char * kwnames[] = {
5019 (char *) "self",(char *) "sz", NULL
5020 };
5021
5022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
5023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5024 if (!SWIG_IsOK(res1)) {
5025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
5026 }
5027 arg1 = reinterpret_cast< wxSize * >(argp1);
5028 {
5029 arg2 = &temp2;
5030 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5031 }
5032 {
5033 (arg1)->DecTo((wxSize const &)*arg2);
5034 if (PyErr_Occurred()) SWIG_fail;
5035 }
5036 resultobj = SWIG_Py_Void();
5037 return resultobj;
5038 fail:
5039 return NULL;
5040 }
5041
5042
5043 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5044 PyObject *resultobj = 0;
5045 wxSize *arg1 = (wxSize *) 0 ;
5046 int arg2 ;
5047 int arg3 ;
5048 void *argp1 = 0 ;
5049 int res1 = 0 ;
5050 int val2 ;
5051 int ecode2 = 0 ;
5052 int val3 ;
5053 int ecode3 = 0 ;
5054 PyObject * obj0 = 0 ;
5055 PyObject * obj1 = 0 ;
5056 PyObject * obj2 = 0 ;
5057 char * kwnames[] = {
5058 (char *) "self",(char *) "dx",(char *) "dy", NULL
5059 };
5060
5061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5063 if (!SWIG_IsOK(res1)) {
5064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
5065 }
5066 arg1 = reinterpret_cast< wxSize * >(argp1);
5067 ecode2 = SWIG_AsVal_int(obj1, &val2);
5068 if (!SWIG_IsOK(ecode2)) {
5069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
5070 }
5071 arg2 = static_cast< int >(val2);
5072 ecode3 = SWIG_AsVal_int(obj2, &val3);
5073 if (!SWIG_IsOK(ecode3)) {
5074 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
5075 }
5076 arg3 = static_cast< int >(val3);
5077 {
5078 (arg1)->IncBy(arg2,arg3);
5079 if (PyErr_Occurred()) SWIG_fail;
5080 }
5081 resultobj = SWIG_Py_Void();
5082 return resultobj;
5083 fail:
5084 return NULL;
5085 }
5086
5087
5088 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5089 PyObject *resultobj = 0;
5090 wxSize *arg1 = (wxSize *) 0 ;
5091 int arg2 ;
5092 int arg3 ;
5093 void *argp1 = 0 ;
5094 int res1 = 0 ;
5095 int val2 ;
5096 int ecode2 = 0 ;
5097 int val3 ;
5098 int ecode3 = 0 ;
5099 PyObject * obj0 = 0 ;
5100 PyObject * obj1 = 0 ;
5101 PyObject * obj2 = 0 ;
5102 char * kwnames[] = {
5103 (char *) "self",(char *) "dx",(char *) "dy", NULL
5104 };
5105
5106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5108 if (!SWIG_IsOK(res1)) {
5109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5110 }
5111 arg1 = reinterpret_cast< wxSize * >(argp1);
5112 ecode2 = SWIG_AsVal_int(obj1, &val2);
5113 if (!SWIG_IsOK(ecode2)) {
5114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5115 }
5116 arg2 = static_cast< int >(val2);
5117 ecode3 = SWIG_AsVal_int(obj2, &val3);
5118 if (!SWIG_IsOK(ecode3)) {
5119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5120 }
5121 arg3 = static_cast< int >(val3);
5122 {
5123 (arg1)->DecBy(arg2,arg3);
5124 if (PyErr_Occurred()) SWIG_fail;
5125 }
5126 resultobj = SWIG_Py_Void();
5127 return resultobj;
5128 fail:
5129 return NULL;
5130 }
5131
5132
5133 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5134 PyObject *resultobj = 0;
5135 wxSize *arg1 = (wxSize *) 0 ;
5136 float arg2 ;
5137 float arg3 ;
5138 void *argp1 = 0 ;
5139 int res1 = 0 ;
5140 float val2 ;
5141 int ecode2 = 0 ;
5142 float val3 ;
5143 int ecode3 = 0 ;
5144 PyObject * obj0 = 0 ;
5145 PyObject * obj1 = 0 ;
5146 PyObject * obj2 = 0 ;
5147 char * kwnames[] = {
5148 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5149 };
5150
5151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5153 if (!SWIG_IsOK(res1)) {
5154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5155 }
5156 arg1 = reinterpret_cast< wxSize * >(argp1);
5157 ecode2 = SWIG_AsVal_float(obj1, &val2);
5158 if (!SWIG_IsOK(ecode2)) {
5159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5160 }
5161 arg2 = static_cast< float >(val2);
5162 ecode3 = SWIG_AsVal_float(obj2, &val3);
5163 if (!SWIG_IsOK(ecode3)) {
5164 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5165 }
5166 arg3 = static_cast< float >(val3);
5167 {
5168 (arg1)->Scale(arg2,arg3);
5169 if (PyErr_Occurred()) SWIG_fail;
5170 }
5171 resultobj = SWIG_Py_Void();
5172 return resultobj;
5173 fail:
5174 return NULL;
5175 }
5176
5177
5178 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5179 PyObject *resultobj = 0;
5180 wxSize *arg1 = (wxSize *) 0 ;
5181 int arg2 ;
5182 int arg3 ;
5183 void *argp1 = 0 ;
5184 int res1 = 0 ;
5185 int val2 ;
5186 int ecode2 = 0 ;
5187 int val3 ;
5188 int ecode3 = 0 ;
5189 PyObject * obj0 = 0 ;
5190 PyObject * obj1 = 0 ;
5191 PyObject * obj2 = 0 ;
5192 char * kwnames[] = {
5193 (char *) "self",(char *) "w",(char *) "h", NULL
5194 };
5195
5196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5198 if (!SWIG_IsOK(res1)) {
5199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5200 }
5201 arg1 = reinterpret_cast< wxSize * >(argp1);
5202 ecode2 = SWIG_AsVal_int(obj1, &val2);
5203 if (!SWIG_IsOK(ecode2)) {
5204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5205 }
5206 arg2 = static_cast< int >(val2);
5207 ecode3 = SWIG_AsVal_int(obj2, &val3);
5208 if (!SWIG_IsOK(ecode3)) {
5209 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5210 }
5211 arg3 = static_cast< int >(val3);
5212 {
5213 (arg1)->Set(arg2,arg3);
5214 if (PyErr_Occurred()) SWIG_fail;
5215 }
5216 resultobj = SWIG_Py_Void();
5217 return resultobj;
5218 fail:
5219 return NULL;
5220 }
5221
5222
5223 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5224 PyObject *resultobj = 0;
5225 wxSize *arg1 = (wxSize *) 0 ;
5226 int arg2 ;
5227 void *argp1 = 0 ;
5228 int res1 = 0 ;
5229 int val2 ;
5230 int ecode2 = 0 ;
5231 PyObject * obj0 = 0 ;
5232 PyObject * obj1 = 0 ;
5233 char * kwnames[] = {
5234 (char *) "self",(char *) "w", NULL
5235 };
5236
5237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5239 if (!SWIG_IsOK(res1)) {
5240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5241 }
5242 arg1 = reinterpret_cast< wxSize * >(argp1);
5243 ecode2 = SWIG_AsVal_int(obj1, &val2);
5244 if (!SWIG_IsOK(ecode2)) {
5245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5246 }
5247 arg2 = static_cast< int >(val2);
5248 {
5249 (arg1)->SetWidth(arg2);
5250 if (PyErr_Occurred()) SWIG_fail;
5251 }
5252 resultobj = SWIG_Py_Void();
5253 return resultobj;
5254 fail:
5255 return NULL;
5256 }
5257
5258
5259 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5260 PyObject *resultobj = 0;
5261 wxSize *arg1 = (wxSize *) 0 ;
5262 int arg2 ;
5263 void *argp1 = 0 ;
5264 int res1 = 0 ;
5265 int val2 ;
5266 int ecode2 = 0 ;
5267 PyObject * obj0 = 0 ;
5268 PyObject * obj1 = 0 ;
5269 char * kwnames[] = {
5270 (char *) "self",(char *) "h", NULL
5271 };
5272
5273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5275 if (!SWIG_IsOK(res1)) {
5276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5277 }
5278 arg1 = reinterpret_cast< wxSize * >(argp1);
5279 ecode2 = SWIG_AsVal_int(obj1, &val2);
5280 if (!SWIG_IsOK(ecode2)) {
5281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5282 }
5283 arg2 = static_cast< int >(val2);
5284 {
5285 (arg1)->SetHeight(arg2);
5286 if (PyErr_Occurred()) SWIG_fail;
5287 }
5288 resultobj = SWIG_Py_Void();
5289 return resultobj;
5290 fail:
5291 return NULL;
5292 }
5293
5294
5295 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5296 PyObject *resultobj = 0;
5297 wxSize *arg1 = (wxSize *) 0 ;
5298 int result;
5299 void *argp1 = 0 ;
5300 int res1 = 0 ;
5301 PyObject *swig_obj[1] ;
5302
5303 if (!args) SWIG_fail;
5304 swig_obj[0] = args;
5305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5306 if (!SWIG_IsOK(res1)) {
5307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5308 }
5309 arg1 = reinterpret_cast< wxSize * >(argp1);
5310 {
5311 result = (int)((wxSize const *)arg1)->GetWidth();
5312 if (PyErr_Occurred()) SWIG_fail;
5313 }
5314 resultobj = SWIG_From_int(static_cast< int >(result));
5315 return resultobj;
5316 fail:
5317 return NULL;
5318 }
5319
5320
5321 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5322 PyObject *resultobj = 0;
5323 wxSize *arg1 = (wxSize *) 0 ;
5324 int result;
5325 void *argp1 = 0 ;
5326 int res1 = 0 ;
5327 PyObject *swig_obj[1] ;
5328
5329 if (!args) SWIG_fail;
5330 swig_obj[0] = args;
5331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5332 if (!SWIG_IsOK(res1)) {
5333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5334 }
5335 arg1 = reinterpret_cast< wxSize * >(argp1);
5336 {
5337 result = (int)((wxSize const *)arg1)->GetHeight();
5338 if (PyErr_Occurred()) SWIG_fail;
5339 }
5340 resultobj = SWIG_From_int(static_cast< int >(result));
5341 return resultobj;
5342 fail:
5343 return NULL;
5344 }
5345
5346
5347 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5348 PyObject *resultobj = 0;
5349 wxSize *arg1 = (wxSize *) 0 ;
5350 bool result;
5351 void *argp1 = 0 ;
5352 int res1 = 0 ;
5353 PyObject *swig_obj[1] ;
5354
5355 if (!args) SWIG_fail;
5356 swig_obj[0] = args;
5357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5358 if (!SWIG_IsOK(res1)) {
5359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5360 }
5361 arg1 = reinterpret_cast< wxSize * >(argp1);
5362 {
5363 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5364 if (PyErr_Occurred()) SWIG_fail;
5365 }
5366 {
5367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5368 }
5369 return resultobj;
5370 fail:
5371 return NULL;
5372 }
5373
5374
5375 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5376 PyObject *resultobj = 0;
5377 wxSize *arg1 = (wxSize *) 0 ;
5378 wxSize *arg2 = 0 ;
5379 void *argp1 = 0 ;
5380 int res1 = 0 ;
5381 wxSize temp2 ;
5382 PyObject * obj0 = 0 ;
5383 PyObject * obj1 = 0 ;
5384 char * kwnames[] = {
5385 (char *) "self",(char *) "size", NULL
5386 };
5387
5388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5390 if (!SWIG_IsOK(res1)) {
5391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5392 }
5393 arg1 = reinterpret_cast< wxSize * >(argp1);
5394 {
5395 arg2 = &temp2;
5396 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5397 }
5398 {
5399 (arg1)->SetDefaults((wxSize const &)*arg2);
5400 if (PyErr_Occurred()) SWIG_fail;
5401 }
5402 resultobj = SWIG_Py_Void();
5403 return resultobj;
5404 fail:
5405 return NULL;
5406 }
5407
5408
5409 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5410 PyObject *resultobj = 0;
5411 wxSize *arg1 = (wxSize *) 0 ;
5412 PyObject *result = 0 ;
5413 void *argp1 = 0 ;
5414 int res1 = 0 ;
5415 PyObject *swig_obj[1] ;
5416
5417 if (!args) SWIG_fail;
5418 swig_obj[0] = args;
5419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5420 if (!SWIG_IsOK(res1)) {
5421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5422 }
5423 arg1 = reinterpret_cast< wxSize * >(argp1);
5424 {
5425 result = (PyObject *)wxSize_Get(arg1);
5426 if (PyErr_Occurred()) SWIG_fail;
5427 }
5428 resultobj = result;
5429 return resultobj;
5430 fail:
5431 return NULL;
5432 }
5433
5434
5435 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5436 PyObject *obj;
5437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5438 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5439 return SWIG_Py_Void();
5440 }
5441
5442 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5443 return SWIG_Python_InitShadowInstance(args);
5444 }
5445
5446 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5447 PyObject *resultobj = 0;
5448 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5449 double arg2 ;
5450 void *argp1 = 0 ;
5451 int res1 = 0 ;
5452 double val2 ;
5453 int ecode2 = 0 ;
5454 PyObject *swig_obj[2] ;
5455
5456 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5458 if (!SWIG_IsOK(res1)) {
5459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5460 }
5461 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5462 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5463 if (!SWIG_IsOK(ecode2)) {
5464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5465 }
5466 arg2 = static_cast< double >(val2);
5467 if (arg1) (arg1)->x = arg2;
5468
5469 resultobj = SWIG_Py_Void();
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5477 PyObject *resultobj = 0;
5478 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5479 double result;
5480 void *argp1 = 0 ;
5481 int res1 = 0 ;
5482 PyObject *swig_obj[1] ;
5483
5484 if (!args) SWIG_fail;
5485 swig_obj[0] = args;
5486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5487 if (!SWIG_IsOK(res1)) {
5488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5489 }
5490 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5491 result = (double) ((arg1)->x);
5492 resultobj = SWIG_From_double(static_cast< double >(result));
5493 return resultobj;
5494 fail:
5495 return NULL;
5496 }
5497
5498
5499 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5500 PyObject *resultobj = 0;
5501 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5502 double arg2 ;
5503 void *argp1 = 0 ;
5504 int res1 = 0 ;
5505 double val2 ;
5506 int ecode2 = 0 ;
5507 PyObject *swig_obj[2] ;
5508
5509 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5511 if (!SWIG_IsOK(res1)) {
5512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5513 }
5514 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5515 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5516 if (!SWIG_IsOK(ecode2)) {
5517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5518 }
5519 arg2 = static_cast< double >(val2);
5520 if (arg1) (arg1)->y = arg2;
5521
5522 resultobj = SWIG_Py_Void();
5523 return resultobj;
5524 fail:
5525 return NULL;
5526 }
5527
5528
5529 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5530 PyObject *resultobj = 0;
5531 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5532 double result;
5533 void *argp1 = 0 ;
5534 int res1 = 0 ;
5535 PyObject *swig_obj[1] ;
5536
5537 if (!args) SWIG_fail;
5538 swig_obj[0] = args;
5539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5540 if (!SWIG_IsOK(res1)) {
5541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5542 }
5543 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5544 result = (double) ((arg1)->y);
5545 resultobj = SWIG_From_double(static_cast< double >(result));
5546 return resultobj;
5547 fail:
5548 return NULL;
5549 }
5550
5551
5552 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5553 PyObject *resultobj = 0;
5554 double arg1 = (double) 0.0 ;
5555 double arg2 = (double) 0.0 ;
5556 wxRealPoint *result = 0 ;
5557 double val1 ;
5558 int ecode1 = 0 ;
5559 double val2 ;
5560 int ecode2 = 0 ;
5561 PyObject * obj0 = 0 ;
5562 PyObject * obj1 = 0 ;
5563 char * kwnames[] = {
5564 (char *) "x",(char *) "y", NULL
5565 };
5566
5567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5568 if (obj0) {
5569 ecode1 = SWIG_AsVal_double(obj0, &val1);
5570 if (!SWIG_IsOK(ecode1)) {
5571 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5572 }
5573 arg1 = static_cast< double >(val1);
5574 }
5575 if (obj1) {
5576 ecode2 = SWIG_AsVal_double(obj1, &val2);
5577 if (!SWIG_IsOK(ecode2)) {
5578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5579 }
5580 arg2 = static_cast< double >(val2);
5581 }
5582 {
5583 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5584 if (PyErr_Occurred()) SWIG_fail;
5585 }
5586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5587 return resultobj;
5588 fail:
5589 return NULL;
5590 }
5591
5592
5593 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5594 PyObject *resultobj = 0;
5595 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5596 void *argp1 = 0 ;
5597 int res1 = 0 ;
5598 PyObject *swig_obj[1] ;
5599
5600 if (!args) SWIG_fail;
5601 swig_obj[0] = args;
5602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5603 if (!SWIG_IsOK(res1)) {
5604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5605 }
5606 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5607 {
5608 delete arg1;
5609
5610 if (PyErr_Occurred()) SWIG_fail;
5611 }
5612 resultobj = SWIG_Py_Void();
5613 return resultobj;
5614 fail:
5615 return NULL;
5616 }
5617
5618
5619 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5620 PyObject *resultobj = 0;
5621 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5622 PyObject *arg2 = (PyObject *) 0 ;
5623 bool result;
5624 void *argp1 = 0 ;
5625 int res1 = 0 ;
5626 PyObject * obj0 = 0 ;
5627 PyObject * obj1 = 0 ;
5628 char * kwnames[] = {
5629 (char *) "self",(char *) "other", NULL
5630 };
5631
5632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5634 if (!SWIG_IsOK(res1)) {
5635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5636 }
5637 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5638 arg2 = obj1;
5639 {
5640 result = (bool)wxRealPoint___eq__(arg1,arg2);
5641 if (PyErr_Occurred()) SWIG_fail;
5642 }
5643 {
5644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5645 }
5646 return resultobj;
5647 fail:
5648 return NULL;
5649 }
5650
5651
5652 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5653 PyObject *resultobj = 0;
5654 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5655 PyObject *arg2 = (PyObject *) 0 ;
5656 bool result;
5657 void *argp1 = 0 ;
5658 int res1 = 0 ;
5659 PyObject * obj0 = 0 ;
5660 PyObject * obj1 = 0 ;
5661 char * kwnames[] = {
5662 (char *) "self",(char *) "other", NULL
5663 };
5664
5665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5667 if (!SWIG_IsOK(res1)) {
5668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5669 }
5670 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5671 arg2 = obj1;
5672 {
5673 result = (bool)wxRealPoint___ne__(arg1,arg2);
5674 if (PyErr_Occurred()) SWIG_fail;
5675 }
5676 {
5677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5678 }
5679 return resultobj;
5680 fail:
5681 return NULL;
5682 }
5683
5684
5685 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5686 PyObject *resultobj = 0;
5687 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5688 wxRealPoint *arg2 = 0 ;
5689 wxRealPoint result;
5690 void *argp1 = 0 ;
5691 int res1 = 0 ;
5692 wxRealPoint temp2 ;
5693 PyObject * obj0 = 0 ;
5694 PyObject * obj1 = 0 ;
5695 char * kwnames[] = {
5696 (char *) "self",(char *) "pt", NULL
5697 };
5698
5699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5701 if (!SWIG_IsOK(res1)) {
5702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5703 }
5704 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5705 {
5706 arg2 = &temp2;
5707 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5708 }
5709 {
5710 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5711 if (PyErr_Occurred()) SWIG_fail;
5712 }
5713 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5714 return resultobj;
5715 fail:
5716 return NULL;
5717 }
5718
5719
5720 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5721 PyObject *resultobj = 0;
5722 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5723 wxRealPoint *arg2 = 0 ;
5724 wxRealPoint result;
5725 void *argp1 = 0 ;
5726 int res1 = 0 ;
5727 wxRealPoint temp2 ;
5728 PyObject * obj0 = 0 ;
5729 PyObject * obj1 = 0 ;
5730 char * kwnames[] = {
5731 (char *) "self",(char *) "pt", NULL
5732 };
5733
5734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5736 if (!SWIG_IsOK(res1)) {
5737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5738 }
5739 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5740 {
5741 arg2 = &temp2;
5742 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5743 }
5744 {
5745 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5746 if (PyErr_Occurred()) SWIG_fail;
5747 }
5748 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5749 return resultobj;
5750 fail:
5751 return NULL;
5752 }
5753
5754
5755 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5756 PyObject *resultobj = 0;
5757 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5758 double arg2 ;
5759 double arg3 ;
5760 void *argp1 = 0 ;
5761 int res1 = 0 ;
5762 double val2 ;
5763 int ecode2 = 0 ;
5764 double val3 ;
5765 int ecode3 = 0 ;
5766 PyObject * obj0 = 0 ;
5767 PyObject * obj1 = 0 ;
5768 PyObject * obj2 = 0 ;
5769 char * kwnames[] = {
5770 (char *) "self",(char *) "x",(char *) "y", NULL
5771 };
5772
5773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5775 if (!SWIG_IsOK(res1)) {
5776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5777 }
5778 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5779 ecode2 = SWIG_AsVal_double(obj1, &val2);
5780 if (!SWIG_IsOK(ecode2)) {
5781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5782 }
5783 arg2 = static_cast< double >(val2);
5784 ecode3 = SWIG_AsVal_double(obj2, &val3);
5785 if (!SWIG_IsOK(ecode3)) {
5786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5787 }
5788 arg3 = static_cast< double >(val3);
5789 {
5790 wxRealPoint_Set(arg1,arg2,arg3);
5791 if (PyErr_Occurred()) SWIG_fail;
5792 }
5793 resultobj = SWIG_Py_Void();
5794 return resultobj;
5795 fail:
5796 return NULL;
5797 }
5798
5799
5800 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5801 PyObject *resultobj = 0;
5802 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5803 PyObject *result = 0 ;
5804 void *argp1 = 0 ;
5805 int res1 = 0 ;
5806 PyObject *swig_obj[1] ;
5807
5808 if (!args) SWIG_fail;
5809 swig_obj[0] = args;
5810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5811 if (!SWIG_IsOK(res1)) {
5812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5813 }
5814 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5815 {
5816 result = (PyObject *)wxRealPoint_Get(arg1);
5817 if (PyErr_Occurred()) SWIG_fail;
5818 }
5819 resultobj = result;
5820 return resultobj;
5821 fail:
5822 return NULL;
5823 }
5824
5825
5826 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5827 PyObject *obj;
5828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5829 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5830 return SWIG_Py_Void();
5831 }
5832
5833 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5834 return SWIG_Python_InitShadowInstance(args);
5835 }
5836
5837 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5838 PyObject *resultobj = 0;
5839 wxPoint *arg1 = (wxPoint *) 0 ;
5840 int arg2 ;
5841 void *argp1 = 0 ;
5842 int res1 = 0 ;
5843 int val2 ;
5844 int ecode2 = 0 ;
5845 PyObject *swig_obj[2] ;
5846
5847 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5849 if (!SWIG_IsOK(res1)) {
5850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5851 }
5852 arg1 = reinterpret_cast< wxPoint * >(argp1);
5853 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5854 if (!SWIG_IsOK(ecode2)) {
5855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5856 }
5857 arg2 = static_cast< int >(val2);
5858 if (arg1) (arg1)->x = arg2;
5859
5860 resultobj = SWIG_Py_Void();
5861 return resultobj;
5862 fail:
5863 return NULL;
5864 }
5865
5866
5867 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5868 PyObject *resultobj = 0;
5869 wxPoint *arg1 = (wxPoint *) 0 ;
5870 int result;
5871 void *argp1 = 0 ;
5872 int res1 = 0 ;
5873 PyObject *swig_obj[1] ;
5874
5875 if (!args) SWIG_fail;
5876 swig_obj[0] = args;
5877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5878 if (!SWIG_IsOK(res1)) {
5879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5880 }
5881 arg1 = reinterpret_cast< wxPoint * >(argp1);
5882 result = (int) ((arg1)->x);
5883 resultobj = SWIG_From_int(static_cast< int >(result));
5884 return resultobj;
5885 fail:
5886 return NULL;
5887 }
5888
5889
5890 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5891 PyObject *resultobj = 0;
5892 wxPoint *arg1 = (wxPoint *) 0 ;
5893 int arg2 ;
5894 void *argp1 = 0 ;
5895 int res1 = 0 ;
5896 int val2 ;
5897 int ecode2 = 0 ;
5898 PyObject *swig_obj[2] ;
5899
5900 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5902 if (!SWIG_IsOK(res1)) {
5903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5904 }
5905 arg1 = reinterpret_cast< wxPoint * >(argp1);
5906 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5907 if (!SWIG_IsOK(ecode2)) {
5908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5909 }
5910 arg2 = static_cast< int >(val2);
5911 if (arg1) (arg1)->y = arg2;
5912
5913 resultobj = SWIG_Py_Void();
5914 return resultobj;
5915 fail:
5916 return NULL;
5917 }
5918
5919
5920 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5921 PyObject *resultobj = 0;
5922 wxPoint *arg1 = (wxPoint *) 0 ;
5923 int result;
5924 void *argp1 = 0 ;
5925 int res1 = 0 ;
5926 PyObject *swig_obj[1] ;
5927
5928 if (!args) SWIG_fail;
5929 swig_obj[0] = args;
5930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5931 if (!SWIG_IsOK(res1)) {
5932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5933 }
5934 arg1 = reinterpret_cast< wxPoint * >(argp1);
5935 result = (int) ((arg1)->y);
5936 resultobj = SWIG_From_int(static_cast< int >(result));
5937 return resultobj;
5938 fail:
5939 return NULL;
5940 }
5941
5942
5943 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5944 PyObject *resultobj = 0;
5945 int arg1 = (int) 0 ;
5946 int arg2 = (int) 0 ;
5947 wxPoint *result = 0 ;
5948 int val1 ;
5949 int ecode1 = 0 ;
5950 int val2 ;
5951 int ecode2 = 0 ;
5952 PyObject * obj0 = 0 ;
5953 PyObject * obj1 = 0 ;
5954 char * kwnames[] = {
5955 (char *) "x",(char *) "y", NULL
5956 };
5957
5958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5959 if (obj0) {
5960 ecode1 = SWIG_AsVal_int(obj0, &val1);
5961 if (!SWIG_IsOK(ecode1)) {
5962 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5963 }
5964 arg1 = static_cast< int >(val1);
5965 }
5966 if (obj1) {
5967 ecode2 = SWIG_AsVal_int(obj1, &val2);
5968 if (!SWIG_IsOK(ecode2)) {
5969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5970 }
5971 arg2 = static_cast< int >(val2);
5972 }
5973 {
5974 result = (wxPoint *)new wxPoint(arg1,arg2);
5975 if (PyErr_Occurred()) SWIG_fail;
5976 }
5977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5978 return resultobj;
5979 fail:
5980 return NULL;
5981 }
5982
5983
5984 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5985 PyObject *resultobj = 0;
5986 wxPoint *arg1 = (wxPoint *) 0 ;
5987 void *argp1 = 0 ;
5988 int res1 = 0 ;
5989 PyObject *swig_obj[1] ;
5990
5991 if (!args) SWIG_fail;
5992 swig_obj[0] = args;
5993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5994 if (!SWIG_IsOK(res1)) {
5995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5996 }
5997 arg1 = reinterpret_cast< wxPoint * >(argp1);
5998 {
5999 delete arg1;
6000
6001 if (PyErr_Occurred()) SWIG_fail;
6002 }
6003 resultobj = SWIG_Py_Void();
6004 return resultobj;
6005 fail:
6006 return NULL;
6007 }
6008
6009
6010 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6011 PyObject *resultobj = 0;
6012 wxPoint *arg1 = (wxPoint *) 0 ;
6013 PyObject *arg2 = (PyObject *) 0 ;
6014 bool result;
6015 void *argp1 = 0 ;
6016 int res1 = 0 ;
6017 PyObject * obj0 = 0 ;
6018 PyObject * obj1 = 0 ;
6019 char * kwnames[] = {
6020 (char *) "self",(char *) "other", NULL
6021 };
6022
6023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
6024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6025 if (!SWIG_IsOK(res1)) {
6026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
6027 }
6028 arg1 = reinterpret_cast< wxPoint * >(argp1);
6029 arg2 = obj1;
6030 {
6031 result = (bool)wxPoint___eq__(arg1,arg2);
6032 if (PyErr_Occurred()) SWIG_fail;
6033 }
6034 {
6035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6036 }
6037 return resultobj;
6038 fail:
6039 return NULL;
6040 }
6041
6042
6043 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6044 PyObject *resultobj = 0;
6045 wxPoint *arg1 = (wxPoint *) 0 ;
6046 PyObject *arg2 = (PyObject *) 0 ;
6047 bool result;
6048 void *argp1 = 0 ;
6049 int res1 = 0 ;
6050 PyObject * obj0 = 0 ;
6051 PyObject * obj1 = 0 ;
6052 char * kwnames[] = {
6053 (char *) "self",(char *) "other", NULL
6054 };
6055
6056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
6057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6058 if (!SWIG_IsOK(res1)) {
6059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
6060 }
6061 arg1 = reinterpret_cast< wxPoint * >(argp1);
6062 arg2 = obj1;
6063 {
6064 result = (bool)wxPoint___ne__(arg1,arg2);
6065 if (PyErr_Occurred()) SWIG_fail;
6066 }
6067 {
6068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6069 }
6070 return resultobj;
6071 fail:
6072 return NULL;
6073 }
6074
6075
6076 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6077 PyObject *resultobj = 0;
6078 wxPoint *arg1 = (wxPoint *) 0 ;
6079 wxPoint *arg2 = 0 ;
6080 wxPoint result;
6081 void *argp1 = 0 ;
6082 int res1 = 0 ;
6083 wxPoint temp2 ;
6084 PyObject * obj0 = 0 ;
6085 PyObject * obj1 = 0 ;
6086 char * kwnames[] = {
6087 (char *) "self",(char *) "pt", NULL
6088 };
6089
6090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
6091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6092 if (!SWIG_IsOK(res1)) {
6093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
6094 }
6095 arg1 = reinterpret_cast< wxPoint * >(argp1);
6096 {
6097 arg2 = &temp2;
6098 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6099 }
6100 {
6101 result = (arg1)->operator +((wxPoint const &)*arg2);
6102 if (PyErr_Occurred()) SWIG_fail;
6103 }
6104 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6105 return resultobj;
6106 fail:
6107 return NULL;
6108 }
6109
6110
6111 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6112 PyObject *resultobj = 0;
6113 wxPoint *arg1 = (wxPoint *) 0 ;
6114 wxPoint *arg2 = 0 ;
6115 wxPoint result;
6116 void *argp1 = 0 ;
6117 int res1 = 0 ;
6118 wxPoint temp2 ;
6119 PyObject * obj0 = 0 ;
6120 PyObject * obj1 = 0 ;
6121 char * kwnames[] = {
6122 (char *) "self",(char *) "pt", NULL
6123 };
6124
6125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6127 if (!SWIG_IsOK(res1)) {
6128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6129 }
6130 arg1 = reinterpret_cast< wxPoint * >(argp1);
6131 {
6132 arg2 = &temp2;
6133 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6134 }
6135 {
6136 result = (arg1)->operator -((wxPoint const &)*arg2);
6137 if (PyErr_Occurred()) SWIG_fail;
6138 }
6139 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6140 return resultobj;
6141 fail:
6142 return NULL;
6143 }
6144
6145
6146 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6147 PyObject *resultobj = 0;
6148 wxPoint *arg1 = (wxPoint *) 0 ;
6149 wxPoint *arg2 = 0 ;
6150 wxPoint *result = 0 ;
6151 void *argp1 = 0 ;
6152 int res1 = 0 ;
6153 wxPoint temp2 ;
6154 PyObject * obj0 = 0 ;
6155 PyObject * obj1 = 0 ;
6156 char * kwnames[] = {
6157 (char *) "self",(char *) "pt", NULL
6158 };
6159
6160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6162 if (!SWIG_IsOK(res1)) {
6163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6164 }
6165 arg1 = reinterpret_cast< wxPoint * >(argp1);
6166 {
6167 arg2 = &temp2;
6168 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6169 }
6170 {
6171 {
6172 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6173 result = (wxPoint *) &_result_ref;
6174 }
6175 if (PyErr_Occurred()) SWIG_fail;
6176 }
6177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6178 return resultobj;
6179 fail:
6180 return NULL;
6181 }
6182
6183
6184 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6185 PyObject *resultobj = 0;
6186 wxPoint *arg1 = (wxPoint *) 0 ;
6187 wxPoint *arg2 = 0 ;
6188 wxPoint *result = 0 ;
6189 void *argp1 = 0 ;
6190 int res1 = 0 ;
6191 wxPoint temp2 ;
6192 PyObject * obj0 = 0 ;
6193 PyObject * obj1 = 0 ;
6194 char * kwnames[] = {
6195 (char *) "self",(char *) "pt", NULL
6196 };
6197
6198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6200 if (!SWIG_IsOK(res1)) {
6201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6202 }
6203 arg1 = reinterpret_cast< wxPoint * >(argp1);
6204 {
6205 arg2 = &temp2;
6206 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6207 }
6208 {
6209 {
6210 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6211 result = (wxPoint *) &_result_ref;
6212 }
6213 if (PyErr_Occurred()) SWIG_fail;
6214 }
6215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6216 return resultobj;
6217 fail:
6218 return NULL;
6219 }
6220
6221
6222 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6223 PyObject *resultobj = 0;
6224 wxPoint *arg1 = (wxPoint *) 0 ;
6225 long arg2 ;
6226 long arg3 ;
6227 void *argp1 = 0 ;
6228 int res1 = 0 ;
6229 long val2 ;
6230 int ecode2 = 0 ;
6231 long val3 ;
6232 int ecode3 = 0 ;
6233 PyObject * obj0 = 0 ;
6234 PyObject * obj1 = 0 ;
6235 PyObject * obj2 = 0 ;
6236 char * kwnames[] = {
6237 (char *) "self",(char *) "x",(char *) "y", NULL
6238 };
6239
6240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6242 if (!SWIG_IsOK(res1)) {
6243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6244 }
6245 arg1 = reinterpret_cast< wxPoint * >(argp1);
6246 ecode2 = SWIG_AsVal_long(obj1, &val2);
6247 if (!SWIG_IsOK(ecode2)) {
6248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6249 }
6250 arg2 = static_cast< long >(val2);
6251 ecode3 = SWIG_AsVal_long(obj2, &val3);
6252 if (!SWIG_IsOK(ecode3)) {
6253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6254 }
6255 arg3 = static_cast< long >(val3);
6256 {
6257 wxPoint_Set(arg1,arg2,arg3);
6258 if (PyErr_Occurred()) SWIG_fail;
6259 }
6260 resultobj = SWIG_Py_Void();
6261 return resultobj;
6262 fail:
6263 return NULL;
6264 }
6265
6266
6267 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6268 PyObject *resultobj = 0;
6269 wxPoint *arg1 = (wxPoint *) 0 ;
6270 PyObject *result = 0 ;
6271 void *argp1 = 0 ;
6272 int res1 = 0 ;
6273 PyObject *swig_obj[1] ;
6274
6275 if (!args) SWIG_fail;
6276 swig_obj[0] = args;
6277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6278 if (!SWIG_IsOK(res1)) {
6279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6280 }
6281 arg1 = reinterpret_cast< wxPoint * >(argp1);
6282 {
6283 result = (PyObject *)wxPoint_Get(arg1);
6284 if (PyErr_Occurred()) SWIG_fail;
6285 }
6286 resultobj = result;
6287 return resultobj;
6288 fail:
6289 return NULL;
6290 }
6291
6292
6293 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6294 PyObject *obj;
6295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6296 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6297 return SWIG_Py_Void();
6298 }
6299
6300 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6301 return SWIG_Python_InitShadowInstance(args);
6302 }
6303
6304 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6305 PyObject *resultobj = 0;
6306 int arg1 = (int) 0 ;
6307 int arg2 = (int) 0 ;
6308 int arg3 = (int) 0 ;
6309 int arg4 = (int) 0 ;
6310 wxRect *result = 0 ;
6311 int val1 ;
6312 int ecode1 = 0 ;
6313 int val2 ;
6314 int ecode2 = 0 ;
6315 int val3 ;
6316 int ecode3 = 0 ;
6317 int val4 ;
6318 int ecode4 = 0 ;
6319 PyObject * obj0 = 0 ;
6320 PyObject * obj1 = 0 ;
6321 PyObject * obj2 = 0 ;
6322 PyObject * obj3 = 0 ;
6323 char * kwnames[] = {
6324 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6325 };
6326
6327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6328 if (obj0) {
6329 ecode1 = SWIG_AsVal_int(obj0, &val1);
6330 if (!SWIG_IsOK(ecode1)) {
6331 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6332 }
6333 arg1 = static_cast< int >(val1);
6334 }
6335 if (obj1) {
6336 ecode2 = SWIG_AsVal_int(obj1, &val2);
6337 if (!SWIG_IsOK(ecode2)) {
6338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6339 }
6340 arg2 = static_cast< int >(val2);
6341 }
6342 if (obj2) {
6343 ecode3 = SWIG_AsVal_int(obj2, &val3);
6344 if (!SWIG_IsOK(ecode3)) {
6345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6346 }
6347 arg3 = static_cast< int >(val3);
6348 }
6349 if (obj3) {
6350 ecode4 = SWIG_AsVal_int(obj3, &val4);
6351 if (!SWIG_IsOK(ecode4)) {
6352 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6353 }
6354 arg4 = static_cast< int >(val4);
6355 }
6356 {
6357 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6358 if (PyErr_Occurred()) SWIG_fail;
6359 }
6360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6361 return resultobj;
6362 fail:
6363 return NULL;
6364 }
6365
6366
6367 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6368 PyObject *resultobj = 0;
6369 wxPoint *arg1 = 0 ;
6370 wxPoint *arg2 = 0 ;
6371 wxRect *result = 0 ;
6372 wxPoint temp1 ;
6373 wxPoint temp2 ;
6374 PyObject * obj0 = 0 ;
6375 PyObject * obj1 = 0 ;
6376 char * kwnames[] = {
6377 (char *) "topLeft",(char *) "bottomRight", NULL
6378 };
6379
6380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6381 {
6382 arg1 = &temp1;
6383 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6384 }
6385 {
6386 arg2 = &temp2;
6387 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6388 }
6389 {
6390 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6391 if (PyErr_Occurred()) SWIG_fail;
6392 }
6393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6394 return resultobj;
6395 fail:
6396 return NULL;
6397 }
6398
6399
6400 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6401 PyObject *resultobj = 0;
6402 wxPoint *arg1 = 0 ;
6403 wxSize *arg2 = 0 ;
6404 wxRect *result = 0 ;
6405 wxPoint temp1 ;
6406 wxSize temp2 ;
6407 PyObject * obj0 = 0 ;
6408 PyObject * obj1 = 0 ;
6409 char * kwnames[] = {
6410 (char *) "pos",(char *) "size", NULL
6411 };
6412
6413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6414 {
6415 arg1 = &temp1;
6416 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6417 }
6418 {
6419 arg2 = &temp2;
6420 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6421 }
6422 {
6423 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6424 if (PyErr_Occurred()) SWIG_fail;
6425 }
6426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6427 return resultobj;
6428 fail:
6429 return NULL;
6430 }
6431
6432
6433 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6434 PyObject *resultobj = 0;
6435 wxSize *arg1 = 0 ;
6436 wxRect *result = 0 ;
6437 wxSize temp1 ;
6438 PyObject * obj0 = 0 ;
6439 char * kwnames[] = {
6440 (char *) "size", NULL
6441 };
6442
6443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6444 {
6445 arg1 = &temp1;
6446 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6447 }
6448 {
6449 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6450 if (PyErr_Occurred()) SWIG_fail;
6451 }
6452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6453 return resultobj;
6454 fail:
6455 return NULL;
6456 }
6457
6458
6459 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6460 PyObject *resultobj = 0;
6461 wxRect *arg1 = (wxRect *) 0 ;
6462 void *argp1 = 0 ;
6463 int res1 = 0 ;
6464 PyObject *swig_obj[1] ;
6465
6466 if (!args) SWIG_fail;
6467 swig_obj[0] = args;
6468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6469 if (!SWIG_IsOK(res1)) {
6470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6471 }
6472 arg1 = reinterpret_cast< wxRect * >(argp1);
6473 {
6474 delete arg1;
6475
6476 if (PyErr_Occurred()) SWIG_fail;
6477 }
6478 resultobj = SWIG_Py_Void();
6479 return resultobj;
6480 fail:
6481 return NULL;
6482 }
6483
6484
6485 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6486 PyObject *resultobj = 0;
6487 wxRect *arg1 = (wxRect *) 0 ;
6488 int result;
6489 void *argp1 = 0 ;
6490 int res1 = 0 ;
6491 PyObject *swig_obj[1] ;
6492
6493 if (!args) SWIG_fail;
6494 swig_obj[0] = args;
6495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6496 if (!SWIG_IsOK(res1)) {
6497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6498 }
6499 arg1 = reinterpret_cast< wxRect * >(argp1);
6500 {
6501 result = (int)((wxRect const *)arg1)->GetX();
6502 if (PyErr_Occurred()) SWIG_fail;
6503 }
6504 resultobj = SWIG_From_int(static_cast< int >(result));
6505 return resultobj;
6506 fail:
6507 return NULL;
6508 }
6509
6510
6511 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6512 PyObject *resultobj = 0;
6513 wxRect *arg1 = (wxRect *) 0 ;
6514 int arg2 ;
6515 void *argp1 = 0 ;
6516 int res1 = 0 ;
6517 int val2 ;
6518 int ecode2 = 0 ;
6519 PyObject * obj0 = 0 ;
6520 PyObject * obj1 = 0 ;
6521 char * kwnames[] = {
6522 (char *) "self",(char *) "x", NULL
6523 };
6524
6525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6527 if (!SWIG_IsOK(res1)) {
6528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6529 }
6530 arg1 = reinterpret_cast< wxRect * >(argp1);
6531 ecode2 = SWIG_AsVal_int(obj1, &val2);
6532 if (!SWIG_IsOK(ecode2)) {
6533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6534 }
6535 arg2 = static_cast< int >(val2);
6536 {
6537 (arg1)->SetX(arg2);
6538 if (PyErr_Occurred()) SWIG_fail;
6539 }
6540 resultobj = SWIG_Py_Void();
6541 return resultobj;
6542 fail:
6543 return NULL;
6544 }
6545
6546
6547 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6548 PyObject *resultobj = 0;
6549 wxRect *arg1 = (wxRect *) 0 ;
6550 int result;
6551 void *argp1 = 0 ;
6552 int res1 = 0 ;
6553 PyObject *swig_obj[1] ;
6554
6555 if (!args) SWIG_fail;
6556 swig_obj[0] = args;
6557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6558 if (!SWIG_IsOK(res1)) {
6559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6560 }
6561 arg1 = reinterpret_cast< wxRect * >(argp1);
6562 {
6563 result = (int)(arg1)->GetY();
6564 if (PyErr_Occurred()) SWIG_fail;
6565 }
6566 resultobj = SWIG_From_int(static_cast< int >(result));
6567 return resultobj;
6568 fail:
6569 return NULL;
6570 }
6571
6572
6573 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6574 PyObject *resultobj = 0;
6575 wxRect *arg1 = (wxRect *) 0 ;
6576 int arg2 ;
6577 void *argp1 = 0 ;
6578 int res1 = 0 ;
6579 int val2 ;
6580 int ecode2 = 0 ;
6581 PyObject * obj0 = 0 ;
6582 PyObject * obj1 = 0 ;
6583 char * kwnames[] = {
6584 (char *) "self",(char *) "y", NULL
6585 };
6586
6587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6589 if (!SWIG_IsOK(res1)) {
6590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6591 }
6592 arg1 = reinterpret_cast< wxRect * >(argp1);
6593 ecode2 = SWIG_AsVal_int(obj1, &val2);
6594 if (!SWIG_IsOK(ecode2)) {
6595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6596 }
6597 arg2 = static_cast< int >(val2);
6598 {
6599 (arg1)->SetY(arg2);
6600 if (PyErr_Occurred()) SWIG_fail;
6601 }
6602 resultobj = SWIG_Py_Void();
6603 return resultobj;
6604 fail:
6605 return NULL;
6606 }
6607
6608
6609 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6610 PyObject *resultobj = 0;
6611 wxRect *arg1 = (wxRect *) 0 ;
6612 int result;
6613 void *argp1 = 0 ;
6614 int res1 = 0 ;
6615 PyObject *swig_obj[1] ;
6616
6617 if (!args) SWIG_fail;
6618 swig_obj[0] = args;
6619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6620 if (!SWIG_IsOK(res1)) {
6621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6622 }
6623 arg1 = reinterpret_cast< wxRect * >(argp1);
6624 {
6625 result = (int)((wxRect const *)arg1)->GetWidth();
6626 if (PyErr_Occurred()) SWIG_fail;
6627 }
6628 resultobj = SWIG_From_int(static_cast< int >(result));
6629 return resultobj;
6630 fail:
6631 return NULL;
6632 }
6633
6634
6635 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6636 PyObject *resultobj = 0;
6637 wxRect *arg1 = (wxRect *) 0 ;
6638 int arg2 ;
6639 void *argp1 = 0 ;
6640 int res1 = 0 ;
6641 int val2 ;
6642 int ecode2 = 0 ;
6643 PyObject * obj0 = 0 ;
6644 PyObject * obj1 = 0 ;
6645 char * kwnames[] = {
6646 (char *) "self",(char *) "w", NULL
6647 };
6648
6649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6651 if (!SWIG_IsOK(res1)) {
6652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6653 }
6654 arg1 = reinterpret_cast< wxRect * >(argp1);
6655 ecode2 = SWIG_AsVal_int(obj1, &val2);
6656 if (!SWIG_IsOK(ecode2)) {
6657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6658 }
6659 arg2 = static_cast< int >(val2);
6660 {
6661 (arg1)->SetWidth(arg2);
6662 if (PyErr_Occurred()) SWIG_fail;
6663 }
6664 resultobj = SWIG_Py_Void();
6665 return resultobj;
6666 fail:
6667 return NULL;
6668 }
6669
6670
6671 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6672 PyObject *resultobj = 0;
6673 wxRect *arg1 = (wxRect *) 0 ;
6674 int result;
6675 void *argp1 = 0 ;
6676 int res1 = 0 ;
6677 PyObject *swig_obj[1] ;
6678
6679 if (!args) SWIG_fail;
6680 swig_obj[0] = args;
6681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6682 if (!SWIG_IsOK(res1)) {
6683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6684 }
6685 arg1 = reinterpret_cast< wxRect * >(argp1);
6686 {
6687 result = (int)((wxRect const *)arg1)->GetHeight();
6688 if (PyErr_Occurred()) SWIG_fail;
6689 }
6690 resultobj = SWIG_From_int(static_cast< int >(result));
6691 return resultobj;
6692 fail:
6693 return NULL;
6694 }
6695
6696
6697 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6698 PyObject *resultobj = 0;
6699 wxRect *arg1 = (wxRect *) 0 ;
6700 int arg2 ;
6701 void *argp1 = 0 ;
6702 int res1 = 0 ;
6703 int val2 ;
6704 int ecode2 = 0 ;
6705 PyObject * obj0 = 0 ;
6706 PyObject * obj1 = 0 ;
6707 char * kwnames[] = {
6708 (char *) "self",(char *) "h", NULL
6709 };
6710
6711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6713 if (!SWIG_IsOK(res1)) {
6714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6715 }
6716 arg1 = reinterpret_cast< wxRect * >(argp1);
6717 ecode2 = SWIG_AsVal_int(obj1, &val2);
6718 if (!SWIG_IsOK(ecode2)) {
6719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6720 }
6721 arg2 = static_cast< int >(val2);
6722 {
6723 (arg1)->SetHeight(arg2);
6724 if (PyErr_Occurred()) SWIG_fail;
6725 }
6726 resultobj = SWIG_Py_Void();
6727 return resultobj;
6728 fail:
6729 return NULL;
6730 }
6731
6732
6733 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6734 PyObject *resultobj = 0;
6735 wxRect *arg1 = (wxRect *) 0 ;
6736 wxPoint result;
6737 void *argp1 = 0 ;
6738 int res1 = 0 ;
6739 PyObject *swig_obj[1] ;
6740
6741 if (!args) SWIG_fail;
6742 swig_obj[0] = args;
6743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6744 if (!SWIG_IsOK(res1)) {
6745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6746 }
6747 arg1 = reinterpret_cast< wxRect * >(argp1);
6748 {
6749 result = ((wxRect const *)arg1)->GetPosition();
6750 if (PyErr_Occurred()) SWIG_fail;
6751 }
6752 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6753 return resultobj;
6754 fail:
6755 return NULL;
6756 }
6757
6758
6759 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6760 PyObject *resultobj = 0;
6761 wxRect *arg1 = (wxRect *) 0 ;
6762 wxPoint *arg2 = 0 ;
6763 void *argp1 = 0 ;
6764 int res1 = 0 ;
6765 wxPoint temp2 ;
6766 PyObject * obj0 = 0 ;
6767 PyObject * obj1 = 0 ;
6768 char * kwnames[] = {
6769 (char *) "self",(char *) "p", NULL
6770 };
6771
6772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6774 if (!SWIG_IsOK(res1)) {
6775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6776 }
6777 arg1 = reinterpret_cast< wxRect * >(argp1);
6778 {
6779 arg2 = &temp2;
6780 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6781 }
6782 {
6783 (arg1)->SetPosition((wxPoint const &)*arg2);
6784 if (PyErr_Occurred()) SWIG_fail;
6785 }
6786 resultobj = SWIG_Py_Void();
6787 return resultobj;
6788 fail:
6789 return NULL;
6790 }
6791
6792
6793 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6794 PyObject *resultobj = 0;
6795 wxRect *arg1 = (wxRect *) 0 ;
6796 wxSize result;
6797 void *argp1 = 0 ;
6798 int res1 = 0 ;
6799 PyObject *swig_obj[1] ;
6800
6801 if (!args) SWIG_fail;
6802 swig_obj[0] = args;
6803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6804 if (!SWIG_IsOK(res1)) {
6805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6806 }
6807 arg1 = reinterpret_cast< wxRect * >(argp1);
6808 {
6809 result = ((wxRect const *)arg1)->GetSize();
6810 if (PyErr_Occurred()) SWIG_fail;
6811 }
6812 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6813 return resultobj;
6814 fail:
6815 return NULL;
6816 }
6817
6818
6819 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6820 PyObject *resultobj = 0;
6821 wxRect *arg1 = (wxRect *) 0 ;
6822 wxSize *arg2 = 0 ;
6823 void *argp1 = 0 ;
6824 int res1 = 0 ;
6825 wxSize temp2 ;
6826 PyObject * obj0 = 0 ;
6827 PyObject * obj1 = 0 ;
6828 char * kwnames[] = {
6829 (char *) "self",(char *) "s", NULL
6830 };
6831
6832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6834 if (!SWIG_IsOK(res1)) {
6835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6836 }
6837 arg1 = reinterpret_cast< wxRect * >(argp1);
6838 {
6839 arg2 = &temp2;
6840 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6841 }
6842 {
6843 (arg1)->SetSize((wxSize const &)*arg2);
6844 if (PyErr_Occurred()) SWIG_fail;
6845 }
6846 resultobj = SWIG_Py_Void();
6847 return resultobj;
6848 fail:
6849 return NULL;
6850 }
6851
6852
6853 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6854 PyObject *resultobj = 0;
6855 wxRect *arg1 = (wxRect *) 0 ;
6856 bool result;
6857 void *argp1 = 0 ;
6858 int res1 = 0 ;
6859 PyObject *swig_obj[1] ;
6860
6861 if (!args) SWIG_fail;
6862 swig_obj[0] = args;
6863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6864 if (!SWIG_IsOK(res1)) {
6865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6866 }
6867 arg1 = reinterpret_cast< wxRect * >(argp1);
6868 {
6869 result = (bool)((wxRect const *)arg1)->IsEmpty();
6870 if (PyErr_Occurred()) SWIG_fail;
6871 }
6872 {
6873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6874 }
6875 return resultobj;
6876 fail:
6877 return NULL;
6878 }
6879
6880
6881 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6882 PyObject *resultobj = 0;
6883 wxRect *arg1 = (wxRect *) 0 ;
6884 wxPoint result;
6885 void *argp1 = 0 ;
6886 int res1 = 0 ;
6887 PyObject *swig_obj[1] ;
6888
6889 if (!args) SWIG_fail;
6890 swig_obj[0] = args;
6891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6892 if (!SWIG_IsOK(res1)) {
6893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6894 }
6895 arg1 = reinterpret_cast< wxRect * >(argp1);
6896 {
6897 result = ((wxRect const *)arg1)->GetTopLeft();
6898 if (PyErr_Occurred()) SWIG_fail;
6899 }
6900 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6901 return resultobj;
6902 fail:
6903 return NULL;
6904 }
6905
6906
6907 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6908 PyObject *resultobj = 0;
6909 wxRect *arg1 = (wxRect *) 0 ;
6910 wxPoint *arg2 = 0 ;
6911 void *argp1 = 0 ;
6912 int res1 = 0 ;
6913 wxPoint temp2 ;
6914 PyObject * obj0 = 0 ;
6915 PyObject * obj1 = 0 ;
6916 char * kwnames[] = {
6917 (char *) "self",(char *) "p", NULL
6918 };
6919
6920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6922 if (!SWIG_IsOK(res1)) {
6923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6924 }
6925 arg1 = reinterpret_cast< wxRect * >(argp1);
6926 {
6927 arg2 = &temp2;
6928 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6929 }
6930 {
6931 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6932 if (PyErr_Occurred()) SWIG_fail;
6933 }
6934 resultobj = SWIG_Py_Void();
6935 return resultobj;
6936 fail:
6937 return NULL;
6938 }
6939
6940
6941 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6942 PyObject *resultobj = 0;
6943 wxRect *arg1 = (wxRect *) 0 ;
6944 wxPoint result;
6945 void *argp1 = 0 ;
6946 int res1 = 0 ;
6947 PyObject *swig_obj[1] ;
6948
6949 if (!args) SWIG_fail;
6950 swig_obj[0] = args;
6951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6952 if (!SWIG_IsOK(res1)) {
6953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6954 }
6955 arg1 = reinterpret_cast< wxRect * >(argp1);
6956 {
6957 result = ((wxRect const *)arg1)->GetBottomRight();
6958 if (PyErr_Occurred()) SWIG_fail;
6959 }
6960 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6961 return resultobj;
6962 fail:
6963 return NULL;
6964 }
6965
6966
6967 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6968 PyObject *resultobj = 0;
6969 wxRect *arg1 = (wxRect *) 0 ;
6970 wxPoint *arg2 = 0 ;
6971 void *argp1 = 0 ;
6972 int res1 = 0 ;
6973 wxPoint temp2 ;
6974 PyObject * obj0 = 0 ;
6975 PyObject * obj1 = 0 ;
6976 char * kwnames[] = {
6977 (char *) "self",(char *) "p", NULL
6978 };
6979
6980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6982 if (!SWIG_IsOK(res1)) {
6983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6984 }
6985 arg1 = reinterpret_cast< wxRect * >(argp1);
6986 {
6987 arg2 = &temp2;
6988 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6989 }
6990 {
6991 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6992 if (PyErr_Occurred()) SWIG_fail;
6993 }
6994 resultobj = SWIG_Py_Void();
6995 return resultobj;
6996 fail:
6997 return NULL;
6998 }
6999
7000
7001 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7002 PyObject *resultobj = 0;
7003 wxRect *arg1 = (wxRect *) 0 ;
7004 wxPoint result;
7005 void *argp1 = 0 ;
7006 int res1 = 0 ;
7007 PyObject *swig_obj[1] ;
7008
7009 if (!args) SWIG_fail;
7010 swig_obj[0] = args;
7011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7012 if (!SWIG_IsOK(res1)) {
7013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7014 }
7015 arg1 = reinterpret_cast< wxRect * >(argp1);
7016 {
7017 result = ((wxRect const *)arg1)->GetTopRight();
7018 if (PyErr_Occurred()) SWIG_fail;
7019 }
7020 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7021 return resultobj;
7022 fail:
7023 return NULL;
7024 }
7025
7026
7027 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7028 PyObject *resultobj = 0;
7029 wxRect *arg1 = (wxRect *) 0 ;
7030 wxPoint *arg2 = 0 ;
7031 void *argp1 = 0 ;
7032 int res1 = 0 ;
7033 wxPoint temp2 ;
7034 PyObject * obj0 = 0 ;
7035 PyObject * obj1 = 0 ;
7036 char * kwnames[] = {
7037 (char *) "self",(char *) "p", NULL
7038 };
7039
7040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
7041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7042 if (!SWIG_IsOK(res1)) {
7043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
7044 }
7045 arg1 = reinterpret_cast< wxRect * >(argp1);
7046 {
7047 arg2 = &temp2;
7048 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7049 }
7050 {
7051 (arg1)->SetTopRight((wxPoint const &)*arg2);
7052 if (PyErr_Occurred()) SWIG_fail;
7053 }
7054 resultobj = SWIG_Py_Void();
7055 return resultobj;
7056 fail:
7057 return NULL;
7058 }
7059
7060
7061 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7062 PyObject *resultobj = 0;
7063 wxRect *arg1 = (wxRect *) 0 ;
7064 wxPoint result;
7065 void *argp1 = 0 ;
7066 int res1 = 0 ;
7067 PyObject *swig_obj[1] ;
7068
7069 if (!args) SWIG_fail;
7070 swig_obj[0] = args;
7071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7072 if (!SWIG_IsOK(res1)) {
7073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7074 }
7075 arg1 = reinterpret_cast< wxRect * >(argp1);
7076 {
7077 result = ((wxRect const *)arg1)->GetBottomLeft();
7078 if (PyErr_Occurred()) SWIG_fail;
7079 }
7080 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7081 return resultobj;
7082 fail:
7083 return NULL;
7084 }
7085
7086
7087 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7088 PyObject *resultobj = 0;
7089 wxRect *arg1 = (wxRect *) 0 ;
7090 wxPoint *arg2 = 0 ;
7091 void *argp1 = 0 ;
7092 int res1 = 0 ;
7093 wxPoint temp2 ;
7094 PyObject * obj0 = 0 ;
7095 PyObject * obj1 = 0 ;
7096 char * kwnames[] = {
7097 (char *) "self",(char *) "p", NULL
7098 };
7099
7100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7102 if (!SWIG_IsOK(res1)) {
7103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7104 }
7105 arg1 = reinterpret_cast< wxRect * >(argp1);
7106 {
7107 arg2 = &temp2;
7108 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7109 }
7110 {
7111 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7112 if (PyErr_Occurred()) SWIG_fail;
7113 }
7114 resultobj = SWIG_Py_Void();
7115 return resultobj;
7116 fail:
7117 return NULL;
7118 }
7119
7120
7121 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7122 PyObject *resultobj = 0;
7123 wxRect *arg1 = (wxRect *) 0 ;
7124 int result;
7125 void *argp1 = 0 ;
7126 int res1 = 0 ;
7127 PyObject *swig_obj[1] ;
7128
7129 if (!args) SWIG_fail;
7130 swig_obj[0] = args;
7131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7132 if (!SWIG_IsOK(res1)) {
7133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7134 }
7135 arg1 = reinterpret_cast< wxRect * >(argp1);
7136 {
7137 result = (int)((wxRect const *)arg1)->GetLeft();
7138 if (PyErr_Occurred()) SWIG_fail;
7139 }
7140 resultobj = SWIG_From_int(static_cast< int >(result));
7141 return resultobj;
7142 fail:
7143 return NULL;
7144 }
7145
7146
7147 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7148 PyObject *resultobj = 0;
7149 wxRect *arg1 = (wxRect *) 0 ;
7150 int result;
7151 void *argp1 = 0 ;
7152 int res1 = 0 ;
7153 PyObject *swig_obj[1] ;
7154
7155 if (!args) SWIG_fail;
7156 swig_obj[0] = args;
7157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7158 if (!SWIG_IsOK(res1)) {
7159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7160 }
7161 arg1 = reinterpret_cast< wxRect * >(argp1);
7162 {
7163 result = (int)((wxRect const *)arg1)->GetTop();
7164 if (PyErr_Occurred()) SWIG_fail;
7165 }
7166 resultobj = SWIG_From_int(static_cast< int >(result));
7167 return resultobj;
7168 fail:
7169 return NULL;
7170 }
7171
7172
7173 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7174 PyObject *resultobj = 0;
7175 wxRect *arg1 = (wxRect *) 0 ;
7176 int result;
7177 void *argp1 = 0 ;
7178 int res1 = 0 ;
7179 PyObject *swig_obj[1] ;
7180
7181 if (!args) SWIG_fail;
7182 swig_obj[0] = args;
7183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7184 if (!SWIG_IsOK(res1)) {
7185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7186 }
7187 arg1 = reinterpret_cast< wxRect * >(argp1);
7188 {
7189 result = (int)((wxRect const *)arg1)->GetBottom();
7190 if (PyErr_Occurred()) SWIG_fail;
7191 }
7192 resultobj = SWIG_From_int(static_cast< int >(result));
7193 return resultobj;
7194 fail:
7195 return NULL;
7196 }
7197
7198
7199 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7200 PyObject *resultobj = 0;
7201 wxRect *arg1 = (wxRect *) 0 ;
7202 int result;
7203 void *argp1 = 0 ;
7204 int res1 = 0 ;
7205 PyObject *swig_obj[1] ;
7206
7207 if (!args) SWIG_fail;
7208 swig_obj[0] = args;
7209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7210 if (!SWIG_IsOK(res1)) {
7211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7212 }
7213 arg1 = reinterpret_cast< wxRect * >(argp1);
7214 {
7215 result = (int)((wxRect const *)arg1)->GetRight();
7216 if (PyErr_Occurred()) SWIG_fail;
7217 }
7218 resultobj = SWIG_From_int(static_cast< int >(result));
7219 return resultobj;
7220 fail:
7221 return NULL;
7222 }
7223
7224
7225 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7226 PyObject *resultobj = 0;
7227 wxRect *arg1 = (wxRect *) 0 ;
7228 int arg2 ;
7229 void *argp1 = 0 ;
7230 int res1 = 0 ;
7231 int val2 ;
7232 int ecode2 = 0 ;
7233 PyObject * obj0 = 0 ;
7234 PyObject * obj1 = 0 ;
7235 char * kwnames[] = {
7236 (char *) "self",(char *) "left", NULL
7237 };
7238
7239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7241 if (!SWIG_IsOK(res1)) {
7242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7243 }
7244 arg1 = reinterpret_cast< wxRect * >(argp1);
7245 ecode2 = SWIG_AsVal_int(obj1, &val2);
7246 if (!SWIG_IsOK(ecode2)) {
7247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7248 }
7249 arg2 = static_cast< int >(val2);
7250 {
7251 (arg1)->SetLeft(arg2);
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_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7262 PyObject *resultobj = 0;
7263 wxRect *arg1 = (wxRect *) 0 ;
7264 int arg2 ;
7265 void *argp1 = 0 ;
7266 int res1 = 0 ;
7267 int val2 ;
7268 int ecode2 = 0 ;
7269 PyObject * obj0 = 0 ;
7270 PyObject * obj1 = 0 ;
7271 char * kwnames[] = {
7272 (char *) "self",(char *) "right", NULL
7273 };
7274
7275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",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_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7279 }
7280 arg1 = reinterpret_cast< wxRect * >(argp1);
7281 ecode2 = SWIG_AsVal_int(obj1, &val2);
7282 if (!SWIG_IsOK(ecode2)) {
7283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7284 }
7285 arg2 = static_cast< int >(val2);
7286 {
7287 (arg1)->SetRight(arg2);
7288 if (PyErr_Occurred()) SWIG_fail;
7289 }
7290 resultobj = SWIG_Py_Void();
7291 return resultobj;
7292 fail:
7293 return NULL;
7294 }
7295
7296
7297 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7298 PyObject *resultobj = 0;
7299 wxRect *arg1 = (wxRect *) 0 ;
7300 int arg2 ;
7301 void *argp1 = 0 ;
7302 int res1 = 0 ;
7303 int val2 ;
7304 int ecode2 = 0 ;
7305 PyObject * obj0 = 0 ;
7306 PyObject * obj1 = 0 ;
7307 char * kwnames[] = {
7308 (char *) "self",(char *) "top", NULL
7309 };
7310
7311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7313 if (!SWIG_IsOK(res1)) {
7314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7315 }
7316 arg1 = reinterpret_cast< wxRect * >(argp1);
7317 ecode2 = SWIG_AsVal_int(obj1, &val2);
7318 if (!SWIG_IsOK(ecode2)) {
7319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7320 }
7321 arg2 = static_cast< int >(val2);
7322 {
7323 (arg1)->SetTop(arg2);
7324 if (PyErr_Occurred()) SWIG_fail;
7325 }
7326 resultobj = SWIG_Py_Void();
7327 return resultobj;
7328 fail:
7329 return NULL;
7330 }
7331
7332
7333 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7334 PyObject *resultobj = 0;
7335 wxRect *arg1 = (wxRect *) 0 ;
7336 int arg2 ;
7337 void *argp1 = 0 ;
7338 int res1 = 0 ;
7339 int val2 ;
7340 int ecode2 = 0 ;
7341 PyObject * obj0 = 0 ;
7342 PyObject * obj1 = 0 ;
7343 char * kwnames[] = {
7344 (char *) "self",(char *) "bottom", NULL
7345 };
7346
7347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7349 if (!SWIG_IsOK(res1)) {
7350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7351 }
7352 arg1 = reinterpret_cast< wxRect * >(argp1);
7353 ecode2 = SWIG_AsVal_int(obj1, &val2);
7354 if (!SWIG_IsOK(ecode2)) {
7355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7356 }
7357 arg2 = static_cast< int >(val2);
7358 {
7359 (arg1)->SetBottom(arg2);
7360 if (PyErr_Occurred()) SWIG_fail;
7361 }
7362 resultobj = SWIG_Py_Void();
7363 return resultobj;
7364 fail:
7365 return NULL;
7366 }
7367
7368
7369 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7370 PyObject *resultobj = 0;
7371 wxRect *arg1 = (wxRect *) 0 ;
7372 int arg2 ;
7373 int arg3 ;
7374 wxRect result;
7375 void *argp1 = 0 ;
7376 int res1 = 0 ;
7377 int val2 ;
7378 int ecode2 = 0 ;
7379 int val3 ;
7380 int ecode3 = 0 ;
7381 PyObject * obj0 = 0 ;
7382 PyObject * obj1 = 0 ;
7383 PyObject * obj2 = 0 ;
7384 char * kwnames[] = {
7385 (char *) "self",(char *) "dx",(char *) "dy", NULL
7386 };
7387
7388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7390 if (!SWIG_IsOK(res1)) {
7391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7392 }
7393 arg1 = reinterpret_cast< wxRect * >(argp1);
7394 ecode2 = SWIG_AsVal_int(obj1, &val2);
7395 if (!SWIG_IsOK(ecode2)) {
7396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7397 }
7398 arg2 = static_cast< int >(val2);
7399 ecode3 = SWIG_AsVal_int(obj2, &val3);
7400 if (!SWIG_IsOK(ecode3)) {
7401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7402 }
7403 arg3 = static_cast< int >(val3);
7404 {
7405 result = (arg1)->Inflate(arg2,arg3);
7406 if (PyErr_Occurred()) SWIG_fail;
7407 }
7408 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7409 return resultobj;
7410 fail:
7411 return NULL;
7412 }
7413
7414
7415 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7416 PyObject *resultobj = 0;
7417 wxRect *arg1 = (wxRect *) 0 ;
7418 int arg2 ;
7419 int arg3 ;
7420 wxRect *result = 0 ;
7421 void *argp1 = 0 ;
7422 int res1 = 0 ;
7423 int val2 ;
7424 int ecode2 = 0 ;
7425 int val3 ;
7426 int ecode3 = 0 ;
7427 PyObject * obj0 = 0 ;
7428 PyObject * obj1 = 0 ;
7429 PyObject * obj2 = 0 ;
7430 char * kwnames[] = {
7431 (char *) "self",(char *) "dx",(char *) "dy", NULL
7432 };
7433
7434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7436 if (!SWIG_IsOK(res1)) {
7437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7438 }
7439 arg1 = reinterpret_cast< wxRect * >(argp1);
7440 ecode2 = SWIG_AsVal_int(obj1, &val2);
7441 if (!SWIG_IsOK(ecode2)) {
7442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7443 }
7444 arg2 = static_cast< int >(val2);
7445 ecode3 = SWIG_AsVal_int(obj2, &val3);
7446 if (!SWIG_IsOK(ecode3)) {
7447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7448 }
7449 arg3 = static_cast< int >(val3);
7450 {
7451 {
7452 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7453 result = (wxRect *) &_result_ref;
7454 }
7455 if (PyErr_Occurred()) SWIG_fail;
7456 }
7457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7458 return resultobj;
7459 fail:
7460 return NULL;
7461 }
7462
7463
7464 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7465 PyObject *resultobj = 0;
7466 wxRect *arg1 = (wxRect *) 0 ;
7467 int arg2 ;
7468 int arg3 ;
7469 void *argp1 = 0 ;
7470 int res1 = 0 ;
7471 int val2 ;
7472 int ecode2 = 0 ;
7473 int val3 ;
7474 int ecode3 = 0 ;
7475 PyObject * obj0 = 0 ;
7476 PyObject * obj1 = 0 ;
7477 PyObject * obj2 = 0 ;
7478 char * kwnames[] = {
7479 (char *) "self",(char *) "dx",(char *) "dy", NULL
7480 };
7481
7482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7484 if (!SWIG_IsOK(res1)) {
7485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7486 }
7487 arg1 = reinterpret_cast< wxRect * >(argp1);
7488 ecode2 = SWIG_AsVal_int(obj1, &val2);
7489 if (!SWIG_IsOK(ecode2)) {
7490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7491 }
7492 arg2 = static_cast< int >(val2);
7493 ecode3 = SWIG_AsVal_int(obj2, &val3);
7494 if (!SWIG_IsOK(ecode3)) {
7495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7496 }
7497 arg3 = static_cast< int >(val3);
7498 {
7499 (arg1)->Offset(arg2,arg3);
7500 if (PyErr_Occurred()) SWIG_fail;
7501 }
7502 resultobj = SWIG_Py_Void();
7503 return resultobj;
7504 fail:
7505 return NULL;
7506 }
7507
7508
7509 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7510 PyObject *resultobj = 0;
7511 wxRect *arg1 = (wxRect *) 0 ;
7512 wxPoint *arg2 = 0 ;
7513 void *argp1 = 0 ;
7514 int res1 = 0 ;
7515 wxPoint temp2 ;
7516 PyObject * obj0 = 0 ;
7517 PyObject * obj1 = 0 ;
7518 char * kwnames[] = {
7519 (char *) "self",(char *) "pt", NULL
7520 };
7521
7522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7524 if (!SWIG_IsOK(res1)) {
7525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7526 }
7527 arg1 = reinterpret_cast< wxRect * >(argp1);
7528 {
7529 arg2 = &temp2;
7530 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7531 }
7532 {
7533 (arg1)->Offset((wxPoint const &)*arg2);
7534 if (PyErr_Occurred()) SWIG_fail;
7535 }
7536 resultobj = SWIG_Py_Void();
7537 return resultobj;
7538 fail:
7539 return NULL;
7540 }
7541
7542
7543 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7544 PyObject *resultobj = 0;
7545 wxRect *arg1 = (wxRect *) 0 ;
7546 wxRect *arg2 = 0 ;
7547 wxRect result;
7548 void *argp1 = 0 ;
7549 int res1 = 0 ;
7550 wxRect temp2 ;
7551 PyObject * obj0 = 0 ;
7552 PyObject * obj1 = 0 ;
7553 char * kwnames[] = {
7554 (char *) "self",(char *) "rect", NULL
7555 };
7556
7557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7559 if (!SWIG_IsOK(res1)) {
7560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7561 }
7562 arg1 = reinterpret_cast< wxRect * >(argp1);
7563 {
7564 arg2 = &temp2;
7565 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7566 }
7567 {
7568 result = (arg1)->Intersect((wxRect const &)*arg2);
7569 if (PyErr_Occurred()) SWIG_fail;
7570 }
7571 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7572 return resultobj;
7573 fail:
7574 return NULL;
7575 }
7576
7577
7578 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7579 PyObject *resultobj = 0;
7580 wxRect *arg1 = (wxRect *) 0 ;
7581 wxRect *arg2 = 0 ;
7582 wxRect result;
7583 void *argp1 = 0 ;
7584 int res1 = 0 ;
7585 wxRect temp2 ;
7586 PyObject * obj0 = 0 ;
7587 PyObject * obj1 = 0 ;
7588 char * kwnames[] = {
7589 (char *) "self",(char *) "rect", NULL
7590 };
7591
7592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7594 if (!SWIG_IsOK(res1)) {
7595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7596 }
7597 arg1 = reinterpret_cast< wxRect * >(argp1);
7598 {
7599 arg2 = &temp2;
7600 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7601 }
7602 {
7603 result = (arg1)->Union((wxRect const &)*arg2);
7604 if (PyErr_Occurred()) SWIG_fail;
7605 }
7606 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7607 return resultobj;
7608 fail:
7609 return NULL;
7610 }
7611
7612
7613 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7614 PyObject *resultobj = 0;
7615 wxRect *arg1 = (wxRect *) 0 ;
7616 wxRect *arg2 = 0 ;
7617 wxRect result;
7618 void *argp1 = 0 ;
7619 int res1 = 0 ;
7620 wxRect temp2 ;
7621 PyObject * obj0 = 0 ;
7622 PyObject * obj1 = 0 ;
7623 char * kwnames[] = {
7624 (char *) "self",(char *) "rect", NULL
7625 };
7626
7627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7629 if (!SWIG_IsOK(res1)) {
7630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7631 }
7632 arg1 = reinterpret_cast< wxRect * >(argp1);
7633 {
7634 arg2 = &temp2;
7635 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7636 }
7637 {
7638 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7639 if (PyErr_Occurred()) SWIG_fail;
7640 }
7641 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7642 return resultobj;
7643 fail:
7644 return NULL;
7645 }
7646
7647
7648 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7649 PyObject *resultobj = 0;
7650 wxRect *arg1 = (wxRect *) 0 ;
7651 wxRect *arg2 = 0 ;
7652 wxRect *result = 0 ;
7653 void *argp1 = 0 ;
7654 int res1 = 0 ;
7655 wxRect temp2 ;
7656 PyObject * obj0 = 0 ;
7657 PyObject * obj1 = 0 ;
7658 char * kwnames[] = {
7659 (char *) "self",(char *) "rect", NULL
7660 };
7661
7662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7664 if (!SWIG_IsOK(res1)) {
7665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7666 }
7667 arg1 = reinterpret_cast< wxRect * >(argp1);
7668 {
7669 arg2 = &temp2;
7670 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7671 }
7672 {
7673 {
7674 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7675 result = (wxRect *) &_result_ref;
7676 }
7677 if (PyErr_Occurred()) SWIG_fail;
7678 }
7679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7680 return resultobj;
7681 fail:
7682 return NULL;
7683 }
7684
7685
7686 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7687 PyObject *resultobj = 0;
7688 wxRect *arg1 = (wxRect *) 0 ;
7689 PyObject *arg2 = (PyObject *) 0 ;
7690 bool result;
7691 void *argp1 = 0 ;
7692 int res1 = 0 ;
7693 PyObject * obj0 = 0 ;
7694 PyObject * obj1 = 0 ;
7695 char * kwnames[] = {
7696 (char *) "self",(char *) "other", NULL
7697 };
7698
7699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7701 if (!SWIG_IsOK(res1)) {
7702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7703 }
7704 arg1 = reinterpret_cast< wxRect * >(argp1);
7705 arg2 = obj1;
7706 {
7707 result = (bool)wxRect___eq__(arg1,arg2);
7708 if (PyErr_Occurred()) SWIG_fail;
7709 }
7710 {
7711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7712 }
7713 return resultobj;
7714 fail:
7715 return NULL;
7716 }
7717
7718
7719 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7720 PyObject *resultobj = 0;
7721 wxRect *arg1 = (wxRect *) 0 ;
7722 PyObject *arg2 = (PyObject *) 0 ;
7723 bool result;
7724 void *argp1 = 0 ;
7725 int res1 = 0 ;
7726 PyObject * obj0 = 0 ;
7727 PyObject * obj1 = 0 ;
7728 char * kwnames[] = {
7729 (char *) "self",(char *) "other", NULL
7730 };
7731
7732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7734 if (!SWIG_IsOK(res1)) {
7735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7736 }
7737 arg1 = reinterpret_cast< wxRect * >(argp1);
7738 arg2 = obj1;
7739 {
7740 result = (bool)wxRect___ne__(arg1,arg2);
7741 if (PyErr_Occurred()) SWIG_fail;
7742 }
7743 {
7744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7745 }
7746 return resultobj;
7747 fail:
7748 return NULL;
7749 }
7750
7751
7752 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7753 PyObject *resultobj = 0;
7754 wxRect *arg1 = (wxRect *) 0 ;
7755 int arg2 ;
7756 int arg3 ;
7757 bool result;
7758 void *argp1 = 0 ;
7759 int res1 = 0 ;
7760 int val2 ;
7761 int ecode2 = 0 ;
7762 int val3 ;
7763 int ecode3 = 0 ;
7764 PyObject * obj0 = 0 ;
7765 PyObject * obj1 = 0 ;
7766 PyObject * obj2 = 0 ;
7767 char * kwnames[] = {
7768 (char *) "self",(char *) "x",(char *) "y", NULL
7769 };
7770
7771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7773 if (!SWIG_IsOK(res1)) {
7774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7775 }
7776 arg1 = reinterpret_cast< wxRect * >(argp1);
7777 ecode2 = SWIG_AsVal_int(obj1, &val2);
7778 if (!SWIG_IsOK(ecode2)) {
7779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7780 }
7781 arg2 = static_cast< int >(val2);
7782 ecode3 = SWIG_AsVal_int(obj2, &val3);
7783 if (!SWIG_IsOK(ecode3)) {
7784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7785 }
7786 arg3 = static_cast< int >(val3);
7787 {
7788 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7789 if (PyErr_Occurred()) SWIG_fail;
7790 }
7791 {
7792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7793 }
7794 return resultobj;
7795 fail:
7796 return NULL;
7797 }
7798
7799
7800 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7801 PyObject *resultobj = 0;
7802 wxRect *arg1 = (wxRect *) 0 ;
7803 wxPoint *arg2 = 0 ;
7804 bool result;
7805 void *argp1 = 0 ;
7806 int res1 = 0 ;
7807 wxPoint temp2 ;
7808 PyObject * obj0 = 0 ;
7809 PyObject * obj1 = 0 ;
7810 char * kwnames[] = {
7811 (char *) "self",(char *) "pt", NULL
7812 };
7813
7814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7816 if (!SWIG_IsOK(res1)) {
7817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7818 }
7819 arg1 = reinterpret_cast< wxRect * >(argp1);
7820 {
7821 arg2 = &temp2;
7822 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7823 }
7824 {
7825 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7826 if (PyErr_Occurred()) SWIG_fail;
7827 }
7828 {
7829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7830 }
7831 return resultobj;
7832 fail:
7833 return NULL;
7834 }
7835
7836
7837 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7838 PyObject *resultobj = 0;
7839 wxRect *arg1 = (wxRect *) 0 ;
7840 wxRect *arg2 = 0 ;
7841 bool result;
7842 void *argp1 = 0 ;
7843 int res1 = 0 ;
7844 wxRect temp2 ;
7845 PyObject * obj0 = 0 ;
7846 PyObject * obj1 = 0 ;
7847 char * kwnames[] = {
7848 (char *) "self",(char *) "rect", NULL
7849 };
7850
7851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7853 if (!SWIG_IsOK(res1)) {
7854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7855 }
7856 arg1 = reinterpret_cast< wxRect * >(argp1);
7857 {
7858 arg2 = &temp2;
7859 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7860 }
7861 {
7862 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7863 if (PyErr_Occurred()) SWIG_fail;
7864 }
7865 {
7866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7867 }
7868 return resultobj;
7869 fail:
7870 return NULL;
7871 }
7872
7873
7874 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7875 PyObject *resultobj = 0;
7876 wxRect *arg1 = (wxRect *) 0 ;
7877 wxRect *arg2 = 0 ;
7878 bool result;
7879 void *argp1 = 0 ;
7880 int res1 = 0 ;
7881 wxRect temp2 ;
7882 PyObject * obj0 = 0 ;
7883 PyObject * obj1 = 0 ;
7884 char * kwnames[] = {
7885 (char *) "self",(char *) "rect", NULL
7886 };
7887
7888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7890 if (!SWIG_IsOK(res1)) {
7891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7892 }
7893 arg1 = reinterpret_cast< wxRect * >(argp1);
7894 {
7895 arg2 = &temp2;
7896 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7897 }
7898 {
7899 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7900 if (PyErr_Occurred()) SWIG_fail;
7901 }
7902 {
7903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7904 }
7905 return resultobj;
7906 fail:
7907 return NULL;
7908 }
7909
7910
7911 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7912 PyObject *resultobj = 0;
7913 wxRect *arg1 = (wxRect *) 0 ;
7914 wxRect *arg2 = 0 ;
7915 int arg3 = (int) wxBOTH ;
7916 wxRect result;
7917 void *argp1 = 0 ;
7918 int res1 = 0 ;
7919 wxRect temp2 ;
7920 int val3 ;
7921 int ecode3 = 0 ;
7922 PyObject * obj0 = 0 ;
7923 PyObject * obj1 = 0 ;
7924 PyObject * obj2 = 0 ;
7925 char * kwnames[] = {
7926 (char *) "self",(char *) "r",(char *) "dir", NULL
7927 };
7928
7929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7931 if (!SWIG_IsOK(res1)) {
7932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7933 }
7934 arg1 = reinterpret_cast< wxRect * >(argp1);
7935 {
7936 arg2 = &temp2;
7937 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7938 }
7939 if (obj2) {
7940 ecode3 = SWIG_AsVal_int(obj2, &val3);
7941 if (!SWIG_IsOK(ecode3)) {
7942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7943 }
7944 arg3 = static_cast< int >(val3);
7945 }
7946 {
7947 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7948 if (PyErr_Occurred()) SWIG_fail;
7949 }
7950 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7951 return resultobj;
7952 fail:
7953 return NULL;
7954 }
7955
7956
7957 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7958 PyObject *resultobj = 0;
7959 wxRect *arg1 = (wxRect *) 0 ;
7960 int arg2 ;
7961 void *argp1 = 0 ;
7962 int res1 = 0 ;
7963 int val2 ;
7964 int ecode2 = 0 ;
7965 PyObject *swig_obj[2] ;
7966
7967 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7969 if (!SWIG_IsOK(res1)) {
7970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7971 }
7972 arg1 = reinterpret_cast< wxRect * >(argp1);
7973 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7974 if (!SWIG_IsOK(ecode2)) {
7975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7976 }
7977 arg2 = static_cast< int >(val2);
7978 if (arg1) (arg1)->x = arg2;
7979
7980 resultobj = SWIG_Py_Void();
7981 return resultobj;
7982 fail:
7983 return NULL;
7984 }
7985
7986
7987 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7988 PyObject *resultobj = 0;
7989 wxRect *arg1 = (wxRect *) 0 ;
7990 int result;
7991 void *argp1 = 0 ;
7992 int res1 = 0 ;
7993 PyObject *swig_obj[1] ;
7994
7995 if (!args) SWIG_fail;
7996 swig_obj[0] = args;
7997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7998 if (!SWIG_IsOK(res1)) {
7999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
8000 }
8001 arg1 = reinterpret_cast< wxRect * >(argp1);
8002 result = (int) ((arg1)->x);
8003 resultobj = SWIG_From_int(static_cast< int >(result));
8004 return resultobj;
8005 fail:
8006 return NULL;
8007 }
8008
8009
8010 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8011 PyObject *resultobj = 0;
8012 wxRect *arg1 = (wxRect *) 0 ;
8013 int arg2 ;
8014 void *argp1 = 0 ;
8015 int res1 = 0 ;
8016 int val2 ;
8017 int ecode2 = 0 ;
8018 PyObject *swig_obj[2] ;
8019
8020 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
8021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8022 if (!SWIG_IsOK(res1)) {
8023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
8024 }
8025 arg1 = reinterpret_cast< wxRect * >(argp1);
8026 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8027 if (!SWIG_IsOK(ecode2)) {
8028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
8029 }
8030 arg2 = static_cast< int >(val2);
8031 if (arg1) (arg1)->y = arg2;
8032
8033 resultobj = SWIG_Py_Void();
8034 return resultobj;
8035 fail:
8036 return NULL;
8037 }
8038
8039
8040 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8041 PyObject *resultobj = 0;
8042 wxRect *arg1 = (wxRect *) 0 ;
8043 int result;
8044 void *argp1 = 0 ;
8045 int res1 = 0 ;
8046 PyObject *swig_obj[1] ;
8047
8048 if (!args) SWIG_fail;
8049 swig_obj[0] = args;
8050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8051 if (!SWIG_IsOK(res1)) {
8052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8053 }
8054 arg1 = reinterpret_cast< wxRect * >(argp1);
8055 result = (int) ((arg1)->y);
8056 resultobj = SWIG_From_int(static_cast< int >(result));
8057 return resultobj;
8058 fail:
8059 return NULL;
8060 }
8061
8062
8063 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8064 PyObject *resultobj = 0;
8065 wxRect *arg1 = (wxRect *) 0 ;
8066 int arg2 ;
8067 void *argp1 = 0 ;
8068 int res1 = 0 ;
8069 int val2 ;
8070 int ecode2 = 0 ;
8071 PyObject *swig_obj[2] ;
8072
8073 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8075 if (!SWIG_IsOK(res1)) {
8076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8077 }
8078 arg1 = reinterpret_cast< wxRect * >(argp1);
8079 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8080 if (!SWIG_IsOK(ecode2)) {
8081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8082 }
8083 arg2 = static_cast< int >(val2);
8084 if (arg1) (arg1)->width = arg2;
8085
8086 resultobj = SWIG_Py_Void();
8087 return resultobj;
8088 fail:
8089 return NULL;
8090 }
8091
8092
8093 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8094 PyObject *resultobj = 0;
8095 wxRect *arg1 = (wxRect *) 0 ;
8096 int result;
8097 void *argp1 = 0 ;
8098 int res1 = 0 ;
8099 PyObject *swig_obj[1] ;
8100
8101 if (!args) SWIG_fail;
8102 swig_obj[0] = args;
8103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8104 if (!SWIG_IsOK(res1)) {
8105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8106 }
8107 arg1 = reinterpret_cast< wxRect * >(argp1);
8108 result = (int) ((arg1)->width);
8109 resultobj = SWIG_From_int(static_cast< int >(result));
8110 return resultobj;
8111 fail:
8112 return NULL;
8113 }
8114
8115
8116 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8117 PyObject *resultobj = 0;
8118 wxRect *arg1 = (wxRect *) 0 ;
8119 int arg2 ;
8120 void *argp1 = 0 ;
8121 int res1 = 0 ;
8122 int val2 ;
8123 int ecode2 = 0 ;
8124 PyObject *swig_obj[2] ;
8125
8126 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8128 if (!SWIG_IsOK(res1)) {
8129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8130 }
8131 arg1 = reinterpret_cast< wxRect * >(argp1);
8132 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8133 if (!SWIG_IsOK(ecode2)) {
8134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8135 }
8136 arg2 = static_cast< int >(val2);
8137 if (arg1) (arg1)->height = arg2;
8138
8139 resultobj = SWIG_Py_Void();
8140 return resultobj;
8141 fail:
8142 return NULL;
8143 }
8144
8145
8146 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8147 PyObject *resultobj = 0;
8148 wxRect *arg1 = (wxRect *) 0 ;
8149 int result;
8150 void *argp1 = 0 ;
8151 int res1 = 0 ;
8152 PyObject *swig_obj[1] ;
8153
8154 if (!args) SWIG_fail;
8155 swig_obj[0] = args;
8156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8157 if (!SWIG_IsOK(res1)) {
8158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8159 }
8160 arg1 = reinterpret_cast< wxRect * >(argp1);
8161 result = (int) ((arg1)->height);
8162 resultobj = SWIG_From_int(static_cast< int >(result));
8163 return resultobj;
8164 fail:
8165 return NULL;
8166 }
8167
8168
8169 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8170 PyObject *resultobj = 0;
8171 wxRect *arg1 = (wxRect *) 0 ;
8172 int arg2 = (int) 0 ;
8173 int arg3 = (int) 0 ;
8174 int arg4 = (int) 0 ;
8175 int arg5 = (int) 0 ;
8176 void *argp1 = 0 ;
8177 int res1 = 0 ;
8178 int val2 ;
8179 int ecode2 = 0 ;
8180 int val3 ;
8181 int ecode3 = 0 ;
8182 int val4 ;
8183 int ecode4 = 0 ;
8184 int val5 ;
8185 int ecode5 = 0 ;
8186 PyObject * obj0 = 0 ;
8187 PyObject * obj1 = 0 ;
8188 PyObject * obj2 = 0 ;
8189 PyObject * obj3 = 0 ;
8190 PyObject * obj4 = 0 ;
8191 char * kwnames[] = {
8192 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8193 };
8194
8195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8197 if (!SWIG_IsOK(res1)) {
8198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8199 }
8200 arg1 = reinterpret_cast< wxRect * >(argp1);
8201 if (obj1) {
8202 ecode2 = SWIG_AsVal_int(obj1, &val2);
8203 if (!SWIG_IsOK(ecode2)) {
8204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8205 }
8206 arg2 = static_cast< int >(val2);
8207 }
8208 if (obj2) {
8209 ecode3 = SWIG_AsVal_int(obj2, &val3);
8210 if (!SWIG_IsOK(ecode3)) {
8211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8212 }
8213 arg3 = static_cast< int >(val3);
8214 }
8215 if (obj3) {
8216 ecode4 = SWIG_AsVal_int(obj3, &val4);
8217 if (!SWIG_IsOK(ecode4)) {
8218 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8219 }
8220 arg4 = static_cast< int >(val4);
8221 }
8222 if (obj4) {
8223 ecode5 = SWIG_AsVal_int(obj4, &val5);
8224 if (!SWIG_IsOK(ecode5)) {
8225 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8226 }
8227 arg5 = static_cast< int >(val5);
8228 }
8229 {
8230 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8231 if (PyErr_Occurred()) SWIG_fail;
8232 }
8233 resultobj = SWIG_Py_Void();
8234 return resultobj;
8235 fail:
8236 return NULL;
8237 }
8238
8239
8240 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8241 PyObject *resultobj = 0;
8242 wxRect *arg1 = (wxRect *) 0 ;
8243 PyObject *result = 0 ;
8244 void *argp1 = 0 ;
8245 int res1 = 0 ;
8246 PyObject *swig_obj[1] ;
8247
8248 if (!args) SWIG_fail;
8249 swig_obj[0] = args;
8250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8251 if (!SWIG_IsOK(res1)) {
8252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8253 }
8254 arg1 = reinterpret_cast< wxRect * >(argp1);
8255 {
8256 result = (PyObject *)wxRect_Get(arg1);
8257 if (PyErr_Occurred()) SWIG_fail;
8258 }
8259 resultobj = result;
8260 return resultobj;
8261 fail:
8262 return NULL;
8263 }
8264
8265
8266 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8267 PyObject *obj;
8268 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8269 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8270 return SWIG_Py_Void();
8271 }
8272
8273 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8274 return SWIG_Python_InitShadowInstance(args);
8275 }
8276
8277 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8278 PyObject *resultobj = 0;
8279 wxRect *arg1 = (wxRect *) 0 ;
8280 wxRect *arg2 = (wxRect *) 0 ;
8281 PyObject *result = 0 ;
8282 void *argp1 = 0 ;
8283 int res1 = 0 ;
8284 void *argp2 = 0 ;
8285 int res2 = 0 ;
8286 PyObject * obj0 = 0 ;
8287 PyObject * obj1 = 0 ;
8288 char * kwnames[] = {
8289 (char *) "r1",(char *) "r2", NULL
8290 };
8291
8292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8294 if (!SWIG_IsOK(res1)) {
8295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8296 }
8297 arg1 = reinterpret_cast< wxRect * >(argp1);
8298 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8299 if (!SWIG_IsOK(res2)) {
8300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8301 }
8302 arg2 = reinterpret_cast< wxRect * >(argp2);
8303 {
8304 if (!wxPyCheckForApp()) SWIG_fail;
8305 PyThreadState* __tstate = wxPyBeginAllowThreads();
8306 result = (PyObject *)wxIntersectRect(arg1,arg2);
8307 wxPyEndAllowThreads(__tstate);
8308 if (PyErr_Occurred()) SWIG_fail;
8309 }
8310 resultobj = result;
8311 return resultobj;
8312 fail:
8313 return NULL;
8314 }
8315
8316
8317 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8318 PyObject *resultobj = 0;
8319 double arg1 = (double) 0.0 ;
8320 double arg2 = (double) 0.0 ;
8321 wxPoint2D *result = 0 ;
8322 double val1 ;
8323 int ecode1 = 0 ;
8324 double val2 ;
8325 int ecode2 = 0 ;
8326 PyObject * obj0 = 0 ;
8327 PyObject * obj1 = 0 ;
8328 char * kwnames[] = {
8329 (char *) "x",(char *) "y", NULL
8330 };
8331
8332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8333 if (obj0) {
8334 ecode1 = SWIG_AsVal_double(obj0, &val1);
8335 if (!SWIG_IsOK(ecode1)) {
8336 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8337 }
8338 arg1 = static_cast< double >(val1);
8339 }
8340 if (obj1) {
8341 ecode2 = SWIG_AsVal_double(obj1, &val2);
8342 if (!SWIG_IsOK(ecode2)) {
8343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8344 }
8345 arg2 = static_cast< double >(val2);
8346 }
8347 {
8348 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8349 if (PyErr_Occurred()) SWIG_fail;
8350 }
8351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8352 return resultobj;
8353 fail:
8354 return NULL;
8355 }
8356
8357
8358 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8359 PyObject *resultobj = 0;
8360 wxPoint2D *arg1 = 0 ;
8361 wxPoint2D *result = 0 ;
8362 wxPoint2D temp1 ;
8363 PyObject * obj0 = 0 ;
8364 char * kwnames[] = {
8365 (char *) "pt", NULL
8366 };
8367
8368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8369 {
8370 arg1 = &temp1;
8371 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8372 }
8373 {
8374 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8375 if (PyErr_Occurred()) SWIG_fail;
8376 }
8377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8378 return resultobj;
8379 fail:
8380 return NULL;
8381 }
8382
8383
8384 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8385 PyObject *resultobj = 0;
8386 wxPoint *arg1 = 0 ;
8387 wxPoint2D *result = 0 ;
8388 wxPoint temp1 ;
8389 PyObject * obj0 = 0 ;
8390 char * kwnames[] = {
8391 (char *) "pt", NULL
8392 };
8393
8394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8395 {
8396 arg1 = &temp1;
8397 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8398 }
8399 {
8400 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8401 if (PyErr_Occurred()) SWIG_fail;
8402 }
8403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8404 return resultobj;
8405 fail:
8406 return NULL;
8407 }
8408
8409
8410 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8411 PyObject *resultobj = 0;
8412 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8413 void *argp1 = 0 ;
8414 int res1 = 0 ;
8415 PyObject *swig_obj[1] ;
8416
8417 if (!args) SWIG_fail;
8418 swig_obj[0] = args;
8419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8420 if (!SWIG_IsOK(res1)) {
8421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8422 }
8423 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8424 {
8425 delete arg1;
8426
8427 if (PyErr_Occurred()) SWIG_fail;
8428 }
8429 resultobj = SWIG_Py_Void();
8430 return resultobj;
8431 fail:
8432 return NULL;
8433 }
8434
8435
8436 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8437 PyObject *resultobj = 0;
8438 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8439 int *arg2 = (int *) 0 ;
8440 int *arg3 = (int *) 0 ;
8441 void *argp1 = 0 ;
8442 int res1 = 0 ;
8443 int temp2 ;
8444 int res2 = SWIG_TMPOBJ ;
8445 int temp3 ;
8446 int res3 = SWIG_TMPOBJ ;
8447 PyObject *swig_obj[1] ;
8448
8449 arg2 = &temp2;
8450 arg3 = &temp3;
8451 if (!args) SWIG_fail;
8452 swig_obj[0] = args;
8453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8454 if (!SWIG_IsOK(res1)) {
8455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8456 }
8457 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8458 {
8459 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8460 if (PyErr_Occurred()) SWIG_fail;
8461 }
8462 resultobj = SWIG_Py_Void();
8463 if (SWIG_IsTmpObj(res2)) {
8464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8465 } else {
8466 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8468 }
8469 if (SWIG_IsTmpObj(res3)) {
8470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8471 } else {
8472 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8473 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8474 }
8475 return resultobj;
8476 fail:
8477 return NULL;
8478 }
8479
8480
8481 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8482 PyObject *resultobj = 0;
8483 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8484 int *arg2 = (int *) 0 ;
8485 int *arg3 = (int *) 0 ;
8486 void *argp1 = 0 ;
8487 int res1 = 0 ;
8488 int temp2 ;
8489 int res2 = SWIG_TMPOBJ ;
8490 int temp3 ;
8491 int res3 = SWIG_TMPOBJ ;
8492 PyObject *swig_obj[1] ;
8493
8494 arg2 = &temp2;
8495 arg3 = &temp3;
8496 if (!args) SWIG_fail;
8497 swig_obj[0] = args;
8498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8499 if (!SWIG_IsOK(res1)) {
8500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8501 }
8502 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8503 {
8504 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8505 if (PyErr_Occurred()) SWIG_fail;
8506 }
8507 resultobj = SWIG_Py_Void();
8508 if (SWIG_IsTmpObj(res2)) {
8509 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8510 } else {
8511 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8512 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8513 }
8514 if (SWIG_IsTmpObj(res3)) {
8515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8516 } else {
8517 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8518 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8519 }
8520 return resultobj;
8521 fail:
8522 return NULL;
8523 }
8524
8525
8526 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8527 PyObject *resultobj = 0;
8528 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8529 double result;
8530 void *argp1 = 0 ;
8531 int res1 = 0 ;
8532 PyObject *swig_obj[1] ;
8533
8534 if (!args) SWIG_fail;
8535 swig_obj[0] = args;
8536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8537 if (!SWIG_IsOK(res1)) {
8538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8539 }
8540 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8541 {
8542 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8543 if (PyErr_Occurred()) SWIG_fail;
8544 }
8545 resultobj = SWIG_From_double(static_cast< double >(result));
8546 return resultobj;
8547 fail:
8548 return NULL;
8549 }
8550
8551
8552 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8553 PyObject *resultobj = 0;
8554 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8555 double result;
8556 void *argp1 = 0 ;
8557 int res1 = 0 ;
8558 PyObject *swig_obj[1] ;
8559
8560 if (!args) SWIG_fail;
8561 swig_obj[0] = args;
8562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8563 if (!SWIG_IsOK(res1)) {
8564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8565 }
8566 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8567 {
8568 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8569 if (PyErr_Occurred()) SWIG_fail;
8570 }
8571 resultobj = SWIG_From_double(static_cast< double >(result));
8572 return resultobj;
8573 fail:
8574 return NULL;
8575 }
8576
8577
8578 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8579 PyObject *resultobj = 0;
8580 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8581 double arg2 ;
8582 void *argp1 = 0 ;
8583 int res1 = 0 ;
8584 double val2 ;
8585 int ecode2 = 0 ;
8586 PyObject * obj0 = 0 ;
8587 PyObject * obj1 = 0 ;
8588 char * kwnames[] = {
8589 (char *) "self",(char *) "length", NULL
8590 };
8591
8592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8594 if (!SWIG_IsOK(res1)) {
8595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8596 }
8597 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8598 ecode2 = SWIG_AsVal_double(obj1, &val2);
8599 if (!SWIG_IsOK(ecode2)) {
8600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8601 }
8602 arg2 = static_cast< double >(val2);
8603 {
8604 (arg1)->SetVectorLength(arg2);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 resultobj = SWIG_Py_Void();
8608 return resultobj;
8609 fail:
8610 return NULL;
8611 }
8612
8613
8614 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8615 PyObject *resultobj = 0;
8616 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8617 double arg2 ;
8618 void *argp1 = 0 ;
8619 int res1 = 0 ;
8620 double val2 ;
8621 int ecode2 = 0 ;
8622 PyObject * obj0 = 0 ;
8623 PyObject * obj1 = 0 ;
8624 char * kwnames[] = {
8625 (char *) "self",(char *) "degrees", NULL
8626 };
8627
8628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8630 if (!SWIG_IsOK(res1)) {
8631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8632 }
8633 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8634 ecode2 = SWIG_AsVal_double(obj1, &val2);
8635 if (!SWIG_IsOK(ecode2)) {
8636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8637 }
8638 arg2 = static_cast< double >(val2);
8639 {
8640 (arg1)->SetVectorAngle(arg2);
8641 if (PyErr_Occurred()) SWIG_fail;
8642 }
8643 resultobj = SWIG_Py_Void();
8644 return resultobj;
8645 fail:
8646 return NULL;
8647 }
8648
8649
8650 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8651 PyObject *resultobj = 0;
8652 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8653 wxPoint2D *arg2 = 0 ;
8654 double result;
8655 void *argp1 = 0 ;
8656 int res1 = 0 ;
8657 wxPoint2D temp2 ;
8658 PyObject * obj0 = 0 ;
8659 PyObject * obj1 = 0 ;
8660 char * kwnames[] = {
8661 (char *) "self",(char *) "pt", NULL
8662 };
8663
8664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8666 if (!SWIG_IsOK(res1)) {
8667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8668 }
8669 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8670 {
8671 arg2 = &temp2;
8672 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8673 }
8674 {
8675 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8676 if (PyErr_Occurred()) SWIG_fail;
8677 }
8678 resultobj = SWIG_From_double(static_cast< double >(result));
8679 return resultobj;
8680 fail:
8681 return NULL;
8682 }
8683
8684
8685 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8686 PyObject *resultobj = 0;
8687 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8688 wxPoint2D *arg2 = 0 ;
8689 double result;
8690 void *argp1 = 0 ;
8691 int res1 = 0 ;
8692 wxPoint2D temp2 ;
8693 PyObject * obj0 = 0 ;
8694 PyObject * obj1 = 0 ;
8695 char * kwnames[] = {
8696 (char *) "self",(char *) "pt", NULL
8697 };
8698
8699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8701 if (!SWIG_IsOK(res1)) {
8702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8703 }
8704 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8705 {
8706 arg2 = &temp2;
8707 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8708 }
8709 {
8710 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8711 if (PyErr_Occurred()) SWIG_fail;
8712 }
8713 resultobj = SWIG_From_double(static_cast< double >(result));
8714 return resultobj;
8715 fail:
8716 return NULL;
8717 }
8718
8719
8720 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8721 PyObject *resultobj = 0;
8722 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8723 wxPoint2D *arg2 = 0 ;
8724 double result;
8725 void *argp1 = 0 ;
8726 int res1 = 0 ;
8727 wxPoint2D temp2 ;
8728 PyObject * obj0 = 0 ;
8729 PyObject * obj1 = 0 ;
8730 char * kwnames[] = {
8731 (char *) "self",(char *) "vec", NULL
8732 };
8733
8734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8736 if (!SWIG_IsOK(res1)) {
8737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8738 }
8739 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8740 {
8741 arg2 = &temp2;
8742 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8743 }
8744 {
8745 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8746 if (PyErr_Occurred()) SWIG_fail;
8747 }
8748 resultobj = SWIG_From_double(static_cast< double >(result));
8749 return resultobj;
8750 fail:
8751 return NULL;
8752 }
8753
8754
8755 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8756 PyObject *resultobj = 0;
8757 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8758 wxPoint2D *arg2 = 0 ;
8759 double result;
8760 void *argp1 = 0 ;
8761 int res1 = 0 ;
8762 wxPoint2D temp2 ;
8763 PyObject * obj0 = 0 ;
8764 PyObject * obj1 = 0 ;
8765 char * kwnames[] = {
8766 (char *) "self",(char *) "vec", NULL
8767 };
8768
8769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8771 if (!SWIG_IsOK(res1)) {
8772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8773 }
8774 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8775 {
8776 arg2 = &temp2;
8777 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8778 }
8779 {
8780 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8781 if (PyErr_Occurred()) SWIG_fail;
8782 }
8783 resultobj = SWIG_From_double(static_cast< double >(result));
8784 return resultobj;
8785 fail:
8786 return NULL;
8787 }
8788
8789
8790 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8791 PyObject *resultobj = 0;
8792 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8793 wxPoint2D result;
8794 void *argp1 = 0 ;
8795 int res1 = 0 ;
8796 PyObject *swig_obj[1] ;
8797
8798 if (!args) SWIG_fail;
8799 swig_obj[0] = args;
8800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8801 if (!SWIG_IsOK(res1)) {
8802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8803 }
8804 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8805 {
8806 result = (arg1)->operator -();
8807 if (PyErr_Occurred()) SWIG_fail;
8808 }
8809 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8810 return resultobj;
8811 fail:
8812 return NULL;
8813 }
8814
8815
8816 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8817 PyObject *resultobj = 0;
8818 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8819 wxPoint2D *arg2 = 0 ;
8820 wxPoint2D *result = 0 ;
8821 void *argp1 = 0 ;
8822 int res1 = 0 ;
8823 wxPoint2D temp2 ;
8824 PyObject * obj0 = 0 ;
8825 PyObject * obj1 = 0 ;
8826 char * kwnames[] = {
8827 (char *) "self",(char *) "pt", NULL
8828 };
8829
8830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8832 if (!SWIG_IsOK(res1)) {
8833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8834 }
8835 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8836 {
8837 arg2 = &temp2;
8838 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8839 }
8840 {
8841 {
8842 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8843 result = (wxPoint2D *) &_result_ref;
8844 }
8845 if (PyErr_Occurred()) SWIG_fail;
8846 }
8847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8848 return resultobj;
8849 fail:
8850 return NULL;
8851 }
8852
8853
8854 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8855 PyObject *resultobj = 0;
8856 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8857 wxPoint2D *arg2 = 0 ;
8858 wxPoint2D *result = 0 ;
8859 void *argp1 = 0 ;
8860 int res1 = 0 ;
8861 wxPoint2D temp2 ;
8862 PyObject * obj0 = 0 ;
8863 PyObject * obj1 = 0 ;
8864 char * kwnames[] = {
8865 (char *) "self",(char *) "pt", NULL
8866 };
8867
8868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8870 if (!SWIG_IsOK(res1)) {
8871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8872 }
8873 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8874 {
8875 arg2 = &temp2;
8876 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8877 }
8878 {
8879 {
8880 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8881 result = (wxPoint2D *) &_result_ref;
8882 }
8883 if (PyErr_Occurred()) SWIG_fail;
8884 }
8885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8886 return resultobj;
8887 fail:
8888 return NULL;
8889 }
8890
8891
8892 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8893 PyObject *resultobj = 0;
8894 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8895 wxPoint2D *arg2 = 0 ;
8896 wxPoint2D *result = 0 ;
8897 void *argp1 = 0 ;
8898 int res1 = 0 ;
8899 wxPoint2D temp2 ;
8900 PyObject * obj0 = 0 ;
8901 PyObject * obj1 = 0 ;
8902 char * kwnames[] = {
8903 (char *) "self",(char *) "pt", NULL
8904 };
8905
8906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8908 if (!SWIG_IsOK(res1)) {
8909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8910 }
8911 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8912 {
8913 arg2 = &temp2;
8914 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8915 }
8916 {
8917 {
8918 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8919 result = (wxPoint2D *) &_result_ref;
8920 }
8921 if (PyErr_Occurred()) SWIG_fail;
8922 }
8923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8924 return resultobj;
8925 fail:
8926 return NULL;
8927 }
8928
8929
8930 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8931 PyObject *resultobj = 0;
8932 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8933 wxPoint2D *arg2 = 0 ;
8934 wxPoint2D *result = 0 ;
8935 void *argp1 = 0 ;
8936 int res1 = 0 ;
8937 wxPoint2D temp2 ;
8938 PyObject * obj0 = 0 ;
8939 PyObject * obj1 = 0 ;
8940 char * kwnames[] = {
8941 (char *) "self",(char *) "pt", NULL
8942 };
8943
8944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8946 if (!SWIG_IsOK(res1)) {
8947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8948 }
8949 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8950 {
8951 arg2 = &temp2;
8952 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8953 }
8954 {
8955 {
8956 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8957 result = (wxPoint2D *) &_result_ref;
8958 }
8959 if (PyErr_Occurred()) SWIG_fail;
8960 }
8961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8962 return resultobj;
8963 fail:
8964 return NULL;
8965 }
8966
8967
8968 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8969 PyObject *resultobj = 0;
8970 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8971 PyObject *arg2 = (PyObject *) 0 ;
8972 bool result;
8973 void *argp1 = 0 ;
8974 int res1 = 0 ;
8975 PyObject * obj0 = 0 ;
8976 PyObject * obj1 = 0 ;
8977 char * kwnames[] = {
8978 (char *) "self",(char *) "other", NULL
8979 };
8980
8981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8983 if (!SWIG_IsOK(res1)) {
8984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8985 }
8986 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8987 arg2 = obj1;
8988 {
8989 result = (bool)wxPoint2D___eq__(arg1,arg2);
8990 if (PyErr_Occurred()) SWIG_fail;
8991 }
8992 {
8993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8994 }
8995 return resultobj;
8996 fail:
8997 return NULL;
8998 }
8999
9000
9001 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9002 PyObject *resultobj = 0;
9003 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9004 PyObject *arg2 = (PyObject *) 0 ;
9005 bool result;
9006 void *argp1 = 0 ;
9007 int res1 = 0 ;
9008 PyObject * obj0 = 0 ;
9009 PyObject * obj1 = 0 ;
9010 char * kwnames[] = {
9011 (char *) "self",(char *) "other", NULL
9012 };
9013
9014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
9015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9016 if (!SWIG_IsOK(res1)) {
9017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9018 }
9019 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9020 arg2 = obj1;
9021 {
9022 result = (bool)wxPoint2D___ne__(arg1,arg2);
9023 if (PyErr_Occurred()) SWIG_fail;
9024 }
9025 {
9026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9027 }
9028 return resultobj;
9029 fail:
9030 return NULL;
9031 }
9032
9033
9034 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9035 PyObject *resultobj = 0;
9036 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9037 double arg2 ;
9038 void *argp1 = 0 ;
9039 int res1 = 0 ;
9040 double val2 ;
9041 int ecode2 = 0 ;
9042 PyObject *swig_obj[2] ;
9043
9044 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9046 if (!SWIG_IsOK(res1)) {
9047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9048 }
9049 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9050 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9051 if (!SWIG_IsOK(ecode2)) {
9052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9053 }
9054 arg2 = static_cast< double >(val2);
9055 if (arg1) (arg1)->m_x = arg2;
9056
9057 resultobj = SWIG_Py_Void();
9058 return resultobj;
9059 fail:
9060 return NULL;
9061 }
9062
9063
9064 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9065 PyObject *resultobj = 0;
9066 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9067 double result;
9068 void *argp1 = 0 ;
9069 int res1 = 0 ;
9070 PyObject *swig_obj[1] ;
9071
9072 if (!args) SWIG_fail;
9073 swig_obj[0] = args;
9074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9075 if (!SWIG_IsOK(res1)) {
9076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9077 }
9078 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9079 result = (double) ((arg1)->m_x);
9080 resultobj = SWIG_From_double(static_cast< double >(result));
9081 return resultobj;
9082 fail:
9083 return NULL;
9084 }
9085
9086
9087 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9088 PyObject *resultobj = 0;
9089 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9090 double arg2 ;
9091 void *argp1 = 0 ;
9092 int res1 = 0 ;
9093 double val2 ;
9094 int ecode2 = 0 ;
9095 PyObject *swig_obj[2] ;
9096
9097 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9099 if (!SWIG_IsOK(res1)) {
9100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9101 }
9102 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9103 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9104 if (!SWIG_IsOK(ecode2)) {
9105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9106 }
9107 arg2 = static_cast< double >(val2);
9108 if (arg1) (arg1)->m_y = arg2;
9109
9110 resultobj = SWIG_Py_Void();
9111 return resultobj;
9112 fail:
9113 return NULL;
9114 }
9115
9116
9117 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9118 PyObject *resultobj = 0;
9119 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9120 double result;
9121 void *argp1 = 0 ;
9122 int res1 = 0 ;
9123 PyObject *swig_obj[1] ;
9124
9125 if (!args) SWIG_fail;
9126 swig_obj[0] = args;
9127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9128 if (!SWIG_IsOK(res1)) {
9129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9130 }
9131 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9132 result = (double) ((arg1)->m_y);
9133 resultobj = SWIG_From_double(static_cast< double >(result));
9134 return resultobj;
9135 fail:
9136 return NULL;
9137 }
9138
9139
9140 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9141 PyObject *resultobj = 0;
9142 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9143 double arg2 = (double) 0 ;
9144 double arg3 = (double) 0 ;
9145 void *argp1 = 0 ;
9146 int res1 = 0 ;
9147 double val2 ;
9148 int ecode2 = 0 ;
9149 double val3 ;
9150 int ecode3 = 0 ;
9151 PyObject * obj0 = 0 ;
9152 PyObject * obj1 = 0 ;
9153 PyObject * obj2 = 0 ;
9154 char * kwnames[] = {
9155 (char *) "self",(char *) "x",(char *) "y", NULL
9156 };
9157
9158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9160 if (!SWIG_IsOK(res1)) {
9161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9162 }
9163 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9164 if (obj1) {
9165 ecode2 = SWIG_AsVal_double(obj1, &val2);
9166 if (!SWIG_IsOK(ecode2)) {
9167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9168 }
9169 arg2 = static_cast< double >(val2);
9170 }
9171 if (obj2) {
9172 ecode3 = SWIG_AsVal_double(obj2, &val3);
9173 if (!SWIG_IsOK(ecode3)) {
9174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9175 }
9176 arg3 = static_cast< double >(val3);
9177 }
9178 {
9179 wxPoint2D_Set(arg1,arg2,arg3);
9180 if (PyErr_Occurred()) SWIG_fail;
9181 }
9182 resultobj = SWIG_Py_Void();
9183 return resultobj;
9184 fail:
9185 return NULL;
9186 }
9187
9188
9189 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9190 PyObject *resultobj = 0;
9191 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9192 PyObject *result = 0 ;
9193 void *argp1 = 0 ;
9194 int res1 = 0 ;
9195 PyObject *swig_obj[1] ;
9196
9197 if (!args) SWIG_fail;
9198 swig_obj[0] = args;
9199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9200 if (!SWIG_IsOK(res1)) {
9201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9202 }
9203 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9204 {
9205 result = (PyObject *)wxPoint2D_Get(arg1);
9206 if (PyErr_Occurred()) SWIG_fail;
9207 }
9208 resultobj = result;
9209 return resultobj;
9210 fail:
9211 return NULL;
9212 }
9213
9214
9215 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9216 PyObject *obj;
9217 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9218 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9219 return SWIG_Py_Void();
9220 }
9221
9222 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9223 return SWIG_Python_InitShadowInstance(args);
9224 }
9225
9226 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9227 PyObject *resultobj = 0;
9228 wxDouble arg1 = (wxDouble) 0.0 ;
9229 wxDouble arg2 = (wxDouble) 0.0 ;
9230 wxDouble arg3 = (wxDouble) 0.0 ;
9231 wxDouble arg4 = (wxDouble) 0.0 ;
9232 wxRect2D *result = 0 ;
9233 void *argp1 ;
9234 int res1 = 0 ;
9235 void *argp2 ;
9236 int res2 = 0 ;
9237 void *argp3 ;
9238 int res3 = 0 ;
9239 void *argp4 ;
9240 int res4 = 0 ;
9241 PyObject * obj0 = 0 ;
9242 PyObject * obj1 = 0 ;
9243 PyObject * obj2 = 0 ;
9244 PyObject * obj3 = 0 ;
9245 char * kwnames[] = {
9246 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9247 };
9248
9249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9250 if (obj0) {
9251 {
9252 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9253 if (!SWIG_IsOK(res1)) {
9254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9255 }
9256 if (!argp1) {
9257 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9258 } else {
9259 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9260 arg1 = *temp;
9261 if (SWIG_IsNewObj(res1)) delete temp;
9262 }
9263 }
9264 }
9265 if (obj1) {
9266 {
9267 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9268 if (!SWIG_IsOK(res2)) {
9269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9270 }
9271 if (!argp2) {
9272 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9273 } else {
9274 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9275 arg2 = *temp;
9276 if (SWIG_IsNewObj(res2)) delete temp;
9277 }
9278 }
9279 }
9280 if (obj2) {
9281 {
9282 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9283 if (!SWIG_IsOK(res3)) {
9284 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9285 }
9286 if (!argp3) {
9287 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9288 } else {
9289 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9290 arg3 = *temp;
9291 if (SWIG_IsNewObj(res3)) delete temp;
9292 }
9293 }
9294 }
9295 if (obj3) {
9296 {
9297 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9298 if (!SWIG_IsOK(res4)) {
9299 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9300 }
9301 if (!argp4) {
9302 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9303 } else {
9304 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9305 arg4 = *temp;
9306 if (SWIG_IsNewObj(res4)) delete temp;
9307 }
9308 }
9309 }
9310 {
9311 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9312 if (PyErr_Occurred()) SWIG_fail;
9313 }
9314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9315 return resultobj;
9316 fail:
9317 return NULL;
9318 }
9319
9320
9321 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9322 PyObject *resultobj = 0;
9323 wxRect2D *arg1 = (wxRect2D *) 0 ;
9324 void *argp1 = 0 ;
9325 int res1 = 0 ;
9326 PyObject *swig_obj[1] ;
9327
9328 if (!args) SWIG_fail;
9329 swig_obj[0] = args;
9330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9331 if (!SWIG_IsOK(res1)) {
9332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9333 }
9334 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9335 {
9336 delete arg1;
9337
9338 if (PyErr_Occurred()) SWIG_fail;
9339 }
9340 resultobj = SWIG_Py_Void();
9341 return resultobj;
9342 fail:
9343 return NULL;
9344 }
9345
9346
9347 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9348 PyObject *resultobj = 0;
9349 wxRect2D *arg1 = (wxRect2D *) 0 ;
9350 wxPoint2D result;
9351 void *argp1 = 0 ;
9352 int res1 = 0 ;
9353 PyObject *swig_obj[1] ;
9354
9355 if (!args) SWIG_fail;
9356 swig_obj[0] = args;
9357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9358 if (!SWIG_IsOK(res1)) {
9359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9360 }
9361 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9362 {
9363 result = (arg1)->GetPosition();
9364 if (PyErr_Occurred()) SWIG_fail;
9365 }
9366 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9367 return resultobj;
9368 fail:
9369 return NULL;
9370 }
9371
9372
9373 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9374 PyObject *resultobj = 0;
9375 wxRect2D *arg1 = (wxRect2D *) 0 ;
9376 wxSize result;
9377 void *argp1 = 0 ;
9378 int res1 = 0 ;
9379 PyObject *swig_obj[1] ;
9380
9381 if (!args) SWIG_fail;
9382 swig_obj[0] = args;
9383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9384 if (!SWIG_IsOK(res1)) {
9385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9386 }
9387 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9388 {
9389 result = (arg1)->GetSize();
9390 if (PyErr_Occurred()) SWIG_fail;
9391 }
9392 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9393 return resultobj;
9394 fail:
9395 return NULL;
9396 }
9397
9398
9399 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9400 PyObject *resultobj = 0;
9401 wxRect2D *arg1 = (wxRect2D *) 0 ;
9402 wxDouble result;
9403 void *argp1 = 0 ;
9404 int res1 = 0 ;
9405 PyObject *swig_obj[1] ;
9406
9407 if (!args) SWIG_fail;
9408 swig_obj[0] = args;
9409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9410 if (!SWIG_IsOK(res1)) {
9411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9412 }
9413 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9414 {
9415 result = ((wxRect2D const *)arg1)->GetLeft();
9416 if (PyErr_Occurred()) SWIG_fail;
9417 }
9418 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9419 return resultobj;
9420 fail:
9421 return NULL;
9422 }
9423
9424
9425 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9426 PyObject *resultobj = 0;
9427 wxRect2D *arg1 = (wxRect2D *) 0 ;
9428 wxDouble arg2 ;
9429 void *argp1 = 0 ;
9430 int res1 = 0 ;
9431 void *argp2 ;
9432 int res2 = 0 ;
9433 PyObject * obj0 = 0 ;
9434 PyObject * obj1 = 0 ;
9435 char * kwnames[] = {
9436 (char *) "self",(char *) "n", NULL
9437 };
9438
9439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9441 if (!SWIG_IsOK(res1)) {
9442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9443 }
9444 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9445 {
9446 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9447 if (!SWIG_IsOK(res2)) {
9448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9449 }
9450 if (!argp2) {
9451 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9452 } else {
9453 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9454 arg2 = *temp;
9455 if (SWIG_IsNewObj(res2)) delete temp;
9456 }
9457 }
9458 {
9459 (arg1)->SetLeft(arg2);
9460 if (PyErr_Occurred()) SWIG_fail;
9461 }
9462 resultobj = SWIG_Py_Void();
9463 return resultobj;
9464 fail:
9465 return NULL;
9466 }
9467
9468
9469 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9470 PyObject *resultobj = 0;
9471 wxRect2D *arg1 = (wxRect2D *) 0 ;
9472 wxDouble arg2 ;
9473 void *argp1 = 0 ;
9474 int res1 = 0 ;
9475 void *argp2 ;
9476 int res2 = 0 ;
9477 PyObject * obj0 = 0 ;
9478 PyObject * obj1 = 0 ;
9479 char * kwnames[] = {
9480 (char *) "self",(char *) "n", NULL
9481 };
9482
9483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9485 if (!SWIG_IsOK(res1)) {
9486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9487 }
9488 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9489 {
9490 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9491 if (!SWIG_IsOK(res2)) {
9492 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9493 }
9494 if (!argp2) {
9495 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9496 } else {
9497 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9498 arg2 = *temp;
9499 if (SWIG_IsNewObj(res2)) delete temp;
9500 }
9501 }
9502 {
9503 (arg1)->MoveLeftTo(arg2);
9504 if (PyErr_Occurred()) SWIG_fail;
9505 }
9506 resultobj = SWIG_Py_Void();
9507 return resultobj;
9508 fail:
9509 return NULL;
9510 }
9511
9512
9513 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9514 PyObject *resultobj = 0;
9515 wxRect2D *arg1 = (wxRect2D *) 0 ;
9516 wxDouble result;
9517 void *argp1 = 0 ;
9518 int res1 = 0 ;
9519 PyObject *swig_obj[1] ;
9520
9521 if (!args) SWIG_fail;
9522 swig_obj[0] = args;
9523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9524 if (!SWIG_IsOK(res1)) {
9525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9526 }
9527 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9528 {
9529 result = ((wxRect2D const *)arg1)->GetTop();
9530 if (PyErr_Occurred()) SWIG_fail;
9531 }
9532 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9533 return resultobj;
9534 fail:
9535 return NULL;
9536 }
9537
9538
9539 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9540 PyObject *resultobj = 0;
9541 wxRect2D *arg1 = (wxRect2D *) 0 ;
9542 wxDouble arg2 ;
9543 void *argp1 = 0 ;
9544 int res1 = 0 ;
9545 void *argp2 ;
9546 int res2 = 0 ;
9547 PyObject * obj0 = 0 ;
9548 PyObject * obj1 = 0 ;
9549 char * kwnames[] = {
9550 (char *) "self",(char *) "n", NULL
9551 };
9552
9553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9555 if (!SWIG_IsOK(res1)) {
9556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9557 }
9558 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9559 {
9560 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9561 if (!SWIG_IsOK(res2)) {
9562 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9563 }
9564 if (!argp2) {
9565 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9566 } else {
9567 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9568 arg2 = *temp;
9569 if (SWIG_IsNewObj(res2)) delete temp;
9570 }
9571 }
9572 {
9573 (arg1)->SetTop(arg2);
9574 if (PyErr_Occurred()) SWIG_fail;
9575 }
9576 resultobj = SWIG_Py_Void();
9577 return resultobj;
9578 fail:
9579 return NULL;
9580 }
9581
9582
9583 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9584 PyObject *resultobj = 0;
9585 wxRect2D *arg1 = (wxRect2D *) 0 ;
9586 wxDouble arg2 ;
9587 void *argp1 = 0 ;
9588 int res1 = 0 ;
9589 void *argp2 ;
9590 int res2 = 0 ;
9591 PyObject * obj0 = 0 ;
9592 PyObject * obj1 = 0 ;
9593 char * kwnames[] = {
9594 (char *) "self",(char *) "n", NULL
9595 };
9596
9597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9599 if (!SWIG_IsOK(res1)) {
9600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9601 }
9602 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9603 {
9604 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9605 if (!SWIG_IsOK(res2)) {
9606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9607 }
9608 if (!argp2) {
9609 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9610 } else {
9611 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9612 arg2 = *temp;
9613 if (SWIG_IsNewObj(res2)) delete temp;
9614 }
9615 }
9616 {
9617 (arg1)->MoveTopTo(arg2);
9618 if (PyErr_Occurred()) SWIG_fail;
9619 }
9620 resultobj = SWIG_Py_Void();
9621 return resultobj;
9622 fail:
9623 return NULL;
9624 }
9625
9626
9627 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9628 PyObject *resultobj = 0;
9629 wxRect2D *arg1 = (wxRect2D *) 0 ;
9630 wxDouble result;
9631 void *argp1 = 0 ;
9632 int res1 = 0 ;
9633 PyObject *swig_obj[1] ;
9634
9635 if (!args) SWIG_fail;
9636 swig_obj[0] = args;
9637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9638 if (!SWIG_IsOK(res1)) {
9639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9640 }
9641 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9642 {
9643 result = ((wxRect2D const *)arg1)->GetBottom();
9644 if (PyErr_Occurred()) SWIG_fail;
9645 }
9646 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9647 return resultobj;
9648 fail:
9649 return NULL;
9650 }
9651
9652
9653 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9654 PyObject *resultobj = 0;
9655 wxRect2D *arg1 = (wxRect2D *) 0 ;
9656 wxDouble arg2 ;
9657 void *argp1 = 0 ;
9658 int res1 = 0 ;
9659 void *argp2 ;
9660 int res2 = 0 ;
9661 PyObject * obj0 = 0 ;
9662 PyObject * obj1 = 0 ;
9663 char * kwnames[] = {
9664 (char *) "self",(char *) "n", NULL
9665 };
9666
9667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9669 if (!SWIG_IsOK(res1)) {
9670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9671 }
9672 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9673 {
9674 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9675 if (!SWIG_IsOK(res2)) {
9676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9677 }
9678 if (!argp2) {
9679 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9680 } else {
9681 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9682 arg2 = *temp;
9683 if (SWIG_IsNewObj(res2)) delete temp;
9684 }
9685 }
9686 {
9687 (arg1)->SetBottom(arg2);
9688 if (PyErr_Occurred()) SWIG_fail;
9689 }
9690 resultobj = SWIG_Py_Void();
9691 return resultobj;
9692 fail:
9693 return NULL;
9694 }
9695
9696
9697 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9698 PyObject *resultobj = 0;
9699 wxRect2D *arg1 = (wxRect2D *) 0 ;
9700 wxDouble arg2 ;
9701 void *argp1 = 0 ;
9702 int res1 = 0 ;
9703 void *argp2 ;
9704 int res2 = 0 ;
9705 PyObject * obj0 = 0 ;
9706 PyObject * obj1 = 0 ;
9707 char * kwnames[] = {
9708 (char *) "self",(char *) "n", NULL
9709 };
9710
9711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9713 if (!SWIG_IsOK(res1)) {
9714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9715 }
9716 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9717 {
9718 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9719 if (!SWIG_IsOK(res2)) {
9720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9721 }
9722 if (!argp2) {
9723 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9724 } else {
9725 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9726 arg2 = *temp;
9727 if (SWIG_IsNewObj(res2)) delete temp;
9728 }
9729 }
9730 {
9731 (arg1)->MoveBottomTo(arg2);
9732 if (PyErr_Occurred()) SWIG_fail;
9733 }
9734 resultobj = SWIG_Py_Void();
9735 return resultobj;
9736 fail:
9737 return NULL;
9738 }
9739
9740
9741 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9742 PyObject *resultobj = 0;
9743 wxRect2D *arg1 = (wxRect2D *) 0 ;
9744 wxDouble result;
9745 void *argp1 = 0 ;
9746 int res1 = 0 ;
9747 PyObject *swig_obj[1] ;
9748
9749 if (!args) SWIG_fail;
9750 swig_obj[0] = args;
9751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9752 if (!SWIG_IsOK(res1)) {
9753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9754 }
9755 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9756 {
9757 result = ((wxRect2D const *)arg1)->GetRight();
9758 if (PyErr_Occurred()) SWIG_fail;
9759 }
9760 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9761 return resultobj;
9762 fail:
9763 return NULL;
9764 }
9765
9766
9767 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9768 PyObject *resultobj = 0;
9769 wxRect2D *arg1 = (wxRect2D *) 0 ;
9770 wxDouble arg2 ;
9771 void *argp1 = 0 ;
9772 int res1 = 0 ;
9773 void *argp2 ;
9774 int res2 = 0 ;
9775 PyObject * obj0 = 0 ;
9776 PyObject * obj1 = 0 ;
9777 char * kwnames[] = {
9778 (char *) "self",(char *) "n", NULL
9779 };
9780
9781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9783 if (!SWIG_IsOK(res1)) {
9784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9785 }
9786 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9787 {
9788 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9789 if (!SWIG_IsOK(res2)) {
9790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9791 }
9792 if (!argp2) {
9793 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9794 } else {
9795 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9796 arg2 = *temp;
9797 if (SWIG_IsNewObj(res2)) delete temp;
9798 }
9799 }
9800 {
9801 (arg1)->SetRight(arg2);
9802 if (PyErr_Occurred()) SWIG_fail;
9803 }
9804 resultobj = SWIG_Py_Void();
9805 return resultobj;
9806 fail:
9807 return NULL;
9808 }
9809
9810
9811 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9812 PyObject *resultobj = 0;
9813 wxRect2D *arg1 = (wxRect2D *) 0 ;
9814 wxDouble arg2 ;
9815 void *argp1 = 0 ;
9816 int res1 = 0 ;
9817 void *argp2 ;
9818 int res2 = 0 ;
9819 PyObject * obj0 = 0 ;
9820 PyObject * obj1 = 0 ;
9821 char * kwnames[] = {
9822 (char *) "self",(char *) "n", NULL
9823 };
9824
9825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9827 if (!SWIG_IsOK(res1)) {
9828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9829 }
9830 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9831 {
9832 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9833 if (!SWIG_IsOK(res2)) {
9834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9835 }
9836 if (!argp2) {
9837 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9838 } else {
9839 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9840 arg2 = *temp;
9841 if (SWIG_IsNewObj(res2)) delete temp;
9842 }
9843 }
9844 {
9845 (arg1)->MoveRightTo(arg2);
9846 if (PyErr_Occurred()) SWIG_fail;
9847 }
9848 resultobj = SWIG_Py_Void();
9849 return resultobj;
9850 fail:
9851 return NULL;
9852 }
9853
9854
9855 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9856 PyObject *resultobj = 0;
9857 wxRect2D *arg1 = (wxRect2D *) 0 ;
9858 wxPoint2D result;
9859 void *argp1 = 0 ;
9860 int res1 = 0 ;
9861 PyObject *swig_obj[1] ;
9862
9863 if (!args) SWIG_fail;
9864 swig_obj[0] = args;
9865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9866 if (!SWIG_IsOK(res1)) {
9867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9868 }
9869 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9870 {
9871 result = ((wxRect2D const *)arg1)->GetLeftTop();
9872 if (PyErr_Occurred()) SWIG_fail;
9873 }
9874 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9875 return resultobj;
9876 fail:
9877 return NULL;
9878 }
9879
9880
9881 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9882 PyObject *resultobj = 0;
9883 wxRect2D *arg1 = (wxRect2D *) 0 ;
9884 wxPoint2D *arg2 = 0 ;
9885 void *argp1 = 0 ;
9886 int res1 = 0 ;
9887 wxPoint2D temp2 ;
9888 PyObject * obj0 = 0 ;
9889 PyObject * obj1 = 0 ;
9890 char * kwnames[] = {
9891 (char *) "self",(char *) "pt", NULL
9892 };
9893
9894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9896 if (!SWIG_IsOK(res1)) {
9897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9898 }
9899 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9900 {
9901 arg2 = &temp2;
9902 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9903 }
9904 {
9905 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9906 if (PyErr_Occurred()) SWIG_fail;
9907 }
9908 resultobj = SWIG_Py_Void();
9909 return resultobj;
9910 fail:
9911 return NULL;
9912 }
9913
9914
9915 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9916 PyObject *resultobj = 0;
9917 wxRect2D *arg1 = (wxRect2D *) 0 ;
9918 wxPoint2D *arg2 = 0 ;
9919 void *argp1 = 0 ;
9920 int res1 = 0 ;
9921 wxPoint2D temp2 ;
9922 PyObject * obj0 = 0 ;
9923 PyObject * obj1 = 0 ;
9924 char * kwnames[] = {
9925 (char *) "self",(char *) "pt", NULL
9926 };
9927
9928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9930 if (!SWIG_IsOK(res1)) {
9931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9932 }
9933 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9934 {
9935 arg2 = &temp2;
9936 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9937 }
9938 {
9939 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9940 if (PyErr_Occurred()) SWIG_fail;
9941 }
9942 resultobj = SWIG_Py_Void();
9943 return resultobj;
9944 fail:
9945 return NULL;
9946 }
9947
9948
9949 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9950 PyObject *resultobj = 0;
9951 wxRect2D *arg1 = (wxRect2D *) 0 ;
9952 wxPoint2D result;
9953 void *argp1 = 0 ;
9954 int res1 = 0 ;
9955 PyObject *swig_obj[1] ;
9956
9957 if (!args) SWIG_fail;
9958 swig_obj[0] = args;
9959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9960 if (!SWIG_IsOK(res1)) {
9961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9962 }
9963 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9964 {
9965 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9966 if (PyErr_Occurred()) SWIG_fail;
9967 }
9968 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9969 return resultobj;
9970 fail:
9971 return NULL;
9972 }
9973
9974
9975 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9976 PyObject *resultobj = 0;
9977 wxRect2D *arg1 = (wxRect2D *) 0 ;
9978 wxPoint2D *arg2 = 0 ;
9979 void *argp1 = 0 ;
9980 int res1 = 0 ;
9981 wxPoint2D temp2 ;
9982 PyObject * obj0 = 0 ;
9983 PyObject * obj1 = 0 ;
9984 char * kwnames[] = {
9985 (char *) "self",(char *) "pt", NULL
9986 };
9987
9988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9990 if (!SWIG_IsOK(res1)) {
9991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9992 }
9993 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9994 {
9995 arg2 = &temp2;
9996 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9997 }
9998 {
9999 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
10000 if (PyErr_Occurred()) SWIG_fail;
10001 }
10002 resultobj = SWIG_Py_Void();
10003 return resultobj;
10004 fail:
10005 return NULL;
10006 }
10007
10008
10009 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10010 PyObject *resultobj = 0;
10011 wxRect2D *arg1 = (wxRect2D *) 0 ;
10012 wxPoint2D *arg2 = 0 ;
10013 void *argp1 = 0 ;
10014 int res1 = 0 ;
10015 wxPoint2D temp2 ;
10016 PyObject * obj0 = 0 ;
10017 PyObject * obj1 = 0 ;
10018 char * kwnames[] = {
10019 (char *) "self",(char *) "pt", NULL
10020 };
10021
10022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10024 if (!SWIG_IsOK(res1)) {
10025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10026 }
10027 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10028 {
10029 arg2 = &temp2;
10030 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10031 }
10032 {
10033 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
10034 if (PyErr_Occurred()) SWIG_fail;
10035 }
10036 resultobj = SWIG_Py_Void();
10037 return resultobj;
10038 fail:
10039 return NULL;
10040 }
10041
10042
10043 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10044 PyObject *resultobj = 0;
10045 wxRect2D *arg1 = (wxRect2D *) 0 ;
10046 wxPoint2D result;
10047 void *argp1 = 0 ;
10048 int res1 = 0 ;
10049 PyObject *swig_obj[1] ;
10050
10051 if (!args) SWIG_fail;
10052 swig_obj[0] = args;
10053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10054 if (!SWIG_IsOK(res1)) {
10055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10056 }
10057 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10058 {
10059 result = ((wxRect2D const *)arg1)->GetRightTop();
10060 if (PyErr_Occurred()) SWIG_fail;
10061 }
10062 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10063 return resultobj;
10064 fail:
10065 return NULL;
10066 }
10067
10068
10069 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10070 PyObject *resultobj = 0;
10071 wxRect2D *arg1 = (wxRect2D *) 0 ;
10072 wxPoint2D *arg2 = 0 ;
10073 void *argp1 = 0 ;
10074 int res1 = 0 ;
10075 wxPoint2D temp2 ;
10076 PyObject * obj0 = 0 ;
10077 PyObject * obj1 = 0 ;
10078 char * kwnames[] = {
10079 (char *) "self",(char *) "pt", NULL
10080 };
10081
10082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
10083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10084 if (!SWIG_IsOK(res1)) {
10085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
10086 }
10087 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10088 {
10089 arg2 = &temp2;
10090 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10091 }
10092 {
10093 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
10094 if (PyErr_Occurred()) SWIG_fail;
10095 }
10096 resultobj = SWIG_Py_Void();
10097 return resultobj;
10098 fail:
10099 return NULL;
10100 }
10101
10102
10103 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10104 PyObject *resultobj = 0;
10105 wxRect2D *arg1 = (wxRect2D *) 0 ;
10106 wxPoint2D *arg2 = 0 ;
10107 void *argp1 = 0 ;
10108 int res1 = 0 ;
10109 wxPoint2D temp2 ;
10110 PyObject * obj0 = 0 ;
10111 PyObject * obj1 = 0 ;
10112 char * kwnames[] = {
10113 (char *) "self",(char *) "pt", NULL
10114 };
10115
10116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10118 if (!SWIG_IsOK(res1)) {
10119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10120 }
10121 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10122 {
10123 arg2 = &temp2;
10124 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10125 }
10126 {
10127 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10128 if (PyErr_Occurred()) SWIG_fail;
10129 }
10130 resultobj = SWIG_Py_Void();
10131 return resultobj;
10132 fail:
10133 return NULL;
10134 }
10135
10136
10137 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10138 PyObject *resultobj = 0;
10139 wxRect2D *arg1 = (wxRect2D *) 0 ;
10140 wxPoint2D result;
10141 void *argp1 = 0 ;
10142 int res1 = 0 ;
10143 PyObject *swig_obj[1] ;
10144
10145 if (!args) SWIG_fail;
10146 swig_obj[0] = args;
10147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10148 if (!SWIG_IsOK(res1)) {
10149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10150 }
10151 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10152 {
10153 result = ((wxRect2D const *)arg1)->GetRightBottom();
10154 if (PyErr_Occurred()) SWIG_fail;
10155 }
10156 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10157 return resultobj;
10158 fail:
10159 return NULL;
10160 }
10161
10162
10163 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10164 PyObject *resultobj = 0;
10165 wxRect2D *arg1 = (wxRect2D *) 0 ;
10166 wxPoint2D *arg2 = 0 ;
10167 void *argp1 = 0 ;
10168 int res1 = 0 ;
10169 wxPoint2D temp2 ;
10170 PyObject * obj0 = 0 ;
10171 PyObject * obj1 = 0 ;
10172 char * kwnames[] = {
10173 (char *) "self",(char *) "pt", NULL
10174 };
10175
10176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10178 if (!SWIG_IsOK(res1)) {
10179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10180 }
10181 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10182 {
10183 arg2 = &temp2;
10184 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10185 }
10186 {
10187 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10188 if (PyErr_Occurred()) SWIG_fail;
10189 }
10190 resultobj = SWIG_Py_Void();
10191 return resultobj;
10192 fail:
10193 return NULL;
10194 }
10195
10196
10197 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10198 PyObject *resultobj = 0;
10199 wxRect2D *arg1 = (wxRect2D *) 0 ;
10200 wxPoint2D *arg2 = 0 ;
10201 void *argp1 = 0 ;
10202 int res1 = 0 ;
10203 wxPoint2D temp2 ;
10204 PyObject * obj0 = 0 ;
10205 PyObject * obj1 = 0 ;
10206 char * kwnames[] = {
10207 (char *) "self",(char *) "pt", NULL
10208 };
10209
10210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10212 if (!SWIG_IsOK(res1)) {
10213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10214 }
10215 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10216 {
10217 arg2 = &temp2;
10218 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10219 }
10220 {
10221 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10222 if (PyErr_Occurred()) SWIG_fail;
10223 }
10224 resultobj = SWIG_Py_Void();
10225 return resultobj;
10226 fail:
10227 return NULL;
10228 }
10229
10230
10231 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10232 PyObject *resultobj = 0;
10233 wxRect2D *arg1 = (wxRect2D *) 0 ;
10234 wxPoint2D result;
10235 void *argp1 = 0 ;
10236 int res1 = 0 ;
10237 PyObject *swig_obj[1] ;
10238
10239 if (!args) SWIG_fail;
10240 swig_obj[0] = args;
10241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10242 if (!SWIG_IsOK(res1)) {
10243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10244 }
10245 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10246 {
10247 result = ((wxRect2D const *)arg1)->GetCentre();
10248 if (PyErr_Occurred()) SWIG_fail;
10249 }
10250 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10251 return resultobj;
10252 fail:
10253 return NULL;
10254 }
10255
10256
10257 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10258 PyObject *resultobj = 0;
10259 wxRect2D *arg1 = (wxRect2D *) 0 ;
10260 wxPoint2D *arg2 = 0 ;
10261 void *argp1 = 0 ;
10262 int res1 = 0 ;
10263 wxPoint2D temp2 ;
10264 PyObject * obj0 = 0 ;
10265 PyObject * obj1 = 0 ;
10266 char * kwnames[] = {
10267 (char *) "self",(char *) "pt", NULL
10268 };
10269
10270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10272 if (!SWIG_IsOK(res1)) {
10273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10274 }
10275 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10276 {
10277 arg2 = &temp2;
10278 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10279 }
10280 {
10281 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10282 if (PyErr_Occurred()) SWIG_fail;
10283 }
10284 resultobj = SWIG_Py_Void();
10285 return resultobj;
10286 fail:
10287 return NULL;
10288 }
10289
10290
10291 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10292 PyObject *resultobj = 0;
10293 wxRect2D *arg1 = (wxRect2D *) 0 ;
10294 wxPoint2D *arg2 = 0 ;
10295 void *argp1 = 0 ;
10296 int res1 = 0 ;
10297 wxPoint2D temp2 ;
10298 PyObject * obj0 = 0 ;
10299 PyObject * obj1 = 0 ;
10300 char * kwnames[] = {
10301 (char *) "self",(char *) "pt", NULL
10302 };
10303
10304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10306 if (!SWIG_IsOK(res1)) {
10307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10308 }
10309 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10310 {
10311 arg2 = &temp2;
10312 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10313 }
10314 {
10315 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10316 if (PyErr_Occurred()) SWIG_fail;
10317 }
10318 resultobj = SWIG_Py_Void();
10319 return resultobj;
10320 fail:
10321 return NULL;
10322 }
10323
10324
10325 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10326 PyObject *resultobj = 0;
10327 wxRect2D *arg1 = (wxRect2D *) 0 ;
10328 wxPoint2D *arg2 = 0 ;
10329 wxOutCode result;
10330 void *argp1 = 0 ;
10331 int res1 = 0 ;
10332 wxPoint2D temp2 ;
10333 PyObject * obj0 = 0 ;
10334 PyObject * obj1 = 0 ;
10335 char * kwnames[] = {
10336 (char *) "self",(char *) "pt", NULL
10337 };
10338
10339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10341 if (!SWIG_IsOK(res1)) {
10342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10343 }
10344 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10345 {
10346 arg2 = &temp2;
10347 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10348 }
10349 {
10350 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10351 if (PyErr_Occurred()) SWIG_fail;
10352 }
10353 resultobj = SWIG_From_int(static_cast< int >(result));
10354 return resultobj;
10355 fail:
10356 return NULL;
10357 }
10358
10359
10360 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10361 PyObject *resultobj = 0;
10362 wxRect2D *arg1 = (wxRect2D *) 0 ;
10363 wxPoint2D *arg2 = 0 ;
10364 bool result;
10365 void *argp1 = 0 ;
10366 int res1 = 0 ;
10367 wxPoint2D temp2 ;
10368 PyObject * obj0 = 0 ;
10369 PyObject * obj1 = 0 ;
10370 char * kwnames[] = {
10371 (char *) "self",(char *) "pt", NULL
10372 };
10373
10374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10376 if (!SWIG_IsOK(res1)) {
10377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10378 }
10379 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10380 {
10381 arg2 = &temp2;
10382 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10383 }
10384 {
10385 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10386 if (PyErr_Occurred()) SWIG_fail;
10387 }
10388 {
10389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10390 }
10391 return resultobj;
10392 fail:
10393 return NULL;
10394 }
10395
10396
10397 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10398 PyObject *resultobj = 0;
10399 wxRect2D *arg1 = (wxRect2D *) 0 ;
10400 wxRect2D *arg2 = 0 ;
10401 bool result;
10402 void *argp1 = 0 ;
10403 int res1 = 0 ;
10404 wxRect2D temp2 ;
10405 PyObject * obj0 = 0 ;
10406 PyObject * obj1 = 0 ;
10407 char * kwnames[] = {
10408 (char *) "self",(char *) "rect", NULL
10409 };
10410
10411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10413 if (!SWIG_IsOK(res1)) {
10414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10415 }
10416 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10417 {
10418 arg2 = &temp2;
10419 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10420 }
10421 {
10422 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10423 if (PyErr_Occurred()) SWIG_fail;
10424 }
10425 {
10426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10427 }
10428 return resultobj;
10429 fail:
10430 return NULL;
10431 }
10432
10433
10434 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10435 PyObject *resultobj = 0;
10436 wxRect2D *arg1 = (wxRect2D *) 0 ;
10437 bool result;
10438 void *argp1 = 0 ;
10439 int res1 = 0 ;
10440 PyObject *swig_obj[1] ;
10441
10442 if (!args) SWIG_fail;
10443 swig_obj[0] = args;
10444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10445 if (!SWIG_IsOK(res1)) {
10446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10447 }
10448 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10449 {
10450 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10451 if (PyErr_Occurred()) SWIG_fail;
10452 }
10453 {
10454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10455 }
10456 return resultobj;
10457 fail:
10458 return NULL;
10459 }
10460
10461
10462 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10463 PyObject *resultobj = 0;
10464 wxRect2D *arg1 = (wxRect2D *) 0 ;
10465 wxRect2D *arg2 = 0 ;
10466 bool result;
10467 void *argp1 = 0 ;
10468 int res1 = 0 ;
10469 wxRect2D temp2 ;
10470 PyObject * obj0 = 0 ;
10471 PyObject * obj1 = 0 ;
10472 char * kwnames[] = {
10473 (char *) "self",(char *) "rect", NULL
10474 };
10475
10476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10478 if (!SWIG_IsOK(res1)) {
10479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10480 }
10481 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10482 {
10483 arg2 = &temp2;
10484 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10485 }
10486 {
10487 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10488 if (PyErr_Occurred()) SWIG_fail;
10489 }
10490 {
10491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10492 }
10493 return resultobj;
10494 fail:
10495 return NULL;
10496 }
10497
10498
10499 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10500 PyObject *resultobj = 0;
10501 wxRect2D *arg1 = (wxRect2D *) 0 ;
10502 wxDouble arg2 ;
10503 wxDouble arg3 ;
10504 void *argp1 = 0 ;
10505 int res1 = 0 ;
10506 void *argp2 ;
10507 int res2 = 0 ;
10508 void *argp3 ;
10509 int res3 = 0 ;
10510
10511 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10513 if (!SWIG_IsOK(res1)) {
10514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10515 }
10516 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10517 {
10518 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10519 if (!SWIG_IsOK(res2)) {
10520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10521 }
10522 if (!argp2) {
10523 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10524 } else {
10525 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10526 arg2 = *temp;
10527 if (SWIG_IsNewObj(res2)) delete temp;
10528 }
10529 }
10530 {
10531 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10532 if (!SWIG_IsOK(res3)) {
10533 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10534 }
10535 if (!argp3) {
10536 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10537 } else {
10538 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10539 arg3 = *temp;
10540 if (SWIG_IsNewObj(res3)) delete temp;
10541 }
10542 }
10543 {
10544 (arg1)->Inset(arg2,arg3);
10545 if (PyErr_Occurred()) SWIG_fail;
10546 }
10547 resultobj = SWIG_Py_Void();
10548 return resultobj;
10549 fail:
10550 return NULL;
10551 }
10552
10553
10554 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10555 PyObject *resultobj = 0;
10556 wxRect2D *arg1 = (wxRect2D *) 0 ;
10557 wxDouble arg2 ;
10558 wxDouble arg3 ;
10559 wxDouble arg4 ;
10560 wxDouble arg5 ;
10561 void *argp1 = 0 ;
10562 int res1 = 0 ;
10563 void *argp2 ;
10564 int res2 = 0 ;
10565 void *argp3 ;
10566 int res3 = 0 ;
10567 void *argp4 ;
10568 int res4 = 0 ;
10569 void *argp5 ;
10570 int res5 = 0 ;
10571
10572 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10574 if (!SWIG_IsOK(res1)) {
10575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10576 }
10577 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10578 {
10579 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10580 if (!SWIG_IsOK(res2)) {
10581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10582 }
10583 if (!argp2) {
10584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10585 } else {
10586 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10587 arg2 = *temp;
10588 if (SWIG_IsNewObj(res2)) delete temp;
10589 }
10590 }
10591 {
10592 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10593 if (!SWIG_IsOK(res3)) {
10594 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10595 }
10596 if (!argp3) {
10597 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10598 } else {
10599 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10600 arg3 = *temp;
10601 if (SWIG_IsNewObj(res3)) delete temp;
10602 }
10603 }
10604 {
10605 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10606 if (!SWIG_IsOK(res4)) {
10607 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10608 }
10609 if (!argp4) {
10610 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10611 } else {
10612 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10613 arg4 = *temp;
10614 if (SWIG_IsNewObj(res4)) delete temp;
10615 }
10616 }
10617 {
10618 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10619 if (!SWIG_IsOK(res5)) {
10620 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10621 }
10622 if (!argp5) {
10623 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10624 } else {
10625 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10626 arg5 = *temp;
10627 if (SWIG_IsNewObj(res5)) delete temp;
10628 }
10629 }
10630 {
10631 (arg1)->Inset(arg2,arg3,arg4,arg5);
10632 if (PyErr_Occurred()) SWIG_fail;
10633 }
10634 resultobj = SWIG_Py_Void();
10635 return resultobj;
10636 fail:
10637 return NULL;
10638 }
10639
10640
10641 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10642 int argc;
10643 PyObject *argv[6];
10644
10645 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10646 --argc;
10647 if (argc == 3) {
10648 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10649 }
10650 if (argc == 5) {
10651 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10652 }
10653
10654 fail:
10655 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10656 return NULL;
10657 }
10658
10659
10660 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10661 PyObject *resultobj = 0;
10662 wxRect2D *arg1 = (wxRect2D *) 0 ;
10663 wxPoint2D *arg2 = 0 ;
10664 void *argp1 = 0 ;
10665 int res1 = 0 ;
10666 wxPoint2D temp2 ;
10667 PyObject * obj0 = 0 ;
10668 PyObject * obj1 = 0 ;
10669 char * kwnames[] = {
10670 (char *) "self",(char *) "pt", NULL
10671 };
10672
10673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10675 if (!SWIG_IsOK(res1)) {
10676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10677 }
10678 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10679 {
10680 arg2 = &temp2;
10681 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10682 }
10683 {
10684 (arg1)->Offset((wxPoint2D const &)*arg2);
10685 if (PyErr_Occurred()) SWIG_fail;
10686 }
10687 resultobj = SWIG_Py_Void();
10688 return resultobj;
10689 fail:
10690 return NULL;
10691 }
10692
10693
10694 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10695 PyObject *resultobj = 0;
10696 wxRect2D *arg1 = (wxRect2D *) 0 ;
10697 wxRect2D *arg2 = 0 ;
10698 void *argp1 = 0 ;
10699 int res1 = 0 ;
10700 wxRect2D temp2 ;
10701 PyObject * obj0 = 0 ;
10702 PyObject * obj1 = 0 ;
10703 char * kwnames[] = {
10704 (char *) "self",(char *) "rect", NULL
10705 };
10706
10707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10709 if (!SWIG_IsOK(res1)) {
10710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10711 }
10712 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10713 {
10714 arg2 = &temp2;
10715 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10716 }
10717 {
10718 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10719 if (PyErr_Occurred()) SWIG_fail;
10720 }
10721 resultobj = SWIG_Py_Void();
10722 return resultobj;
10723 fail:
10724 return NULL;
10725 }
10726
10727
10728 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10729 PyObject *resultobj = 0;
10730 wxRect2D *arg1 = (wxRect2D *) 0 ;
10731 int arg2 ;
10732 int arg3 ;
10733 wxPoint2D result;
10734 void *argp1 = 0 ;
10735 int res1 = 0 ;
10736 int val2 ;
10737 int ecode2 = 0 ;
10738 int val3 ;
10739 int ecode3 = 0 ;
10740 PyObject * obj0 = 0 ;
10741 PyObject * obj1 = 0 ;
10742 PyObject * obj2 = 0 ;
10743 char * kwnames[] = {
10744 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10745 };
10746
10747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10749 if (!SWIG_IsOK(res1)) {
10750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10751 }
10752 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10753 ecode2 = SWIG_AsVal_int(obj1, &val2);
10754 if (!SWIG_IsOK(ecode2)) {
10755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10756 }
10757 arg2 = static_cast< int >(val2);
10758 ecode3 = SWIG_AsVal_int(obj2, &val3);
10759 if (!SWIG_IsOK(ecode3)) {
10760 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10761 }
10762 arg3 = static_cast< int >(val3);
10763 {
10764 result = (arg1)->Interpolate(arg2,arg3);
10765 if (PyErr_Occurred()) SWIG_fail;
10766 }
10767 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10768 return resultobj;
10769 fail:
10770 return NULL;
10771 }
10772
10773
10774 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10775 PyObject *resultobj = 0;
10776 wxRect2D *arg1 = (wxRect2D *) 0 ;
10777 wxRect2D *arg2 = 0 ;
10778 void *argp1 = 0 ;
10779 int res1 = 0 ;
10780 wxRect2D temp2 ;
10781 PyObject * obj0 = 0 ;
10782 PyObject * obj1 = 0 ;
10783 char * kwnames[] = {
10784 (char *) "self",(char *) "otherRect", NULL
10785 };
10786
10787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10789 if (!SWIG_IsOK(res1)) {
10790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10791 }
10792 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10793 {
10794 arg2 = &temp2;
10795 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10796 }
10797 {
10798 (arg1)->Intersect((wxRect2D const &)*arg2);
10799 if (PyErr_Occurred()) SWIG_fail;
10800 }
10801 resultobj = SWIG_Py_Void();
10802 return resultobj;
10803 fail:
10804 return NULL;
10805 }
10806
10807
10808 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10809 PyObject *resultobj = 0;
10810 wxRect2D *arg1 = (wxRect2D *) 0 ;
10811 wxRect2D *arg2 = 0 ;
10812 wxRect2D result;
10813 void *argp1 = 0 ;
10814 int res1 = 0 ;
10815 wxRect2D temp2 ;
10816 PyObject * obj0 = 0 ;
10817 PyObject * obj1 = 0 ;
10818 char * kwnames[] = {
10819 (char *) "self",(char *) "otherRect", NULL
10820 };
10821
10822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10824 if (!SWIG_IsOK(res1)) {
10825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10826 }
10827 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10828 {
10829 arg2 = &temp2;
10830 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10831 }
10832 {
10833 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10834 if (PyErr_Occurred()) SWIG_fail;
10835 }
10836 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10837 return resultobj;
10838 fail:
10839 return NULL;
10840 }
10841
10842
10843 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10844 PyObject *resultobj = 0;
10845 wxRect2D *arg1 = (wxRect2D *) 0 ;
10846 wxRect2D *arg2 = 0 ;
10847 bool result;
10848 void *argp1 = 0 ;
10849 int res1 = 0 ;
10850 wxRect2D temp2 ;
10851 PyObject * obj0 = 0 ;
10852 PyObject * obj1 = 0 ;
10853 char * kwnames[] = {
10854 (char *) "self",(char *) "rect", NULL
10855 };
10856
10857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10859 if (!SWIG_IsOK(res1)) {
10860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10861 }
10862 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10863 {
10864 arg2 = &temp2;
10865 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10866 }
10867 {
10868 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10869 if (PyErr_Occurred()) SWIG_fail;
10870 }
10871 {
10872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10873 }
10874 return resultobj;
10875 fail:
10876 return NULL;
10877 }
10878
10879
10880 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10881 PyObject *resultobj = 0;
10882 wxRect2D *arg1 = (wxRect2D *) 0 ;
10883 wxRect2D *arg2 = 0 ;
10884 void *argp1 = 0 ;
10885 int res1 = 0 ;
10886 wxRect2D temp2 ;
10887 PyObject * obj0 = 0 ;
10888 PyObject * obj1 = 0 ;
10889 char * kwnames[] = {
10890 (char *) "self",(char *) "otherRect", NULL
10891 };
10892
10893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10895 if (!SWIG_IsOK(res1)) {
10896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10897 }
10898 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10899 {
10900 arg2 = &temp2;
10901 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10902 }
10903 {
10904 (arg1)->Union((wxRect2D const &)*arg2);
10905 if (PyErr_Occurred()) SWIG_fail;
10906 }
10907 resultobj = SWIG_Py_Void();
10908 return resultobj;
10909 fail:
10910 return NULL;
10911 }
10912
10913
10914 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10915 PyObject *resultobj = 0;
10916 wxRect2D *arg1 = (wxRect2D *) 0 ;
10917 wxRect2D *arg2 = 0 ;
10918 wxRect2D result;
10919 void *argp1 = 0 ;
10920 int res1 = 0 ;
10921 wxRect2D temp2 ;
10922 PyObject * obj0 = 0 ;
10923 PyObject * obj1 = 0 ;
10924 char * kwnames[] = {
10925 (char *) "self",(char *) "otherRect", NULL
10926 };
10927
10928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10930 if (!SWIG_IsOK(res1)) {
10931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10932 }
10933 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10934 {
10935 arg2 = &temp2;
10936 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10937 }
10938 {
10939 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10940 if (PyErr_Occurred()) SWIG_fail;
10941 }
10942 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10943 return resultobj;
10944 fail:
10945 return NULL;
10946 }
10947
10948
10949 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10950 PyObject *resultobj = 0;
10951 wxRect2D *arg1 = (wxRect2D *) 0 ;
10952 wxDouble arg2 ;
10953 void *argp1 = 0 ;
10954 int res1 = 0 ;
10955 void *argp2 ;
10956 int res2 = 0 ;
10957
10958 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10960 if (!SWIG_IsOK(res1)) {
10961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10962 }
10963 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10964 {
10965 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10966 if (!SWIG_IsOK(res2)) {
10967 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10968 }
10969 if (!argp2) {
10970 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10971 } else {
10972 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10973 arg2 = *temp;
10974 if (SWIG_IsNewObj(res2)) delete temp;
10975 }
10976 }
10977 {
10978 (arg1)->Scale(arg2);
10979 if (PyErr_Occurred()) SWIG_fail;
10980 }
10981 resultobj = SWIG_Py_Void();
10982 return resultobj;
10983 fail:
10984 return NULL;
10985 }
10986
10987
10988 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10989 PyObject *resultobj = 0;
10990 wxRect2D *arg1 = (wxRect2D *) 0 ;
10991 int arg2 ;
10992 int arg3 ;
10993 void *argp1 = 0 ;
10994 int res1 = 0 ;
10995 int val2 ;
10996 int ecode2 = 0 ;
10997 int val3 ;
10998 int ecode3 = 0 ;
10999
11000 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
11001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11002 if (!SWIG_IsOK(res1)) {
11003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
11004 }
11005 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11006 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11007 if (!SWIG_IsOK(ecode2)) {
11008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
11009 }
11010 arg2 = static_cast< int >(val2);
11011 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11012 if (!SWIG_IsOK(ecode3)) {
11013 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
11014 }
11015 arg3 = static_cast< int >(val3);
11016 {
11017 (arg1)->Scale(arg2,arg3);
11018 if (PyErr_Occurred()) SWIG_fail;
11019 }
11020 resultobj = SWIG_Py_Void();
11021 return resultobj;
11022 fail:
11023 return NULL;
11024 }
11025
11026
11027 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
11028 int argc;
11029 PyObject *argv[4];
11030
11031 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
11032 --argc;
11033 if (argc == 2) {
11034 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
11035 }
11036 if (argc == 3) {
11037 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
11038 }
11039
11040 fail:
11041 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
11042 return NULL;
11043 }
11044
11045
11046 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11047 PyObject *resultobj = 0;
11048 wxRect2D *arg1 = (wxRect2D *) 0 ;
11049 PyObject *arg2 = (PyObject *) 0 ;
11050 bool result;
11051 void *argp1 = 0 ;
11052 int res1 = 0 ;
11053 PyObject * obj0 = 0 ;
11054 PyObject * obj1 = 0 ;
11055 char * kwnames[] = {
11056 (char *) "self",(char *) "other", NULL
11057 };
11058
11059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
11060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11061 if (!SWIG_IsOK(res1)) {
11062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11063 }
11064 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11065 arg2 = obj1;
11066 {
11067 result = (bool)wxRect2D___eq__(arg1,arg2);
11068 if (PyErr_Occurred()) SWIG_fail;
11069 }
11070 {
11071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11072 }
11073 return resultobj;
11074 fail:
11075 return NULL;
11076 }
11077
11078
11079 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11080 PyObject *resultobj = 0;
11081 wxRect2D *arg1 = (wxRect2D *) 0 ;
11082 PyObject *arg2 = (PyObject *) 0 ;
11083 bool result;
11084 void *argp1 = 0 ;
11085 int res1 = 0 ;
11086 PyObject * obj0 = 0 ;
11087 PyObject * obj1 = 0 ;
11088 char * kwnames[] = {
11089 (char *) "self",(char *) "other", NULL
11090 };
11091
11092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
11093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11094 if (!SWIG_IsOK(res1)) {
11095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11096 }
11097 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11098 arg2 = obj1;
11099 {
11100 result = (bool)wxRect2D___ne__(arg1,arg2);
11101 if (PyErr_Occurred()) SWIG_fail;
11102 }
11103 {
11104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11105 }
11106 return resultobj;
11107 fail:
11108 return NULL;
11109 }
11110
11111
11112 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11113 PyObject *resultobj = 0;
11114 wxRect2D *arg1 = (wxRect2D *) 0 ;
11115 wxDouble arg2 ;
11116 void *argp1 = 0 ;
11117 int res1 = 0 ;
11118 void *argp2 ;
11119 int res2 = 0 ;
11120 PyObject *swig_obj[2] ;
11121
11122 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11124 if (!SWIG_IsOK(res1)) {
11125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11126 }
11127 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11128 {
11129 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11130 if (!SWIG_IsOK(res2)) {
11131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11132 }
11133 if (!argp2) {
11134 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11135 } else {
11136 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11137 arg2 = *temp;
11138 if (SWIG_IsNewObj(res2)) delete temp;
11139 }
11140 }
11141 if (arg1) (arg1)->m_x = arg2;
11142
11143 resultobj = SWIG_Py_Void();
11144 return resultobj;
11145 fail:
11146 return NULL;
11147 }
11148
11149
11150 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11151 PyObject *resultobj = 0;
11152 wxRect2D *arg1 = (wxRect2D *) 0 ;
11153 wxDouble result;
11154 void *argp1 = 0 ;
11155 int res1 = 0 ;
11156 PyObject *swig_obj[1] ;
11157
11158 if (!args) SWIG_fail;
11159 swig_obj[0] = args;
11160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11161 if (!SWIG_IsOK(res1)) {
11162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11163 }
11164 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11165 result = ((arg1)->m_x);
11166 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11167 return resultobj;
11168 fail:
11169 return NULL;
11170 }
11171
11172
11173 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11174 PyObject *resultobj = 0;
11175 wxRect2D *arg1 = (wxRect2D *) 0 ;
11176 wxDouble arg2 ;
11177 void *argp1 = 0 ;
11178 int res1 = 0 ;
11179 void *argp2 ;
11180 int res2 = 0 ;
11181 PyObject *swig_obj[2] ;
11182
11183 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11185 if (!SWIG_IsOK(res1)) {
11186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11187 }
11188 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11189 {
11190 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11191 if (!SWIG_IsOK(res2)) {
11192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11193 }
11194 if (!argp2) {
11195 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11196 } else {
11197 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11198 arg2 = *temp;
11199 if (SWIG_IsNewObj(res2)) delete temp;
11200 }
11201 }
11202 if (arg1) (arg1)->m_y = arg2;
11203
11204 resultobj = SWIG_Py_Void();
11205 return resultobj;
11206 fail:
11207 return NULL;
11208 }
11209
11210
11211 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11212 PyObject *resultobj = 0;
11213 wxRect2D *arg1 = (wxRect2D *) 0 ;
11214 wxDouble result;
11215 void *argp1 = 0 ;
11216 int res1 = 0 ;
11217 PyObject *swig_obj[1] ;
11218
11219 if (!args) SWIG_fail;
11220 swig_obj[0] = args;
11221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11222 if (!SWIG_IsOK(res1)) {
11223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11224 }
11225 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11226 result = ((arg1)->m_y);
11227 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11228 return resultobj;
11229 fail:
11230 return NULL;
11231 }
11232
11233
11234 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11235 PyObject *resultobj = 0;
11236 wxRect2D *arg1 = (wxRect2D *) 0 ;
11237 wxDouble arg2 ;
11238 void *argp1 = 0 ;
11239 int res1 = 0 ;
11240 void *argp2 ;
11241 int res2 = 0 ;
11242 PyObject *swig_obj[2] ;
11243
11244 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11246 if (!SWIG_IsOK(res1)) {
11247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11248 }
11249 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11250 {
11251 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11252 if (!SWIG_IsOK(res2)) {
11253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11254 }
11255 if (!argp2) {
11256 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11257 } else {
11258 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11259 arg2 = *temp;
11260 if (SWIG_IsNewObj(res2)) delete temp;
11261 }
11262 }
11263 if (arg1) (arg1)->m_width = arg2;
11264
11265 resultobj = SWIG_Py_Void();
11266 return resultobj;
11267 fail:
11268 return NULL;
11269 }
11270
11271
11272 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11273 PyObject *resultobj = 0;
11274 wxRect2D *arg1 = (wxRect2D *) 0 ;
11275 wxDouble result;
11276 void *argp1 = 0 ;
11277 int res1 = 0 ;
11278 PyObject *swig_obj[1] ;
11279
11280 if (!args) SWIG_fail;
11281 swig_obj[0] = args;
11282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11283 if (!SWIG_IsOK(res1)) {
11284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11285 }
11286 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11287 result = ((arg1)->m_width);
11288 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11289 return resultobj;
11290 fail:
11291 return NULL;
11292 }
11293
11294
11295 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11296 PyObject *resultobj = 0;
11297 wxRect2D *arg1 = (wxRect2D *) 0 ;
11298 wxDouble arg2 ;
11299 void *argp1 = 0 ;
11300 int res1 = 0 ;
11301 void *argp2 ;
11302 int res2 = 0 ;
11303 PyObject *swig_obj[2] ;
11304
11305 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11307 if (!SWIG_IsOK(res1)) {
11308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11309 }
11310 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11311 {
11312 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11313 if (!SWIG_IsOK(res2)) {
11314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11315 }
11316 if (!argp2) {
11317 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11318 } else {
11319 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11320 arg2 = *temp;
11321 if (SWIG_IsNewObj(res2)) delete temp;
11322 }
11323 }
11324 if (arg1) (arg1)->m_height = arg2;
11325
11326 resultobj = SWIG_Py_Void();
11327 return resultobj;
11328 fail:
11329 return NULL;
11330 }
11331
11332
11333 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11334 PyObject *resultobj = 0;
11335 wxRect2D *arg1 = (wxRect2D *) 0 ;
11336 wxDouble result;
11337 void *argp1 = 0 ;
11338 int res1 = 0 ;
11339 PyObject *swig_obj[1] ;
11340
11341 if (!args) SWIG_fail;
11342 swig_obj[0] = args;
11343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11344 if (!SWIG_IsOK(res1)) {
11345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11346 }
11347 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11348 result = ((arg1)->m_height);
11349 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11350 return resultobj;
11351 fail:
11352 return NULL;
11353 }
11354
11355
11356 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11357 PyObject *resultobj = 0;
11358 wxRect2D *arg1 = (wxRect2D *) 0 ;
11359 wxDouble arg2 = (wxDouble) 0 ;
11360 wxDouble arg3 = (wxDouble) 0 ;
11361 wxDouble arg4 = (wxDouble) 0 ;
11362 wxDouble arg5 = (wxDouble) 0 ;
11363 void *argp1 = 0 ;
11364 int res1 = 0 ;
11365 void *argp2 ;
11366 int res2 = 0 ;
11367 void *argp3 ;
11368 int res3 = 0 ;
11369 void *argp4 ;
11370 int res4 = 0 ;
11371 void *argp5 ;
11372 int res5 = 0 ;
11373 PyObject * obj0 = 0 ;
11374 PyObject * obj1 = 0 ;
11375 PyObject * obj2 = 0 ;
11376 PyObject * obj3 = 0 ;
11377 PyObject * obj4 = 0 ;
11378 char * kwnames[] = {
11379 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11380 };
11381
11382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11384 if (!SWIG_IsOK(res1)) {
11385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11386 }
11387 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11388 if (obj1) {
11389 {
11390 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11391 if (!SWIG_IsOK(res2)) {
11392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11393 }
11394 if (!argp2) {
11395 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11396 } else {
11397 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11398 arg2 = *temp;
11399 if (SWIG_IsNewObj(res2)) delete temp;
11400 }
11401 }
11402 }
11403 if (obj2) {
11404 {
11405 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11406 if (!SWIG_IsOK(res3)) {
11407 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11408 }
11409 if (!argp3) {
11410 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11411 } else {
11412 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11413 arg3 = *temp;
11414 if (SWIG_IsNewObj(res3)) delete temp;
11415 }
11416 }
11417 }
11418 if (obj3) {
11419 {
11420 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11421 if (!SWIG_IsOK(res4)) {
11422 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11423 }
11424 if (!argp4) {
11425 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11426 } else {
11427 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11428 arg4 = *temp;
11429 if (SWIG_IsNewObj(res4)) delete temp;
11430 }
11431 }
11432 }
11433 if (obj4) {
11434 {
11435 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11436 if (!SWIG_IsOK(res5)) {
11437 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11438 }
11439 if (!argp5) {
11440 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11441 } else {
11442 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11443 arg5 = *temp;
11444 if (SWIG_IsNewObj(res5)) delete temp;
11445 }
11446 }
11447 }
11448 {
11449 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11450 if (PyErr_Occurred()) SWIG_fail;
11451 }
11452 resultobj = SWIG_Py_Void();
11453 return resultobj;
11454 fail:
11455 return NULL;
11456 }
11457
11458
11459 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11460 PyObject *resultobj = 0;
11461 wxRect2D *arg1 = (wxRect2D *) 0 ;
11462 PyObject *result = 0 ;
11463 void *argp1 = 0 ;
11464 int res1 = 0 ;
11465 PyObject *swig_obj[1] ;
11466
11467 if (!args) SWIG_fail;
11468 swig_obj[0] = args;
11469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11470 if (!SWIG_IsOK(res1)) {
11471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11472 }
11473 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11474 {
11475 result = (PyObject *)wxRect2D_Get(arg1);
11476 if (PyErr_Occurred()) SWIG_fail;
11477 }
11478 resultobj = result;
11479 return resultobj;
11480 fail:
11481 return NULL;
11482 }
11483
11484
11485 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11486 PyObject *obj;
11487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11488 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11489 return SWIG_Py_Void();
11490 }
11491
11492 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11493 return SWIG_Python_InitShadowInstance(args);
11494 }
11495
11496 SWIGINTERN PyObject *_wrap_new_Position(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11497 PyObject *resultobj = 0;
11498 int arg1 = (int) 0 ;
11499 int arg2 = (int) 0 ;
11500 wxPosition *result = 0 ;
11501 int val1 ;
11502 int ecode1 = 0 ;
11503 int val2 ;
11504 int ecode2 = 0 ;
11505 PyObject * obj0 = 0 ;
11506 PyObject * obj1 = 0 ;
11507 char * kwnames[] = {
11508 (char *) "row",(char *) "col", NULL
11509 };
11510
11511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Position",kwnames,&obj0,&obj1)) SWIG_fail;
11512 if (obj0) {
11513 ecode1 = SWIG_AsVal_int(obj0, &val1);
11514 if (!SWIG_IsOK(ecode1)) {
11515 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Position" "', expected argument " "1"" of type '" "int""'");
11516 }
11517 arg1 = static_cast< int >(val1);
11518 }
11519 if (obj1) {
11520 ecode2 = SWIG_AsVal_int(obj1, &val2);
11521 if (!SWIG_IsOK(ecode2)) {
11522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Position" "', expected argument " "2"" of type '" "int""'");
11523 }
11524 arg2 = static_cast< int >(val2);
11525 }
11526 {
11527 result = (wxPosition *)new wxPosition(arg1,arg2);
11528 if (PyErr_Occurred()) SWIG_fail;
11529 }
11530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPosition, SWIG_POINTER_NEW | 0 );
11531 return resultobj;
11532 fail:
11533 return NULL;
11534 }
11535
11536
11537 SWIGINTERN PyObject *_wrap_delete_Position(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11538 PyObject *resultobj = 0;
11539 wxPosition *arg1 = (wxPosition *) 0 ;
11540 void *argp1 = 0 ;
11541 int res1 = 0 ;
11542 PyObject *swig_obj[1] ;
11543
11544 if (!args) SWIG_fail;
11545 swig_obj[0] = args;
11546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, SWIG_POINTER_DISOWN | 0 );
11547 if (!SWIG_IsOK(res1)) {
11548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Position" "', expected argument " "1"" of type '" "wxPosition *""'");
11549 }
11550 arg1 = reinterpret_cast< wxPosition * >(argp1);
11551 {
11552 delete arg1;
11553
11554 if (PyErr_Occurred()) SWIG_fail;
11555 }
11556 resultobj = SWIG_Py_Void();
11557 return resultobj;
11558 fail:
11559 return NULL;
11560 }
11561
11562
11563 SWIGINTERN PyObject *_wrap_Position_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11564 PyObject *resultobj = 0;
11565 wxPosition *arg1 = (wxPosition *) 0 ;
11566 int result;
11567 void *argp1 = 0 ;
11568 int res1 = 0 ;
11569 PyObject *swig_obj[1] ;
11570
11571 if (!args) SWIG_fail;
11572 swig_obj[0] = args;
11573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11574 if (!SWIG_IsOK(res1)) {
11575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_GetRow" "', expected argument " "1"" of type '" "wxPosition const *""'");
11576 }
11577 arg1 = reinterpret_cast< wxPosition * >(argp1);
11578 {
11579 result = (int)((wxPosition const *)arg1)->GetRow();
11580 if (PyErr_Occurred()) SWIG_fail;
11581 }
11582 resultobj = SWIG_From_int(static_cast< int >(result));
11583 return resultobj;
11584 fail:
11585 return NULL;
11586 }
11587
11588
11589 SWIGINTERN PyObject *_wrap_Position_GetColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11590 PyObject *resultobj = 0;
11591 wxPosition *arg1 = (wxPosition *) 0 ;
11592 int result;
11593 void *argp1 = 0 ;
11594 int res1 = 0 ;
11595 PyObject *swig_obj[1] ;
11596
11597 if (!args) SWIG_fail;
11598 swig_obj[0] = args;
11599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11600 if (!SWIG_IsOK(res1)) {
11601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_GetColumn" "', expected argument " "1"" of type '" "wxPosition const *""'");
11602 }
11603 arg1 = reinterpret_cast< wxPosition * >(argp1);
11604 {
11605 result = (int)((wxPosition const *)arg1)->GetColumn();
11606 if (PyErr_Occurred()) SWIG_fail;
11607 }
11608 resultobj = SWIG_From_int(static_cast< int >(result));
11609 return resultobj;
11610 fail:
11611 return NULL;
11612 }
11613
11614
11615 SWIGINTERN PyObject *_wrap_Position_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11616 PyObject *resultobj = 0;
11617 wxPosition *arg1 = (wxPosition *) 0 ;
11618 int result;
11619 void *argp1 = 0 ;
11620 int res1 = 0 ;
11621 PyObject *swig_obj[1] ;
11622
11623 if (!args) SWIG_fail;
11624 swig_obj[0] = args;
11625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11626 if (!SWIG_IsOK(res1)) {
11627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_GetCol" "', expected argument " "1"" of type '" "wxPosition const *""'");
11628 }
11629 arg1 = reinterpret_cast< wxPosition * >(argp1);
11630 {
11631 result = (int)((wxPosition const *)arg1)->GetCol();
11632 if (PyErr_Occurred()) SWIG_fail;
11633 }
11634 resultobj = SWIG_From_int(static_cast< int >(result));
11635 return resultobj;
11636 fail:
11637 return NULL;
11638 }
11639
11640
11641 SWIGINTERN PyObject *_wrap_Position_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11642 PyObject *resultobj = 0;
11643 wxPosition *arg1 = (wxPosition *) 0 ;
11644 int arg2 ;
11645 void *argp1 = 0 ;
11646 int res1 = 0 ;
11647 int val2 ;
11648 int ecode2 = 0 ;
11649 PyObject * obj0 = 0 ;
11650 PyObject * obj1 = 0 ;
11651 char * kwnames[] = {
11652 (char *) "self",(char *) "row", NULL
11653 };
11654
11655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
11656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11657 if (!SWIG_IsOK(res1)) {
11658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_SetRow" "', expected argument " "1"" of type '" "wxPosition *""'");
11659 }
11660 arg1 = reinterpret_cast< wxPosition * >(argp1);
11661 ecode2 = SWIG_AsVal_int(obj1, &val2);
11662 if (!SWIG_IsOK(ecode2)) {
11663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Position_SetRow" "', expected argument " "2"" of type '" "int""'");
11664 }
11665 arg2 = static_cast< int >(val2);
11666 {
11667 (arg1)->SetRow(arg2);
11668 if (PyErr_Occurred()) SWIG_fail;
11669 }
11670 resultobj = SWIG_Py_Void();
11671 return resultobj;
11672 fail:
11673 return NULL;
11674 }
11675
11676
11677 SWIGINTERN PyObject *_wrap_Position_SetColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11678 PyObject *resultobj = 0;
11679 wxPosition *arg1 = (wxPosition *) 0 ;
11680 int arg2 ;
11681 void *argp1 = 0 ;
11682 int res1 = 0 ;
11683 int val2 ;
11684 int ecode2 = 0 ;
11685 PyObject * obj0 = 0 ;
11686 PyObject * obj1 = 0 ;
11687 char * kwnames[] = {
11688 (char *) "self",(char *) "column", NULL
11689 };
11690
11691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position_SetColumn",kwnames,&obj0,&obj1)) SWIG_fail;
11692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11693 if (!SWIG_IsOK(res1)) {
11694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_SetColumn" "', expected argument " "1"" of type '" "wxPosition *""'");
11695 }
11696 arg1 = reinterpret_cast< wxPosition * >(argp1);
11697 ecode2 = SWIG_AsVal_int(obj1, &val2);
11698 if (!SWIG_IsOK(ecode2)) {
11699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Position_SetColumn" "', expected argument " "2"" of type '" "int""'");
11700 }
11701 arg2 = static_cast< int >(val2);
11702 {
11703 (arg1)->SetColumn(arg2);
11704 if (PyErr_Occurred()) SWIG_fail;
11705 }
11706 resultobj = SWIG_Py_Void();
11707 return resultobj;
11708 fail:
11709 return NULL;
11710 }
11711
11712
11713 SWIGINTERN PyObject *_wrap_Position_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11714 PyObject *resultobj = 0;
11715 wxPosition *arg1 = (wxPosition *) 0 ;
11716 int arg2 ;
11717 void *argp1 = 0 ;
11718 int res1 = 0 ;
11719 int val2 ;
11720 int ecode2 = 0 ;
11721 PyObject * obj0 = 0 ;
11722 PyObject * obj1 = 0 ;
11723 char * kwnames[] = {
11724 (char *) "self",(char *) "column", NULL
11725 };
11726
11727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
11728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11729 if (!SWIG_IsOK(res1)) {
11730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_SetCol" "', expected argument " "1"" of type '" "wxPosition *""'");
11731 }
11732 arg1 = reinterpret_cast< wxPosition * >(argp1);
11733 ecode2 = SWIG_AsVal_int(obj1, &val2);
11734 if (!SWIG_IsOK(ecode2)) {
11735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Position_SetCol" "', expected argument " "2"" of type '" "int""'");
11736 }
11737 arg2 = static_cast< int >(val2);
11738 {
11739 (arg1)->SetCol(arg2);
11740 if (PyErr_Occurred()) SWIG_fail;
11741 }
11742 resultobj = SWIG_Py_Void();
11743 return resultobj;
11744 fail:
11745 return NULL;
11746 }
11747
11748
11749 SWIGINTERN PyObject *_wrap_Position___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11750 PyObject *resultobj = 0;
11751 wxPosition *arg1 = (wxPosition *) 0 ;
11752 PyObject *arg2 = (PyObject *) 0 ;
11753 bool result;
11754 void *argp1 = 0 ;
11755 int res1 = 0 ;
11756 PyObject * obj0 = 0 ;
11757 PyObject * obj1 = 0 ;
11758 char * kwnames[] = {
11759 (char *) "self",(char *) "other", NULL
11760 };
11761
11762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
11763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11764 if (!SWIG_IsOK(res1)) {
11765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___eq__" "', expected argument " "1"" of type '" "wxPosition *""'");
11766 }
11767 arg1 = reinterpret_cast< wxPosition * >(argp1);
11768 arg2 = obj1;
11769 {
11770 result = (bool)wxPosition___eq__(arg1,arg2);
11771 if (PyErr_Occurred()) SWIG_fail;
11772 }
11773 {
11774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11775 }
11776 return resultobj;
11777 fail:
11778 return NULL;
11779 }
11780
11781
11782 SWIGINTERN PyObject *_wrap_Position___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11783 PyObject *resultobj = 0;
11784 wxPosition *arg1 = (wxPosition *) 0 ;
11785 PyObject *arg2 = (PyObject *) 0 ;
11786 bool result;
11787 void *argp1 = 0 ;
11788 int res1 = 0 ;
11789 PyObject * obj0 = 0 ;
11790 PyObject * obj1 = 0 ;
11791 char * kwnames[] = {
11792 (char *) "self",(char *) "other", NULL
11793 };
11794
11795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
11796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11797 if (!SWIG_IsOK(res1)) {
11798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___ne__" "', expected argument " "1"" of type '" "wxPosition *""'");
11799 }
11800 arg1 = reinterpret_cast< wxPosition * >(argp1);
11801 arg2 = obj1;
11802 {
11803 result = (bool)wxPosition___ne__(arg1,arg2);
11804 if (PyErr_Occurred()) SWIG_fail;
11805 }
11806 {
11807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11808 }
11809 return resultobj;
11810 fail:
11811 return NULL;
11812 }
11813
11814
11815 SWIGINTERN PyObject *_wrap_Position___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11816 PyObject *resultobj = 0;
11817 wxPosition *arg1 = (wxPosition *) 0 ;
11818 wxPosition *arg2 = 0 ;
11819 wxPosition result;
11820 void *argp1 = 0 ;
11821 int res1 = 0 ;
11822 void *argp2 = 0 ;
11823 int res2 = 0 ;
11824
11825 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11827 if (!SWIG_IsOK(res1)) {
11828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___add__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11829 }
11830 arg1 = reinterpret_cast< wxPosition * >(argp1);
11831 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxPosition, 0 | 0);
11832 if (!SWIG_IsOK(res2)) {
11833 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position___add__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11834 }
11835 if (!argp2) {
11836 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position___add__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11837 }
11838 arg2 = reinterpret_cast< wxPosition * >(argp2);
11839 {
11840 result = ((wxPosition const *)arg1)->operator +((wxPosition const &)*arg2);
11841 if (PyErr_Occurred()) SWIG_fail;
11842 }
11843 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11844 return resultobj;
11845 fail:
11846 return NULL;
11847 }
11848
11849
11850 SWIGINTERN PyObject *_wrap_Position___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11851 PyObject *resultobj = 0;
11852 wxPosition *arg1 = (wxPosition *) 0 ;
11853 wxPosition *arg2 = 0 ;
11854 wxPosition result;
11855 void *argp1 = 0 ;
11856 int res1 = 0 ;
11857 void *argp2 = 0 ;
11858 int res2 = 0 ;
11859
11860 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11862 if (!SWIG_IsOK(res1)) {
11863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___sub__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11864 }
11865 arg1 = reinterpret_cast< wxPosition * >(argp1);
11866 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxPosition, 0 | 0);
11867 if (!SWIG_IsOK(res2)) {
11868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position___sub__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11869 }
11870 if (!argp2) {
11871 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position___sub__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11872 }
11873 arg2 = reinterpret_cast< wxPosition * >(argp2);
11874 {
11875 result = ((wxPosition const *)arg1)->operator -((wxPosition const &)*arg2);
11876 if (PyErr_Occurred()) SWIG_fail;
11877 }
11878 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11879 return resultobj;
11880 fail:
11881 return NULL;
11882 }
11883
11884
11885 SWIGINTERN PyObject *_wrap_Position___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11886 PyObject *resultobj = 0;
11887 wxPosition *arg1 = (wxPosition *) 0 ;
11888 wxSize *arg2 = 0 ;
11889 wxPosition result;
11890 void *argp1 = 0 ;
11891 int res1 = 0 ;
11892 wxSize temp2 ;
11893
11894 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11896 if (!SWIG_IsOK(res1)) {
11897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___add__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11898 }
11899 arg1 = reinterpret_cast< wxPosition * >(argp1);
11900 {
11901 arg2 = &temp2;
11902 if ( ! wxSize_helper(swig_obj[1], &arg2)) SWIG_fail;
11903 }
11904 {
11905 result = ((wxPosition const *)arg1)->operator +((wxSize const &)*arg2);
11906 if (PyErr_Occurred()) SWIG_fail;
11907 }
11908 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11909 return resultobj;
11910 fail:
11911 return NULL;
11912 }
11913
11914
11915 SWIGINTERN PyObject *_wrap_Position___add__(PyObject *self, PyObject *args) {
11916 int argc;
11917 PyObject *argv[3];
11918
11919 if (!(argc = SWIG_Python_UnpackTuple(args,"Position___add__",0,2,argv))) SWIG_fail;
11920 --argc;
11921 if (argc == 2) {
11922 int _v = 0;
11923 {
11924 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxPosition, 0);
11925 _v = SWIG_CheckState(res);
11926 }
11927 if (!_v) goto check_1;
11928 return _wrap_Position___add____SWIG_0(self, argc, argv);
11929 }
11930 check_1:
11931
11932 if (argc == 2) {
11933 return _wrap_Position___add____SWIG_1(self, argc, argv);
11934 }
11935
11936 fail:
11937 Py_INCREF(Py_NotImplemented);
11938 return Py_NotImplemented;
11939 }
11940
11941
11942 SWIGINTERN PyObject *_wrap_Position___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11943 PyObject *resultobj = 0;
11944 wxPosition *arg1 = (wxPosition *) 0 ;
11945 wxSize *arg2 = 0 ;
11946 wxPosition result;
11947 void *argp1 = 0 ;
11948 int res1 = 0 ;
11949 wxSize temp2 ;
11950
11951 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11953 if (!SWIG_IsOK(res1)) {
11954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___sub__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11955 }
11956 arg1 = reinterpret_cast< wxPosition * >(argp1);
11957 {
11958 arg2 = &temp2;
11959 if ( ! wxSize_helper(swig_obj[1], &arg2)) SWIG_fail;
11960 }
11961 {
11962 result = ((wxPosition const *)arg1)->operator -((wxSize const &)*arg2);
11963 if (PyErr_Occurred()) SWIG_fail;
11964 }
11965 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11966 return resultobj;
11967 fail:
11968 return NULL;
11969 }
11970
11971
11972 SWIGINTERN PyObject *_wrap_Position___sub__(PyObject *self, PyObject *args) {
11973 int argc;
11974 PyObject *argv[3];
11975
11976 if (!(argc = SWIG_Python_UnpackTuple(args,"Position___sub__",0,2,argv))) SWIG_fail;
11977 --argc;
11978 if (argc == 2) {
11979 int _v = 0;
11980 {
11981 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxPosition, 0);
11982 _v = SWIG_CheckState(res);
11983 }
11984 if (!_v) goto check_1;
11985 return _wrap_Position___sub____SWIG_0(self, argc, argv);
11986 }
11987 check_1:
11988
11989 if (argc == 2) {
11990 return _wrap_Position___sub____SWIG_1(self, argc, argv);
11991 }
11992
11993 fail:
11994 Py_INCREF(Py_NotImplemented);
11995 return Py_NotImplemented;
11996 }
11997
11998
11999 SWIGINTERN PyObject *Position_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12000 PyObject *obj;
12001 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12002 SWIG_TypeNewClientData(SWIGTYPE_p_wxPosition, SWIG_NewClientData(obj));
12003 return SWIG_Py_Void();
12004 }
12005
12006 SWIGINTERN PyObject *Position_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12007 return SWIG_Python_InitShadowInstance(args);
12008 }
12009
12010 SWIGINTERN int DefaultPosition_set(PyObject *) {
12011 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
12012 return 1;
12013 }
12014
12015
12016 SWIGINTERN PyObject *DefaultPosition_get(void) {
12017 PyObject *pyobj = 0;
12018
12019 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
12020 return pyobj;
12021 }
12022
12023
12024 SWIGINTERN int DefaultSize_set(PyObject *) {
12025 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
12026 return 1;
12027 }
12028
12029
12030 SWIGINTERN PyObject *DefaultSize_get(void) {
12031 PyObject *pyobj = 0;
12032
12033 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
12034 return pyobj;
12035 }
12036
12037
12038 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12039 PyObject *resultobj = 0;
12040 PyObject *arg1 = (PyObject *) 0 ;
12041 wxPyInputStream *result = 0 ;
12042 PyObject * obj0 = 0 ;
12043 char * kwnames[] = {
12044 (char *) "p", NULL
12045 };
12046
12047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
12048 arg1 = obj0;
12049 {
12050 PyThreadState* __tstate = wxPyBeginAllowThreads();
12051 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
12052 wxPyEndAllowThreads(__tstate);
12053 if (PyErr_Occurred()) SWIG_fail;
12054 }
12055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
12056 return resultobj;
12057 fail:
12058 return NULL;
12059 }
12060
12061
12062 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12063 PyObject *resultobj = 0;
12064 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12065 void *argp1 = 0 ;
12066 int res1 = 0 ;
12067 PyObject *swig_obj[1] ;
12068
12069 if (!args) SWIG_fail;
12070 swig_obj[0] = args;
12071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
12072 if (!SWIG_IsOK(res1)) {
12073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12074 }
12075 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12076 {
12077 PyThreadState* __tstate = wxPyBeginAllowThreads();
12078 delete arg1;
12079
12080 wxPyEndAllowThreads(__tstate);
12081 if (PyErr_Occurred()) SWIG_fail;
12082 }
12083 resultobj = SWIG_Py_Void();
12084 return resultobj;
12085 fail:
12086 return NULL;
12087 }
12088
12089
12090 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12091 PyObject *resultobj = 0;
12092 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12093 void *argp1 = 0 ;
12094 int res1 = 0 ;
12095 PyObject *swig_obj[1] ;
12096
12097 if (!args) SWIG_fail;
12098 swig_obj[0] = args;
12099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12100 if (!SWIG_IsOK(res1)) {
12101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12102 }
12103 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12104 {
12105 PyThreadState* __tstate = wxPyBeginAllowThreads();
12106 (arg1)->close();
12107 wxPyEndAllowThreads(__tstate);
12108 if (PyErr_Occurred()) SWIG_fail;
12109 }
12110 resultobj = SWIG_Py_Void();
12111 return resultobj;
12112 fail:
12113 return NULL;
12114 }
12115
12116
12117 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12118 PyObject *resultobj = 0;
12119 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12120 void *argp1 = 0 ;
12121 int res1 = 0 ;
12122 PyObject *swig_obj[1] ;
12123
12124 if (!args) SWIG_fail;
12125 swig_obj[0] = args;
12126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12127 if (!SWIG_IsOK(res1)) {
12128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12129 }
12130 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12131 {
12132 PyThreadState* __tstate = wxPyBeginAllowThreads();
12133 (arg1)->flush();
12134 wxPyEndAllowThreads(__tstate);
12135 if (PyErr_Occurred()) SWIG_fail;
12136 }
12137 resultobj = SWIG_Py_Void();
12138 return resultobj;
12139 fail:
12140 return NULL;
12141 }
12142
12143
12144 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12145 PyObject *resultobj = 0;
12146 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12147 bool result;
12148 void *argp1 = 0 ;
12149 int res1 = 0 ;
12150 PyObject *swig_obj[1] ;
12151
12152 if (!args) SWIG_fail;
12153 swig_obj[0] = args;
12154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12155 if (!SWIG_IsOK(res1)) {
12156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12157 }
12158 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12159 {
12160 PyThreadState* __tstate = wxPyBeginAllowThreads();
12161 result = (bool)(arg1)->eof();
12162 wxPyEndAllowThreads(__tstate);
12163 if (PyErr_Occurred()) SWIG_fail;
12164 }
12165 {
12166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12167 }
12168 return resultobj;
12169 fail:
12170 return NULL;
12171 }
12172
12173
12174 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12175 PyObject *resultobj = 0;
12176 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12177 int arg2 = (int) -1 ;
12178 PyObject *result = 0 ;
12179 void *argp1 = 0 ;
12180 int res1 = 0 ;
12181 int val2 ;
12182 int ecode2 = 0 ;
12183 PyObject * obj0 = 0 ;
12184 PyObject * obj1 = 0 ;
12185 char * kwnames[] = {
12186 (char *) "self",(char *) "size", NULL
12187 };
12188
12189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
12190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12191 if (!SWIG_IsOK(res1)) {
12192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12193 }
12194 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12195 if (obj1) {
12196 ecode2 = SWIG_AsVal_int(obj1, &val2);
12197 if (!SWIG_IsOK(ecode2)) {
12198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
12199 }
12200 arg2 = static_cast< int >(val2);
12201 }
12202 {
12203 PyThreadState* __tstate = wxPyBeginAllowThreads();
12204 result = (PyObject *)(arg1)->read(arg2);
12205 wxPyEndAllowThreads(__tstate);
12206 if (PyErr_Occurred()) SWIG_fail;
12207 }
12208 resultobj = result;
12209 return resultobj;
12210 fail:
12211 return NULL;
12212 }
12213
12214
12215 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12216 PyObject *resultobj = 0;
12217 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12218 int arg2 = (int) -1 ;
12219 PyObject *result = 0 ;
12220 void *argp1 = 0 ;
12221 int res1 = 0 ;
12222 int val2 ;
12223 int ecode2 = 0 ;
12224 PyObject * obj0 = 0 ;
12225 PyObject * obj1 = 0 ;
12226 char * kwnames[] = {
12227 (char *) "self",(char *) "size", NULL
12228 };
12229
12230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
12231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12232 if (!SWIG_IsOK(res1)) {
12233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12234 }
12235 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12236 if (obj1) {
12237 ecode2 = SWIG_AsVal_int(obj1, &val2);
12238 if (!SWIG_IsOK(ecode2)) {
12239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
12240 }
12241 arg2 = static_cast< int >(val2);
12242 }
12243 {
12244 PyThreadState* __tstate = wxPyBeginAllowThreads();
12245 result = (PyObject *)(arg1)->readline(arg2);
12246 wxPyEndAllowThreads(__tstate);
12247 if (PyErr_Occurred()) SWIG_fail;
12248 }
12249 resultobj = result;
12250 return resultobj;
12251 fail:
12252 return NULL;
12253 }
12254
12255
12256 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12257 PyObject *resultobj = 0;
12258 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12259 int arg2 = (int) -1 ;
12260 PyObject *result = 0 ;
12261 void *argp1 = 0 ;
12262 int res1 = 0 ;
12263 int val2 ;
12264 int ecode2 = 0 ;
12265 PyObject * obj0 = 0 ;
12266 PyObject * obj1 = 0 ;
12267 char * kwnames[] = {
12268 (char *) "self",(char *) "sizehint", NULL
12269 };
12270
12271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
12272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12273 if (!SWIG_IsOK(res1)) {
12274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12275 }
12276 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12277 if (obj1) {
12278 ecode2 = SWIG_AsVal_int(obj1, &val2);
12279 if (!SWIG_IsOK(ecode2)) {
12280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
12281 }
12282 arg2 = static_cast< int >(val2);
12283 }
12284 {
12285 PyThreadState* __tstate = wxPyBeginAllowThreads();
12286 result = (PyObject *)(arg1)->readlines(arg2);
12287 wxPyEndAllowThreads(__tstate);
12288 if (PyErr_Occurred()) SWIG_fail;
12289 }
12290 resultobj = result;
12291 return resultobj;
12292 fail:
12293 return NULL;
12294 }
12295
12296
12297 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12298 PyObject *resultobj = 0;
12299 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12300 int arg2 ;
12301 int arg3 = (int) 0 ;
12302 void *argp1 = 0 ;
12303 int res1 = 0 ;
12304 int val2 ;
12305 int ecode2 = 0 ;
12306 int val3 ;
12307 int ecode3 = 0 ;
12308 PyObject * obj0 = 0 ;
12309 PyObject * obj1 = 0 ;
12310 PyObject * obj2 = 0 ;
12311 char * kwnames[] = {
12312 (char *) "self",(char *) "offset",(char *) "whence", NULL
12313 };
12314
12315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12317 if (!SWIG_IsOK(res1)) {
12318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12319 }
12320 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12321 ecode2 = SWIG_AsVal_int(obj1, &val2);
12322 if (!SWIG_IsOK(ecode2)) {
12323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
12324 }
12325 arg2 = static_cast< int >(val2);
12326 if (obj2) {
12327 ecode3 = SWIG_AsVal_int(obj2, &val3);
12328 if (!SWIG_IsOK(ecode3)) {
12329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
12330 }
12331 arg3 = static_cast< int >(val3);
12332 }
12333 {
12334 PyThreadState* __tstate = wxPyBeginAllowThreads();
12335 (arg1)->seek(arg2,arg3);
12336 wxPyEndAllowThreads(__tstate);
12337 if (PyErr_Occurred()) SWIG_fail;
12338 }
12339 resultobj = SWIG_Py_Void();
12340 return resultobj;
12341 fail:
12342 return NULL;
12343 }
12344
12345
12346 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12347 PyObject *resultobj = 0;
12348 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12349 int result;
12350 void *argp1 = 0 ;
12351 int res1 = 0 ;
12352 PyObject *swig_obj[1] ;
12353
12354 if (!args) SWIG_fail;
12355 swig_obj[0] = args;
12356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12357 if (!SWIG_IsOK(res1)) {
12358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12359 }
12360 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12361 {
12362 PyThreadState* __tstate = wxPyBeginAllowThreads();
12363 result = (int)(arg1)->tell();
12364 wxPyEndAllowThreads(__tstate);
12365 if (PyErr_Occurred()) SWIG_fail;
12366 }
12367 resultobj = SWIG_From_int(static_cast< int >(result));
12368 return resultobj;
12369 fail:
12370 return NULL;
12371 }
12372
12373
12374 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12375 PyObject *resultobj = 0;
12376 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12377 char result;
12378 void *argp1 = 0 ;
12379 int res1 = 0 ;
12380 PyObject *swig_obj[1] ;
12381
12382 if (!args) SWIG_fail;
12383 swig_obj[0] = args;
12384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12385 if (!SWIG_IsOK(res1)) {
12386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12387 }
12388 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12389 {
12390 PyThreadState* __tstate = wxPyBeginAllowThreads();
12391 result = (char)(arg1)->Peek();
12392 wxPyEndAllowThreads(__tstate);
12393 if (PyErr_Occurred()) SWIG_fail;
12394 }
12395 resultobj = SWIG_From_char(static_cast< char >(result));
12396 return resultobj;
12397 fail:
12398 return NULL;
12399 }
12400
12401
12402 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12403 PyObject *resultobj = 0;
12404 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12405 char result;
12406 void *argp1 = 0 ;
12407 int res1 = 0 ;
12408 PyObject *swig_obj[1] ;
12409
12410 if (!args) SWIG_fail;
12411 swig_obj[0] = args;
12412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12413 if (!SWIG_IsOK(res1)) {
12414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12415 }
12416 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12417 {
12418 PyThreadState* __tstate = wxPyBeginAllowThreads();
12419 result = (char)(arg1)->GetC();
12420 wxPyEndAllowThreads(__tstate);
12421 if (PyErr_Occurred()) SWIG_fail;
12422 }
12423 resultobj = SWIG_From_char(static_cast< char >(result));
12424 return resultobj;
12425 fail:
12426 return NULL;
12427 }
12428
12429
12430 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12431 PyObject *resultobj = 0;
12432 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12433 size_t result;
12434 void *argp1 = 0 ;
12435 int res1 = 0 ;
12436 PyObject *swig_obj[1] ;
12437
12438 if (!args) SWIG_fail;
12439 swig_obj[0] = args;
12440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12441 if (!SWIG_IsOK(res1)) {
12442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12443 }
12444 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12445 {
12446 PyThreadState* __tstate = wxPyBeginAllowThreads();
12447 result = (size_t)(arg1)->LastRead();
12448 wxPyEndAllowThreads(__tstate);
12449 if (PyErr_Occurred()) SWIG_fail;
12450 }
12451 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12452 return resultobj;
12453 fail:
12454 return NULL;
12455 }
12456
12457
12458 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12459 PyObject *resultobj = 0;
12460 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12461 bool result;
12462 void *argp1 = 0 ;
12463 int res1 = 0 ;
12464 PyObject *swig_obj[1] ;
12465
12466 if (!args) SWIG_fail;
12467 swig_obj[0] = args;
12468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12469 if (!SWIG_IsOK(res1)) {
12470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12471 }
12472 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12473 {
12474 PyThreadState* __tstate = wxPyBeginAllowThreads();
12475 result = (bool)(arg1)->CanRead();
12476 wxPyEndAllowThreads(__tstate);
12477 if (PyErr_Occurred()) SWIG_fail;
12478 }
12479 {
12480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12481 }
12482 return resultobj;
12483 fail:
12484 return NULL;
12485 }
12486
12487
12488 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12489 PyObject *resultobj = 0;
12490 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12491 bool result;
12492 void *argp1 = 0 ;
12493 int res1 = 0 ;
12494 PyObject *swig_obj[1] ;
12495
12496 if (!args) SWIG_fail;
12497 swig_obj[0] = args;
12498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12499 if (!SWIG_IsOK(res1)) {
12500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12501 }
12502 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12503 {
12504 PyThreadState* __tstate = wxPyBeginAllowThreads();
12505 result = (bool)(arg1)->Eof();
12506 wxPyEndAllowThreads(__tstate);
12507 if (PyErr_Occurred()) SWIG_fail;
12508 }
12509 {
12510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12511 }
12512 return resultobj;
12513 fail:
12514 return NULL;
12515 }
12516
12517
12518 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12519 PyObject *resultobj = 0;
12520 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12521 char arg2 ;
12522 bool result;
12523 void *argp1 = 0 ;
12524 int res1 = 0 ;
12525 char val2 ;
12526 int ecode2 = 0 ;
12527 PyObject * obj0 = 0 ;
12528 PyObject * obj1 = 0 ;
12529 char * kwnames[] = {
12530 (char *) "self",(char *) "c", NULL
12531 };
12532
12533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
12534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12535 if (!SWIG_IsOK(res1)) {
12536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12537 }
12538 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12539 ecode2 = SWIG_AsVal_char(obj1, &val2);
12540 if (!SWIG_IsOK(ecode2)) {
12541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
12542 }
12543 arg2 = static_cast< char >(val2);
12544 {
12545 PyThreadState* __tstate = wxPyBeginAllowThreads();
12546 result = (bool)(arg1)->Ungetch(arg2);
12547 wxPyEndAllowThreads(__tstate);
12548 if (PyErr_Occurred()) SWIG_fail;
12549 }
12550 {
12551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12552 }
12553 return resultobj;
12554 fail:
12555 return NULL;
12556 }
12557
12558
12559 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12560 PyObject *resultobj = 0;
12561 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12562 long arg2 ;
12563 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
12564 long result;
12565 void *argp1 = 0 ;
12566 int res1 = 0 ;
12567 long val2 ;
12568 int ecode2 = 0 ;
12569 int val3 ;
12570 int ecode3 = 0 ;
12571 PyObject * obj0 = 0 ;
12572 PyObject * obj1 = 0 ;
12573 PyObject * obj2 = 0 ;
12574 char * kwnames[] = {
12575 (char *) "self",(char *) "pos",(char *) "mode", NULL
12576 };
12577
12578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12580 if (!SWIG_IsOK(res1)) {
12581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12582 }
12583 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12584 ecode2 = SWIG_AsVal_long(obj1, &val2);
12585 if (!SWIG_IsOK(ecode2)) {
12586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
12587 }
12588 arg2 = static_cast< long >(val2);
12589 if (obj2) {
12590 ecode3 = SWIG_AsVal_int(obj2, &val3);
12591 if (!SWIG_IsOK(ecode3)) {
12592 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
12593 }
12594 arg3 = static_cast< wxSeekMode >(val3);
12595 }
12596 {
12597 PyThreadState* __tstate = wxPyBeginAllowThreads();
12598 result = (long)(arg1)->SeekI(arg2,arg3);
12599 wxPyEndAllowThreads(__tstate);
12600 if (PyErr_Occurred()) SWIG_fail;
12601 }
12602 resultobj = SWIG_From_long(static_cast< long >(result));
12603 return resultobj;
12604 fail:
12605 return NULL;
12606 }
12607
12608
12609 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12610 PyObject *resultobj = 0;
12611 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12612 long result;
12613 void *argp1 = 0 ;
12614 int res1 = 0 ;
12615 PyObject *swig_obj[1] ;
12616
12617 if (!args) SWIG_fail;
12618 swig_obj[0] = args;
12619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12620 if (!SWIG_IsOK(res1)) {
12621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12622 }
12623 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12624 {
12625 PyThreadState* __tstate = wxPyBeginAllowThreads();
12626 result = (long)(arg1)->TellI();
12627 wxPyEndAllowThreads(__tstate);
12628 if (PyErr_Occurred()) SWIG_fail;
12629 }
12630 resultobj = SWIG_From_long(static_cast< long >(result));
12631 return resultobj;
12632 fail:
12633 return NULL;
12634 }
12635
12636
12637 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12638 PyObject *obj;
12639 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12640 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12641 return SWIG_Py_Void();
12642 }
12643
12644 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12645 return SWIG_Python_InitShadowInstance(args);
12646 }
12647
12648 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12649 PyObject *resultobj = 0;
12650 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12651 PyObject *arg2 = (PyObject *) 0 ;
12652 void *argp1 = 0 ;
12653 int res1 = 0 ;
12654 PyObject * obj0 = 0 ;
12655 PyObject * obj1 = 0 ;
12656 char * kwnames[] = {
12657 (char *) "self",(char *) "obj", NULL
12658 };
12659
12660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12662 if (!SWIG_IsOK(res1)) {
12663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12664 }
12665 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12666 arg2 = obj1;
12667 {
12668 PyThreadState* __tstate = wxPyBeginAllowThreads();
12669 wxOutputStream_write(arg1,arg2);
12670 wxPyEndAllowThreads(__tstate);
12671 if (PyErr_Occurred()) SWIG_fail;
12672 }
12673 resultobj = SWIG_Py_Void();
12674 return resultobj;
12675 fail:
12676 return NULL;
12677 }
12678
12679
12680 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12681 PyObject *resultobj = 0;
12682 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12683 size_t result;
12684 void *argp1 = 0 ;
12685 int res1 = 0 ;
12686 PyObject *swig_obj[1] ;
12687
12688 if (!args) SWIG_fail;
12689 swig_obj[0] = args;
12690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12691 if (!SWIG_IsOK(res1)) {
12692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12693 }
12694 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12695 {
12696 PyThreadState* __tstate = wxPyBeginAllowThreads();
12697 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12698 wxPyEndAllowThreads(__tstate);
12699 if (PyErr_Occurred()) SWIG_fail;
12700 }
12701 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12702 return resultobj;
12703 fail:
12704 return NULL;
12705 }
12706
12707
12708 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12709 PyObject *obj;
12710 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12711 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12712 return SWIG_Py_Void();
12713 }
12714
12715 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12716 PyObject *resultobj = 0;
12717 wxInputStream *arg1 = (wxInputStream *) 0 ;
12718 wxString *arg2 = 0 ;
12719 wxString *arg3 = 0 ;
12720 wxString *arg4 = 0 ;
12721 wxDateTime arg5 ;
12722 wxFSFile *result = 0 ;
12723 wxPyInputStream *temp1 ;
12724 bool temp2 = false ;
12725 bool temp3 = false ;
12726 bool temp4 = false ;
12727 void *argp5 ;
12728 int res5 = 0 ;
12729 PyObject * obj0 = 0 ;
12730 PyObject * obj1 = 0 ;
12731 PyObject * obj2 = 0 ;
12732 PyObject * obj3 = 0 ;
12733 PyObject * obj4 = 0 ;
12734 char * kwnames[] = {
12735 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12736 };
12737
12738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12739 {
12740 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12741 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12742 } else {
12743 PyErr_Clear(); // clear the failure of the wxPyConvert above
12744 arg1 = wxPyCBInputStream_create(obj0, true);
12745 if (arg1 == NULL) {
12746 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12747 SWIG_fail;
12748 }
12749 }
12750 }
12751 {
12752 arg2 = wxString_in_helper(obj1);
12753 if (arg2 == NULL) SWIG_fail;
12754 temp2 = true;
12755 }
12756 {
12757 arg3 = wxString_in_helper(obj2);
12758 if (arg3 == NULL) SWIG_fail;
12759 temp3 = true;
12760 }
12761 {
12762 arg4 = wxString_in_helper(obj3);
12763 if (arg4 == NULL) SWIG_fail;
12764 temp4 = true;
12765 }
12766 {
12767 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12768 if (!SWIG_IsOK(res5)) {
12769 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12770 }
12771 if (!argp5) {
12772 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12773 } else {
12774 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12775 arg5 = *temp;
12776 if (SWIG_IsNewObj(res5)) delete temp;
12777 }
12778 }
12779 {
12780 PyThreadState* __tstate = wxPyBeginAllowThreads();
12781 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12782 wxPyEndAllowThreads(__tstate);
12783 if (PyErr_Occurred()) SWIG_fail;
12784 }
12785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12786 {
12787 if (temp2)
12788 delete arg2;
12789 }
12790 {
12791 if (temp3)
12792 delete arg3;
12793 }
12794 {
12795 if (temp4)
12796 delete arg4;
12797 }
12798 return resultobj;
12799 fail:
12800 {
12801 if (temp2)
12802 delete arg2;
12803 }
12804 {
12805 if (temp3)
12806 delete arg3;
12807 }
12808 {
12809 if (temp4)
12810 delete arg4;
12811 }
12812 return NULL;
12813 }
12814
12815
12816 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12817 PyObject *resultobj = 0;
12818 wxFSFile *arg1 = (wxFSFile *) 0 ;
12819 void *argp1 = 0 ;
12820 int res1 = 0 ;
12821 PyObject *swig_obj[1] ;
12822
12823 if (!args) SWIG_fail;
12824 swig_obj[0] = args;
12825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12826 if (!SWIG_IsOK(res1)) {
12827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12828 }
12829 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12830 {
12831 PyThreadState* __tstate = wxPyBeginAllowThreads();
12832 delete arg1;
12833
12834 wxPyEndAllowThreads(__tstate);
12835 if (PyErr_Occurred()) SWIG_fail;
12836 }
12837 resultobj = SWIG_Py_Void();
12838 return resultobj;
12839 fail:
12840 return NULL;
12841 }
12842
12843
12844 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12845 PyObject *resultobj = 0;
12846 wxFSFile *arg1 = (wxFSFile *) 0 ;
12847 wxInputStream *result = 0 ;
12848 void *argp1 = 0 ;
12849 int res1 = 0 ;
12850 PyObject *swig_obj[1] ;
12851
12852 if (!args) SWIG_fail;
12853 swig_obj[0] = args;
12854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12855 if (!SWIG_IsOK(res1)) {
12856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12857 }
12858 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12859 {
12860 PyThreadState* __tstate = wxPyBeginAllowThreads();
12861 result = (wxInputStream *)(arg1)->GetStream();
12862 wxPyEndAllowThreads(__tstate);
12863 if (PyErr_Occurred()) SWIG_fail;
12864 }
12865 {
12866 wxPyInputStream * _ptr = NULL;
12867
12868 if (result) {
12869 _ptr = new wxPyInputStream(result);
12870 }
12871 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12872 }
12873 return resultobj;
12874 fail:
12875 return NULL;
12876 }
12877
12878
12879 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12880 PyObject *resultobj = 0;
12881 wxFSFile *arg1 = (wxFSFile *) 0 ;
12882 void *argp1 = 0 ;
12883 int res1 = 0 ;
12884 PyObject *swig_obj[1] ;
12885
12886 if (!args) SWIG_fail;
12887 swig_obj[0] = args;
12888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12889 if (!SWIG_IsOK(res1)) {
12890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12891 }
12892 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12893 {
12894 PyThreadState* __tstate = wxPyBeginAllowThreads();
12895 (arg1)->DetachStream();
12896 wxPyEndAllowThreads(__tstate);
12897 if (PyErr_Occurred()) SWIG_fail;
12898 }
12899 resultobj = SWIG_Py_Void();
12900 return resultobj;
12901 fail:
12902 return NULL;
12903 }
12904
12905
12906 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12907 PyObject *resultobj = 0;
12908 wxFSFile *arg1 = (wxFSFile *) 0 ;
12909 wxString *result = 0 ;
12910 void *argp1 = 0 ;
12911 int res1 = 0 ;
12912 PyObject *swig_obj[1] ;
12913
12914 if (!args) SWIG_fail;
12915 swig_obj[0] = args;
12916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12917 if (!SWIG_IsOK(res1)) {
12918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12919 }
12920 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12921 {
12922 PyThreadState* __tstate = wxPyBeginAllowThreads();
12923 {
12924 wxString const &_result_ref = (arg1)->GetMimeType();
12925 result = (wxString *) &_result_ref;
12926 }
12927 wxPyEndAllowThreads(__tstate);
12928 if (PyErr_Occurred()) SWIG_fail;
12929 }
12930 {
12931 #if wxUSE_UNICODE
12932 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12933 #else
12934 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12935 #endif
12936 }
12937 return resultobj;
12938 fail:
12939 return NULL;
12940 }
12941
12942
12943 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12944 PyObject *resultobj = 0;
12945 wxFSFile *arg1 = (wxFSFile *) 0 ;
12946 wxString *result = 0 ;
12947 void *argp1 = 0 ;
12948 int res1 = 0 ;
12949 PyObject *swig_obj[1] ;
12950
12951 if (!args) SWIG_fail;
12952 swig_obj[0] = args;
12953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12954 if (!SWIG_IsOK(res1)) {
12955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12956 }
12957 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12958 {
12959 PyThreadState* __tstate = wxPyBeginAllowThreads();
12960 {
12961 wxString const &_result_ref = (arg1)->GetLocation();
12962 result = (wxString *) &_result_ref;
12963 }
12964 wxPyEndAllowThreads(__tstate);
12965 if (PyErr_Occurred()) SWIG_fail;
12966 }
12967 {
12968 #if wxUSE_UNICODE
12969 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12970 #else
12971 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12972 #endif
12973 }
12974 return resultobj;
12975 fail:
12976 return NULL;
12977 }
12978
12979
12980 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12981 PyObject *resultobj = 0;
12982 wxFSFile *arg1 = (wxFSFile *) 0 ;
12983 wxString *result = 0 ;
12984 void *argp1 = 0 ;
12985 int res1 = 0 ;
12986 PyObject *swig_obj[1] ;
12987
12988 if (!args) SWIG_fail;
12989 swig_obj[0] = args;
12990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12991 if (!SWIG_IsOK(res1)) {
12992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12993 }
12994 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12995 {
12996 PyThreadState* __tstate = wxPyBeginAllowThreads();
12997 {
12998 wxString const &_result_ref = (arg1)->GetAnchor();
12999 result = (wxString *) &_result_ref;
13000 }
13001 wxPyEndAllowThreads(__tstate);
13002 if (PyErr_Occurred()) SWIG_fail;
13003 }
13004 {
13005 #if wxUSE_UNICODE
13006 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13007 #else
13008 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13009 #endif
13010 }
13011 return resultobj;
13012 fail:
13013 return NULL;
13014 }
13015
13016
13017 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13018 PyObject *resultobj = 0;
13019 wxFSFile *arg1 = (wxFSFile *) 0 ;
13020 wxDateTime result;
13021 void *argp1 = 0 ;
13022 int res1 = 0 ;
13023 PyObject *swig_obj[1] ;
13024
13025 if (!args) SWIG_fail;
13026 swig_obj[0] = args;
13027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
13028 if (!SWIG_IsOK(res1)) {
13029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
13030 }
13031 arg1 = reinterpret_cast< wxFSFile * >(argp1);
13032 {
13033 PyThreadState* __tstate = wxPyBeginAllowThreads();
13034 result = (arg1)->GetModificationTime();
13035 wxPyEndAllowThreads(__tstate);
13036 if (PyErr_Occurred()) SWIG_fail;
13037 }
13038 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
13039 return resultobj;
13040 fail:
13041 return NULL;
13042 }
13043
13044
13045 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13046 PyObject *obj;
13047 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13048 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
13049 return SWIG_Py_Void();
13050 }
13051
13052 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13053 return SWIG_Python_InitShadowInstance(args);
13054 }
13055
13056 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13057 PyObject *resultobj = 0;
13058 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13059 void *argp1 = 0 ;
13060 int res1 = 0 ;
13061 PyObject *swig_obj[1] ;
13062
13063 if (!args) SWIG_fail;
13064 swig_obj[0] = args;
13065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13066 if (!SWIG_IsOK(res1)) {
13067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13068 }
13069 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13070 {
13071 PyThreadState* __tstate = wxPyBeginAllowThreads();
13072 delete arg1;
13073
13074 wxPyEndAllowThreads(__tstate);
13075 if (PyErr_Occurred()) SWIG_fail;
13076 }
13077 resultobj = SWIG_Py_Void();
13078 return resultobj;
13079 fail:
13080 return NULL;
13081 }
13082
13083
13084 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13085 PyObject *obj;
13086 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13087 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
13088 return SWIG_Py_Void();
13089 }
13090
13091 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13092 PyObject *resultobj = 0;
13093 wxPyFileSystemHandler *result = 0 ;
13094
13095 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
13096 {
13097 PyThreadState* __tstate = wxPyBeginAllowThreads();
13098 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
13099 wxPyEndAllowThreads(__tstate);
13100 if (PyErr_Occurred()) SWIG_fail;
13101 }
13102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
13103 return resultobj;
13104 fail:
13105 return NULL;
13106 }
13107
13108
13109 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13110 PyObject *resultobj = 0;
13111 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13112 PyObject *arg2 = (PyObject *) 0 ;
13113 PyObject *arg3 = (PyObject *) 0 ;
13114 void *argp1 = 0 ;
13115 int res1 = 0 ;
13116 PyObject * obj0 = 0 ;
13117 PyObject * obj1 = 0 ;
13118 PyObject * obj2 = 0 ;
13119 char * kwnames[] = {
13120 (char *) "self",(char *) "self",(char *) "_class", NULL
13121 };
13122
13123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13125 if (!SWIG_IsOK(res1)) {
13126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13127 }
13128 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13129 arg2 = obj1;
13130 arg3 = obj2;
13131 {
13132 PyThreadState* __tstate = wxPyBeginAllowThreads();
13133 (arg1)->_setCallbackInfo(arg2,arg3);
13134 wxPyEndAllowThreads(__tstate);
13135 if (PyErr_Occurred()) SWIG_fail;
13136 }
13137 resultobj = SWIG_Py_Void();
13138 return resultobj;
13139 fail:
13140 return NULL;
13141 }
13142
13143
13144 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13145 PyObject *resultobj = 0;
13146 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13147 wxString *arg2 = 0 ;
13148 bool result;
13149 void *argp1 = 0 ;
13150 int res1 = 0 ;
13151 bool temp2 = false ;
13152 PyObject * obj0 = 0 ;
13153 PyObject * obj1 = 0 ;
13154 char * kwnames[] = {
13155 (char *) "self",(char *) "location", NULL
13156 };
13157
13158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13160 if (!SWIG_IsOK(res1)) {
13161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13162 }
13163 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13164 {
13165 arg2 = wxString_in_helper(obj1);
13166 if (arg2 == NULL) SWIG_fail;
13167 temp2 = true;
13168 }
13169 {
13170 PyThreadState* __tstate = wxPyBeginAllowThreads();
13171 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13172 wxPyEndAllowThreads(__tstate);
13173 if (PyErr_Occurred()) SWIG_fail;
13174 }
13175 {
13176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13177 }
13178 {
13179 if (temp2)
13180 delete arg2;
13181 }
13182 return resultobj;
13183 fail:
13184 {
13185 if (temp2)
13186 delete arg2;
13187 }
13188 return NULL;
13189 }
13190
13191
13192 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13193 PyObject *resultobj = 0;
13194 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13195 wxFileSystem *arg2 = 0 ;
13196 wxString *arg3 = 0 ;
13197 wxFSFile *result = 0 ;
13198 void *argp1 = 0 ;
13199 int res1 = 0 ;
13200 void *argp2 = 0 ;
13201 int res2 = 0 ;
13202 bool temp3 = false ;
13203 PyObject * obj0 = 0 ;
13204 PyObject * obj1 = 0 ;
13205 PyObject * obj2 = 0 ;
13206 char * kwnames[] = {
13207 (char *) "self",(char *) "fs",(char *) "location", NULL
13208 };
13209
13210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13212 if (!SWIG_IsOK(res1)) {
13213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13214 }
13215 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13216 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13217 if (!SWIG_IsOK(res2)) {
13218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13219 }
13220 if (!argp2) {
13221 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13222 }
13223 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13224 {
13225 arg3 = wxString_in_helper(obj2);
13226 if (arg3 == NULL) SWIG_fail;
13227 temp3 = true;
13228 }
13229 {
13230 PyThreadState* __tstate = wxPyBeginAllowThreads();
13231 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13232 wxPyEndAllowThreads(__tstate);
13233 if (PyErr_Occurred()) SWIG_fail;
13234 }
13235 {
13236 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13237 }
13238 {
13239 if (temp3)
13240 delete arg3;
13241 }
13242 return resultobj;
13243 fail:
13244 {
13245 if (temp3)
13246 delete arg3;
13247 }
13248 return NULL;
13249 }
13250
13251
13252 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13253 PyObject *resultobj = 0;
13254 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13255 wxString *arg2 = 0 ;
13256 int arg3 = (int) 0 ;
13257 wxString result;
13258 void *argp1 = 0 ;
13259 int res1 = 0 ;
13260 bool temp2 = false ;
13261 int val3 ;
13262 int ecode3 = 0 ;
13263 PyObject * obj0 = 0 ;
13264 PyObject * obj1 = 0 ;
13265 PyObject * obj2 = 0 ;
13266 char * kwnames[] = {
13267 (char *) "self",(char *) "spec",(char *) "flags", NULL
13268 };
13269
13270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13272 if (!SWIG_IsOK(res1)) {
13273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13274 }
13275 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13276 {
13277 arg2 = wxString_in_helper(obj1);
13278 if (arg2 == NULL) SWIG_fail;
13279 temp2 = true;
13280 }
13281 if (obj2) {
13282 ecode3 = SWIG_AsVal_int(obj2, &val3);
13283 if (!SWIG_IsOK(ecode3)) {
13284 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13285 }
13286 arg3 = static_cast< int >(val3);
13287 }
13288 {
13289 PyThreadState* __tstate = wxPyBeginAllowThreads();
13290 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13291 wxPyEndAllowThreads(__tstate);
13292 if (PyErr_Occurred()) SWIG_fail;
13293 }
13294 {
13295 #if wxUSE_UNICODE
13296 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13297 #else
13298 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13299 #endif
13300 }
13301 {
13302 if (temp2)
13303 delete arg2;
13304 }
13305 return resultobj;
13306 fail:
13307 {
13308 if (temp2)
13309 delete arg2;
13310 }
13311 return NULL;
13312 }
13313
13314
13315 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13316 PyObject *resultobj = 0;
13317 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13318 wxString result;
13319 void *argp1 = 0 ;
13320 int res1 = 0 ;
13321 PyObject *swig_obj[1] ;
13322
13323 if (!args) SWIG_fail;
13324 swig_obj[0] = args;
13325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13326 if (!SWIG_IsOK(res1)) {
13327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13328 }
13329 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13330 {
13331 PyThreadState* __tstate = wxPyBeginAllowThreads();
13332 result = (arg1)->FindNext();
13333 wxPyEndAllowThreads(__tstate);
13334 if (PyErr_Occurred()) SWIG_fail;
13335 }
13336 {
13337 #if wxUSE_UNICODE
13338 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13339 #else
13340 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13341 #endif
13342 }
13343 return resultobj;
13344 fail:
13345 return NULL;
13346 }
13347
13348
13349 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13350 PyObject *resultobj = 0;
13351 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13352 wxString *arg2 = 0 ;
13353 wxString result;
13354 void *argp1 = 0 ;
13355 int res1 = 0 ;
13356 bool temp2 = false ;
13357 PyObject * obj0 = 0 ;
13358 PyObject * obj1 = 0 ;
13359 char * kwnames[] = {
13360 (char *) "self",(char *) "location", NULL
13361 };
13362
13363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
13364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13365 if (!SWIG_IsOK(res1)) {
13366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13367 }
13368 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13369 {
13370 arg2 = wxString_in_helper(obj1);
13371 if (arg2 == NULL) SWIG_fail;
13372 temp2 = true;
13373 }
13374 {
13375 PyThreadState* __tstate = wxPyBeginAllowThreads();
13376 result = (arg1)->GetProtocol((wxString const &)*arg2);
13377 wxPyEndAllowThreads(__tstate);
13378 if (PyErr_Occurred()) SWIG_fail;
13379 }
13380 {
13381 #if wxUSE_UNICODE
13382 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13383 #else
13384 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13385 #endif
13386 }
13387 {
13388 if (temp2)
13389 delete arg2;
13390 }
13391 return resultobj;
13392 fail:
13393 {
13394 if (temp2)
13395 delete arg2;
13396 }
13397 return NULL;
13398 }
13399
13400
13401 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13402 PyObject *resultobj = 0;
13403 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13404 wxString *arg2 = 0 ;
13405 wxString result;
13406 void *argp1 = 0 ;
13407 int res1 = 0 ;
13408 bool temp2 = false ;
13409 PyObject * obj0 = 0 ;
13410 PyObject * obj1 = 0 ;
13411 char * kwnames[] = {
13412 (char *) "self",(char *) "location", NULL
13413 };
13414
13415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
13416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13417 if (!SWIG_IsOK(res1)) {
13418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13419 }
13420 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13421 {
13422 arg2 = wxString_in_helper(obj1);
13423 if (arg2 == NULL) SWIG_fail;
13424 temp2 = true;
13425 }
13426 {
13427 PyThreadState* __tstate = wxPyBeginAllowThreads();
13428 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
13429 wxPyEndAllowThreads(__tstate);
13430 if (PyErr_Occurred()) SWIG_fail;
13431 }
13432 {
13433 #if wxUSE_UNICODE
13434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13435 #else
13436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13437 #endif
13438 }
13439 {
13440 if (temp2)
13441 delete arg2;
13442 }
13443 return resultobj;
13444 fail:
13445 {
13446 if (temp2)
13447 delete arg2;
13448 }
13449 return NULL;
13450 }
13451
13452
13453 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13454 PyObject *resultobj = 0;
13455 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13456 wxString *arg2 = 0 ;
13457 wxString result;
13458 void *argp1 = 0 ;
13459 int res1 = 0 ;
13460 bool temp2 = false ;
13461 PyObject * obj0 = 0 ;
13462 PyObject * obj1 = 0 ;
13463 char * kwnames[] = {
13464 (char *) "self",(char *) "location", NULL
13465 };
13466
13467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
13468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13469 if (!SWIG_IsOK(res1)) {
13470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13471 }
13472 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13473 {
13474 arg2 = wxString_in_helper(obj1);
13475 if (arg2 == NULL) SWIG_fail;
13476 temp2 = true;
13477 }
13478 {
13479 PyThreadState* __tstate = wxPyBeginAllowThreads();
13480 result = (arg1)->GetAnchor((wxString const &)*arg2);
13481 wxPyEndAllowThreads(__tstate);
13482 if (PyErr_Occurred()) SWIG_fail;
13483 }
13484 {
13485 #if wxUSE_UNICODE
13486 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13487 #else
13488 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13489 #endif
13490 }
13491 {
13492 if (temp2)
13493 delete arg2;
13494 }
13495 return resultobj;
13496 fail:
13497 {
13498 if (temp2)
13499 delete arg2;
13500 }
13501 return NULL;
13502 }
13503
13504
13505 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13506 PyObject *resultobj = 0;
13507 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13508 wxString *arg2 = 0 ;
13509 wxString result;
13510 void *argp1 = 0 ;
13511 int res1 = 0 ;
13512 bool temp2 = false ;
13513 PyObject * obj0 = 0 ;
13514 PyObject * obj1 = 0 ;
13515 char * kwnames[] = {
13516 (char *) "self",(char *) "location", NULL
13517 };
13518
13519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
13520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13521 if (!SWIG_IsOK(res1)) {
13522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13523 }
13524 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13525 {
13526 arg2 = wxString_in_helper(obj1);
13527 if (arg2 == NULL) SWIG_fail;
13528 temp2 = true;
13529 }
13530 {
13531 PyThreadState* __tstate = wxPyBeginAllowThreads();
13532 result = (arg1)->GetRightLocation((wxString const &)*arg2);
13533 wxPyEndAllowThreads(__tstate);
13534 if (PyErr_Occurred()) SWIG_fail;
13535 }
13536 {
13537 #if wxUSE_UNICODE
13538 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13539 #else
13540 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13541 #endif
13542 }
13543 {
13544 if (temp2)
13545 delete arg2;
13546 }
13547 return resultobj;
13548 fail:
13549 {
13550 if (temp2)
13551 delete arg2;
13552 }
13553 return NULL;
13554 }
13555
13556
13557 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13558 PyObject *resultobj = 0;
13559 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13560 wxString *arg2 = 0 ;
13561 wxString result;
13562 void *argp1 = 0 ;
13563 int res1 = 0 ;
13564 bool temp2 = false ;
13565 PyObject * obj0 = 0 ;
13566 PyObject * obj1 = 0 ;
13567 char * kwnames[] = {
13568 (char *) "self",(char *) "location", NULL
13569 };
13570
13571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
13572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13573 if (!SWIG_IsOK(res1)) {
13574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13575 }
13576 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13577 {
13578 arg2 = wxString_in_helper(obj1);
13579 if (arg2 == NULL) SWIG_fail;
13580 temp2 = true;
13581 }
13582 {
13583 PyThreadState* __tstate = wxPyBeginAllowThreads();
13584 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
13585 wxPyEndAllowThreads(__tstate);
13586 if (PyErr_Occurred()) SWIG_fail;
13587 }
13588 {
13589 #if wxUSE_UNICODE
13590 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13591 #else
13592 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13593 #endif
13594 }
13595 {
13596 if (temp2)
13597 delete arg2;
13598 }
13599 return resultobj;
13600 fail:
13601 {
13602 if (temp2)
13603 delete arg2;
13604 }
13605 return NULL;
13606 }
13607
13608
13609 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13610 PyObject *obj;
13611 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13612 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13613 return SWIG_Py_Void();
13614 }
13615
13616 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13617 return SWIG_Python_InitShadowInstance(args);
13618 }
13619
13620 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13621 PyObject *resultobj = 0;
13622 wxFileSystem *result = 0 ;
13623
13624 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13625 {
13626 PyThreadState* __tstate = wxPyBeginAllowThreads();
13627 result = (wxFileSystem *)new wxFileSystem();
13628 wxPyEndAllowThreads(__tstate);
13629 if (PyErr_Occurred()) SWIG_fail;
13630 }
13631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13632 return resultobj;
13633 fail:
13634 return NULL;
13635 }
13636
13637
13638 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13639 PyObject *resultobj = 0;
13640 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13641 void *argp1 = 0 ;
13642 int res1 = 0 ;
13643 PyObject *swig_obj[1] ;
13644
13645 if (!args) SWIG_fail;
13646 swig_obj[0] = args;
13647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13648 if (!SWIG_IsOK(res1)) {
13649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13650 }
13651 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13652 {
13653 PyThreadState* __tstate = wxPyBeginAllowThreads();
13654 delete arg1;
13655
13656 wxPyEndAllowThreads(__tstate);
13657 if (PyErr_Occurred()) SWIG_fail;
13658 }
13659 resultobj = SWIG_Py_Void();
13660 return resultobj;
13661 fail:
13662 return NULL;
13663 }
13664
13665
13666 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13667 PyObject *resultobj = 0;
13668 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13669 wxString *arg2 = 0 ;
13670 bool arg3 = (bool) false ;
13671 void *argp1 = 0 ;
13672 int res1 = 0 ;
13673 bool temp2 = false ;
13674 bool val3 ;
13675 int ecode3 = 0 ;
13676 PyObject * obj0 = 0 ;
13677 PyObject * obj1 = 0 ;
13678 PyObject * obj2 = 0 ;
13679 char * kwnames[] = {
13680 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13681 };
13682
13683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13685 if (!SWIG_IsOK(res1)) {
13686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13687 }
13688 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13689 {
13690 arg2 = wxString_in_helper(obj1);
13691 if (arg2 == NULL) SWIG_fail;
13692 temp2 = true;
13693 }
13694 if (obj2) {
13695 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13696 if (!SWIG_IsOK(ecode3)) {
13697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13698 }
13699 arg3 = static_cast< bool >(val3);
13700 }
13701 {
13702 PyThreadState* __tstate = wxPyBeginAllowThreads();
13703 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13704 wxPyEndAllowThreads(__tstate);
13705 if (PyErr_Occurred()) SWIG_fail;
13706 }
13707 resultobj = SWIG_Py_Void();
13708 {
13709 if (temp2)
13710 delete arg2;
13711 }
13712 return resultobj;
13713 fail:
13714 {
13715 if (temp2)
13716 delete arg2;
13717 }
13718 return NULL;
13719 }
13720
13721
13722 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13723 PyObject *resultobj = 0;
13724 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13725 wxString result;
13726 void *argp1 = 0 ;
13727 int res1 = 0 ;
13728 PyObject *swig_obj[1] ;
13729
13730 if (!args) SWIG_fail;
13731 swig_obj[0] = args;
13732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13733 if (!SWIG_IsOK(res1)) {
13734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13735 }
13736 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13737 {
13738 PyThreadState* __tstate = wxPyBeginAllowThreads();
13739 result = (arg1)->GetPath();
13740 wxPyEndAllowThreads(__tstate);
13741 if (PyErr_Occurred()) SWIG_fail;
13742 }
13743 {
13744 #if wxUSE_UNICODE
13745 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13746 #else
13747 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13748 #endif
13749 }
13750 return resultobj;
13751 fail:
13752 return NULL;
13753 }
13754
13755
13756 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13757 PyObject *resultobj = 0;
13758 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13759 wxString *arg2 = 0 ;
13760 wxFSFile *result = 0 ;
13761 void *argp1 = 0 ;
13762 int res1 = 0 ;
13763 bool temp2 = false ;
13764 PyObject * obj0 = 0 ;
13765 PyObject * obj1 = 0 ;
13766 char * kwnames[] = {
13767 (char *) "self",(char *) "location", NULL
13768 };
13769
13770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13772 if (!SWIG_IsOK(res1)) {
13773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13774 }
13775 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13776 {
13777 arg2 = wxString_in_helper(obj1);
13778 if (arg2 == NULL) SWIG_fail;
13779 temp2 = true;
13780 }
13781 {
13782 PyThreadState* __tstate = wxPyBeginAllowThreads();
13783 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13784 wxPyEndAllowThreads(__tstate);
13785 if (PyErr_Occurred()) SWIG_fail;
13786 }
13787 {
13788 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13789 }
13790 {
13791 if (temp2)
13792 delete arg2;
13793 }
13794 return resultobj;
13795 fail:
13796 {
13797 if (temp2)
13798 delete arg2;
13799 }
13800 return NULL;
13801 }
13802
13803
13804 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13805 PyObject *resultobj = 0;
13806 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13807 wxString *arg2 = 0 ;
13808 int arg3 = (int) 0 ;
13809 wxString result;
13810 void *argp1 = 0 ;
13811 int res1 = 0 ;
13812 bool temp2 = false ;
13813 int val3 ;
13814 int ecode3 = 0 ;
13815 PyObject * obj0 = 0 ;
13816 PyObject * obj1 = 0 ;
13817 PyObject * obj2 = 0 ;
13818 char * kwnames[] = {
13819 (char *) "self",(char *) "spec",(char *) "flags", NULL
13820 };
13821
13822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13824 if (!SWIG_IsOK(res1)) {
13825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13826 }
13827 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13828 {
13829 arg2 = wxString_in_helper(obj1);
13830 if (arg2 == NULL) SWIG_fail;
13831 temp2 = true;
13832 }
13833 if (obj2) {
13834 ecode3 = SWIG_AsVal_int(obj2, &val3);
13835 if (!SWIG_IsOK(ecode3)) {
13836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13837 }
13838 arg3 = static_cast< int >(val3);
13839 }
13840 {
13841 PyThreadState* __tstate = wxPyBeginAllowThreads();
13842 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13843 wxPyEndAllowThreads(__tstate);
13844 if (PyErr_Occurred()) SWIG_fail;
13845 }
13846 {
13847 #if wxUSE_UNICODE
13848 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13849 #else
13850 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13851 #endif
13852 }
13853 {
13854 if (temp2)
13855 delete arg2;
13856 }
13857 return resultobj;
13858 fail:
13859 {
13860 if (temp2)
13861 delete arg2;
13862 }
13863 return NULL;
13864 }
13865
13866
13867 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13868 PyObject *resultobj = 0;
13869 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13870 wxString result;
13871 void *argp1 = 0 ;
13872 int res1 = 0 ;
13873 PyObject *swig_obj[1] ;
13874
13875 if (!args) SWIG_fail;
13876 swig_obj[0] = args;
13877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13878 if (!SWIG_IsOK(res1)) {
13879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13880 }
13881 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13882 {
13883 PyThreadState* __tstate = wxPyBeginAllowThreads();
13884 result = (arg1)->FindNext();
13885 wxPyEndAllowThreads(__tstate);
13886 if (PyErr_Occurred()) SWIG_fail;
13887 }
13888 {
13889 #if wxUSE_UNICODE
13890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13891 #else
13892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13893 #endif
13894 }
13895 return resultobj;
13896 fail:
13897 return NULL;
13898 }
13899
13900
13901 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13902 PyObject *resultobj = 0;
13903 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13904 int res1 = 0 ;
13905 PyObject * obj0 = 0 ;
13906 char * kwnames[] = {
13907 (char *) "handler", NULL
13908 };
13909
13910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13911 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13912 if (!SWIG_IsOK(res1)) {
13913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13914 }
13915 {
13916 PyThreadState* __tstate = wxPyBeginAllowThreads();
13917 wxFileSystem::AddHandler(arg1);
13918 wxPyEndAllowThreads(__tstate);
13919 if (PyErr_Occurred()) SWIG_fail;
13920 }
13921 resultobj = SWIG_Py_Void();
13922 return resultobj;
13923 fail:
13924 return NULL;
13925 }
13926
13927
13928 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13929 PyObject *resultobj = 0;
13930 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13931 wxFileSystemHandler *result = 0 ;
13932 void *argp1 = 0 ;
13933 int res1 = 0 ;
13934 PyObject * obj0 = 0 ;
13935 char * kwnames[] = {
13936 (char *) "handler", NULL
13937 };
13938
13939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13941 if (!SWIG_IsOK(res1)) {
13942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13943 }
13944 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13945 {
13946 PyThreadState* __tstate = wxPyBeginAllowThreads();
13947 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13948 wxPyEndAllowThreads(__tstate);
13949 if (PyErr_Occurred()) SWIG_fail;
13950 }
13951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13952 return resultobj;
13953 fail:
13954 return NULL;
13955 }
13956
13957
13958 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13959 PyObject *resultobj = 0;
13960
13961 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13962 {
13963 PyThreadState* __tstate = wxPyBeginAllowThreads();
13964 wxFileSystem::CleanUpHandlers();
13965 wxPyEndAllowThreads(__tstate);
13966 if (PyErr_Occurred()) SWIG_fail;
13967 }
13968 resultobj = SWIG_Py_Void();
13969 return resultobj;
13970 fail:
13971 return NULL;
13972 }
13973
13974
13975 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13976 PyObject *resultobj = 0;
13977 wxString *arg1 = 0 ;
13978 wxString result;
13979 bool temp1 = false ;
13980 PyObject * obj0 = 0 ;
13981 char * kwnames[] = {
13982 (char *) "filename", NULL
13983 };
13984
13985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13986 {
13987 arg1 = wxString_in_helper(obj0);
13988 if (arg1 == NULL) SWIG_fail;
13989 temp1 = true;
13990 }
13991 {
13992 PyThreadState* __tstate = wxPyBeginAllowThreads();
13993 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13994 wxPyEndAllowThreads(__tstate);
13995 if (PyErr_Occurred()) SWIG_fail;
13996 }
13997 {
13998 #if wxUSE_UNICODE
13999 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14000 #else
14001 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14002 #endif
14003 }
14004 {
14005 if (temp1)
14006 delete arg1;
14007 }
14008 return resultobj;
14009 fail:
14010 {
14011 if (temp1)
14012 delete arg1;
14013 }
14014 return NULL;
14015 }
14016
14017
14018 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14019 PyObject *resultobj = 0;
14020 wxString *arg1 = 0 ;
14021 wxString result;
14022 bool temp1 = false ;
14023 PyObject * obj0 = 0 ;
14024 char * kwnames[] = {
14025 (char *) "url", NULL
14026 };
14027
14028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
14029 {
14030 arg1 = wxString_in_helper(obj0);
14031 if (arg1 == NULL) SWIG_fail;
14032 temp1 = true;
14033 }
14034 {
14035 PyThreadState* __tstate = wxPyBeginAllowThreads();
14036 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
14037 wxPyEndAllowThreads(__tstate);
14038 if (PyErr_Occurred()) SWIG_fail;
14039 }
14040 {
14041 #if wxUSE_UNICODE
14042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14043 #else
14044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14045 #endif
14046 }
14047 {
14048 if (temp1)
14049 delete arg1;
14050 }
14051 return resultobj;
14052 fail:
14053 {
14054 if (temp1)
14055 delete arg1;
14056 }
14057 return NULL;
14058 }
14059
14060
14061 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14062 PyObject *obj;
14063 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14064 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
14065 return SWIG_Py_Void();
14066 }
14067
14068 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14069 return SWIG_Python_InitShadowInstance(args);
14070 }
14071
14072 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14073 PyObject *resultobj = 0;
14074 wxInternetFSHandler *result = 0 ;
14075
14076 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
14077 {
14078 PyThreadState* __tstate = wxPyBeginAllowThreads();
14079 result = (wxInternetFSHandler *)new wxInternetFSHandler();
14080 wxPyEndAllowThreads(__tstate);
14081 if (PyErr_Occurred()) SWIG_fail;
14082 }
14083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
14084 return resultobj;
14085 fail:
14086 return NULL;
14087 }
14088
14089
14090 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14091 PyObject *resultobj = 0;
14092 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
14093 wxString *arg2 = 0 ;
14094 bool result;
14095 void *argp1 = 0 ;
14096 int res1 = 0 ;
14097 bool temp2 = false ;
14098 PyObject * obj0 = 0 ;
14099 PyObject * obj1 = 0 ;
14100 char * kwnames[] = {
14101 (char *) "self",(char *) "location", NULL
14102 };
14103
14104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
14106 if (!SWIG_IsOK(res1)) {
14107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
14108 }
14109 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
14110 {
14111 arg2 = wxString_in_helper(obj1);
14112 if (arg2 == NULL) SWIG_fail;
14113 temp2 = true;
14114 }
14115 {
14116 PyThreadState* __tstate = wxPyBeginAllowThreads();
14117 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14118 wxPyEndAllowThreads(__tstate);
14119 if (PyErr_Occurred()) SWIG_fail;
14120 }
14121 {
14122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14123 }
14124 {
14125 if (temp2)
14126 delete arg2;
14127 }
14128 return resultobj;
14129 fail:
14130 {
14131 if (temp2)
14132 delete arg2;
14133 }
14134 return NULL;
14135 }
14136
14137
14138 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14139 PyObject *resultobj = 0;
14140 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
14141 wxFileSystem *arg2 = 0 ;
14142 wxString *arg3 = 0 ;
14143 wxFSFile *result = 0 ;
14144 void *argp1 = 0 ;
14145 int res1 = 0 ;
14146 void *argp2 = 0 ;
14147 int res2 = 0 ;
14148 bool temp3 = false ;
14149 PyObject * obj0 = 0 ;
14150 PyObject * obj1 = 0 ;
14151 PyObject * obj2 = 0 ;
14152 char * kwnames[] = {
14153 (char *) "self",(char *) "fs",(char *) "location", NULL
14154 };
14155
14156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
14158 if (!SWIG_IsOK(res1)) {
14159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
14160 }
14161 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
14162 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14163 if (!SWIG_IsOK(res2)) {
14164 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14165 }
14166 if (!argp2) {
14167 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14168 }
14169 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14170 {
14171 arg3 = wxString_in_helper(obj2);
14172 if (arg3 == NULL) SWIG_fail;
14173 temp3 = true;
14174 }
14175 {
14176 PyThreadState* __tstate = wxPyBeginAllowThreads();
14177 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14178 wxPyEndAllowThreads(__tstate);
14179 if (PyErr_Occurred()) SWIG_fail;
14180 }
14181 {
14182 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14183 }
14184 {
14185 if (temp3)
14186 delete arg3;
14187 }
14188 return resultobj;
14189 fail:
14190 {
14191 if (temp3)
14192 delete arg3;
14193 }
14194 return NULL;
14195 }
14196
14197
14198 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14199 PyObject *obj;
14200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14201 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
14202 return SWIG_Py_Void();
14203 }
14204
14205 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14206 return SWIG_Python_InitShadowInstance(args);
14207 }
14208
14209 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14210 PyObject *resultobj = 0;
14211 wxZipFSHandler *result = 0 ;
14212
14213 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
14214 {
14215 PyThreadState* __tstate = wxPyBeginAllowThreads();
14216 result = (wxZipFSHandler *)new wxZipFSHandler();
14217 wxPyEndAllowThreads(__tstate);
14218 if (PyErr_Occurred()) SWIG_fail;
14219 }
14220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
14221 return resultobj;
14222 fail:
14223 return NULL;
14224 }
14225
14226
14227 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14228 PyObject *resultobj = 0;
14229 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14230 wxString *arg2 = 0 ;
14231 bool result;
14232 void *argp1 = 0 ;
14233 int res1 = 0 ;
14234 bool temp2 = false ;
14235 PyObject * obj0 = 0 ;
14236 PyObject * obj1 = 0 ;
14237 char * kwnames[] = {
14238 (char *) "self",(char *) "location", NULL
14239 };
14240
14241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14243 if (!SWIG_IsOK(res1)) {
14244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14245 }
14246 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14247 {
14248 arg2 = wxString_in_helper(obj1);
14249 if (arg2 == NULL) SWIG_fail;
14250 temp2 = true;
14251 }
14252 {
14253 PyThreadState* __tstate = wxPyBeginAllowThreads();
14254 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14255 wxPyEndAllowThreads(__tstate);
14256 if (PyErr_Occurred()) SWIG_fail;
14257 }
14258 {
14259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14260 }
14261 {
14262 if (temp2)
14263 delete arg2;
14264 }
14265 return resultobj;
14266 fail:
14267 {
14268 if (temp2)
14269 delete arg2;
14270 }
14271 return NULL;
14272 }
14273
14274
14275 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14276 PyObject *resultobj = 0;
14277 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14278 wxFileSystem *arg2 = 0 ;
14279 wxString *arg3 = 0 ;
14280 wxFSFile *result = 0 ;
14281 void *argp1 = 0 ;
14282 int res1 = 0 ;
14283 void *argp2 = 0 ;
14284 int res2 = 0 ;
14285 bool temp3 = false ;
14286 PyObject * obj0 = 0 ;
14287 PyObject * obj1 = 0 ;
14288 PyObject * obj2 = 0 ;
14289 char * kwnames[] = {
14290 (char *) "self",(char *) "fs",(char *) "location", NULL
14291 };
14292
14293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14295 if (!SWIG_IsOK(res1)) {
14296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14297 }
14298 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14299 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14300 if (!SWIG_IsOK(res2)) {
14301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14302 }
14303 if (!argp2) {
14304 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14305 }
14306 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14307 {
14308 arg3 = wxString_in_helper(obj2);
14309 if (arg3 == NULL) SWIG_fail;
14310 temp3 = true;
14311 }
14312 {
14313 PyThreadState* __tstate = wxPyBeginAllowThreads();
14314 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14315 wxPyEndAllowThreads(__tstate);
14316 if (PyErr_Occurred()) SWIG_fail;
14317 }
14318 {
14319 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14320 }
14321 {
14322 if (temp3)
14323 delete arg3;
14324 }
14325 return resultobj;
14326 fail:
14327 {
14328 if (temp3)
14329 delete arg3;
14330 }
14331 return NULL;
14332 }
14333
14334
14335 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14336 PyObject *resultobj = 0;
14337 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14338 wxString *arg2 = 0 ;
14339 int arg3 = (int) 0 ;
14340 wxString result;
14341 void *argp1 = 0 ;
14342 int res1 = 0 ;
14343 bool temp2 = false ;
14344 int val3 ;
14345 int ecode3 = 0 ;
14346 PyObject * obj0 = 0 ;
14347 PyObject * obj1 = 0 ;
14348 PyObject * obj2 = 0 ;
14349 char * kwnames[] = {
14350 (char *) "self",(char *) "spec",(char *) "flags", NULL
14351 };
14352
14353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14355 if (!SWIG_IsOK(res1)) {
14356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14357 }
14358 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14359 {
14360 arg2 = wxString_in_helper(obj1);
14361 if (arg2 == NULL) SWIG_fail;
14362 temp2 = true;
14363 }
14364 if (obj2) {
14365 ecode3 = SWIG_AsVal_int(obj2, &val3);
14366 if (!SWIG_IsOK(ecode3)) {
14367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14368 }
14369 arg3 = static_cast< int >(val3);
14370 }
14371 {
14372 PyThreadState* __tstate = wxPyBeginAllowThreads();
14373 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14374 wxPyEndAllowThreads(__tstate);
14375 if (PyErr_Occurred()) SWIG_fail;
14376 }
14377 {
14378 #if wxUSE_UNICODE
14379 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14380 #else
14381 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14382 #endif
14383 }
14384 {
14385 if (temp2)
14386 delete arg2;
14387 }
14388 return resultobj;
14389 fail:
14390 {
14391 if (temp2)
14392 delete arg2;
14393 }
14394 return NULL;
14395 }
14396
14397
14398 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14399 PyObject *resultobj = 0;
14400 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14401 wxString result;
14402 void *argp1 = 0 ;
14403 int res1 = 0 ;
14404 PyObject *swig_obj[1] ;
14405
14406 if (!args) SWIG_fail;
14407 swig_obj[0] = args;
14408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14409 if (!SWIG_IsOK(res1)) {
14410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14411 }
14412 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14413 {
14414 PyThreadState* __tstate = wxPyBeginAllowThreads();
14415 result = (arg1)->FindNext();
14416 wxPyEndAllowThreads(__tstate);
14417 if (PyErr_Occurred()) SWIG_fail;
14418 }
14419 {
14420 #if wxUSE_UNICODE
14421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14422 #else
14423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14424 #endif
14425 }
14426 return resultobj;
14427 fail:
14428 return NULL;
14429 }
14430
14431
14432 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14433 PyObject *obj;
14434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14435 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
14436 return SWIG_Py_Void();
14437 }
14438
14439 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14440 return SWIG_Python_InitShadowInstance(args);
14441 }
14442
14443 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14444 PyObject *resultobj = 0;
14445 wxString *arg1 = 0 ;
14446 wxImage *arg2 = 0 ;
14447 long arg3 ;
14448 bool temp1 = false ;
14449 void *argp2 = 0 ;
14450 int res2 = 0 ;
14451 long val3 ;
14452 int ecode3 = 0 ;
14453 PyObject * obj0 = 0 ;
14454 PyObject * obj1 = 0 ;
14455 PyObject * obj2 = 0 ;
14456 char * kwnames[] = {
14457 (char *) "filename",(char *) "image",(char *) "type", NULL
14458 };
14459
14460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14461 {
14462 arg1 = wxString_in_helper(obj0);
14463 if (arg1 == NULL) SWIG_fail;
14464 temp1 = true;
14465 }
14466 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
14467 if (!SWIG_IsOK(res2)) {
14468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
14469 }
14470 if (!argp2) {
14471 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
14472 }
14473 arg2 = reinterpret_cast< wxImage * >(argp2);
14474 ecode3 = SWIG_AsVal_long(obj2, &val3);
14475 if (!SWIG_IsOK(ecode3)) {
14476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
14477 }
14478 arg3 = static_cast< long >(val3);
14479 {
14480 PyThreadState* __tstate = wxPyBeginAllowThreads();
14481 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
14482 wxPyEndAllowThreads(__tstate);
14483 if (PyErr_Occurred()) SWIG_fail;
14484 }
14485 resultobj = SWIG_Py_Void();
14486 {
14487 if (temp1)
14488 delete arg1;
14489 }
14490 return resultobj;
14491 fail:
14492 {
14493 if (temp1)
14494 delete arg1;
14495 }
14496 return NULL;
14497 }
14498
14499
14500 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14501 PyObject *resultobj = 0;
14502 wxString *arg1 = 0 ;
14503 wxBitmap *arg2 = 0 ;
14504 long arg3 ;
14505 bool temp1 = false ;
14506 void *argp2 = 0 ;
14507 int res2 = 0 ;
14508 long val3 ;
14509 int ecode3 = 0 ;
14510 PyObject * obj0 = 0 ;
14511 PyObject * obj1 = 0 ;
14512 PyObject * obj2 = 0 ;
14513 char * kwnames[] = {
14514 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
14515 };
14516
14517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14518 {
14519 arg1 = wxString_in_helper(obj0);
14520 if (arg1 == NULL) SWIG_fail;
14521 temp1 = true;
14522 }
14523 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
14524 if (!SWIG_IsOK(res2)) {
14525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
14526 }
14527 if (!argp2) {
14528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
14529 }
14530 arg2 = reinterpret_cast< wxBitmap * >(argp2);
14531 ecode3 = SWIG_AsVal_long(obj2, &val3);
14532 if (!SWIG_IsOK(ecode3)) {
14533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
14534 }
14535 arg3 = static_cast< long >(val3);
14536 {
14537 PyThreadState* __tstate = wxPyBeginAllowThreads();
14538 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
14539 wxPyEndAllowThreads(__tstate);
14540 if (PyErr_Occurred()) SWIG_fail;
14541 }
14542 resultobj = SWIG_Py_Void();
14543 {
14544 if (temp1)
14545 delete arg1;
14546 }
14547 return resultobj;
14548 fail:
14549 {
14550 if (temp1)
14551 delete arg1;
14552 }
14553 return NULL;
14554 }
14555
14556
14557 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14558 PyObject *resultobj = 0;
14559 wxString *arg1 = 0 ;
14560 PyObject *arg2 = (PyObject *) 0 ;
14561 bool temp1 = false ;
14562 PyObject * obj0 = 0 ;
14563 PyObject * obj1 = 0 ;
14564 char * kwnames[] = {
14565 (char *) "filename",(char *) "data", NULL
14566 };
14567
14568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
14569 {
14570 arg1 = wxString_in_helper(obj0);
14571 if (arg1 == NULL) SWIG_fail;
14572 temp1 = true;
14573 }
14574 arg2 = obj1;
14575 {
14576 PyThreadState* __tstate = wxPyBeginAllowThreads();
14577 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
14578 wxPyEndAllowThreads(__tstate);
14579 if (PyErr_Occurred()) SWIG_fail;
14580 }
14581 resultobj = SWIG_Py_Void();
14582 {
14583 if (temp1)
14584 delete arg1;
14585 }
14586 return resultobj;
14587 fail:
14588 {
14589 if (temp1)
14590 delete arg1;
14591 }
14592 return NULL;
14593 }
14594
14595
14596 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14597 PyObject *resultobj = 0;
14598 wxMemoryFSHandler *result = 0 ;
14599
14600 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
14601 {
14602 PyThreadState* __tstate = wxPyBeginAllowThreads();
14603 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
14604 wxPyEndAllowThreads(__tstate);
14605 if (PyErr_Occurred()) SWIG_fail;
14606 }
14607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
14608 return resultobj;
14609 fail:
14610 return NULL;
14611 }
14612
14613
14614 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14615 PyObject *resultobj = 0;
14616 wxString *arg1 = 0 ;
14617 bool temp1 = false ;
14618 PyObject * obj0 = 0 ;
14619 char * kwnames[] = {
14620 (char *) "filename", NULL
14621 };
14622
14623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14624 {
14625 arg1 = wxString_in_helper(obj0);
14626 if (arg1 == NULL) SWIG_fail;
14627 temp1 = true;
14628 }
14629 {
14630 PyThreadState* __tstate = wxPyBeginAllowThreads();
14631 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14632 wxPyEndAllowThreads(__tstate);
14633 if (PyErr_Occurred()) SWIG_fail;
14634 }
14635 resultobj = SWIG_Py_Void();
14636 {
14637 if (temp1)
14638 delete arg1;
14639 }
14640 return resultobj;
14641 fail:
14642 {
14643 if (temp1)
14644 delete arg1;
14645 }
14646 return NULL;
14647 }
14648
14649
14650 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14651 PyObject *resultobj = 0;
14652 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14653 wxString *arg2 = 0 ;
14654 bool result;
14655 void *argp1 = 0 ;
14656 int res1 = 0 ;
14657 bool temp2 = false ;
14658 PyObject * obj0 = 0 ;
14659 PyObject * obj1 = 0 ;
14660 char * kwnames[] = {
14661 (char *) "self",(char *) "location", NULL
14662 };
14663
14664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14666 if (!SWIG_IsOK(res1)) {
14667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14668 }
14669 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14670 {
14671 arg2 = wxString_in_helper(obj1);
14672 if (arg2 == NULL) SWIG_fail;
14673 temp2 = true;
14674 }
14675 {
14676 PyThreadState* __tstate = wxPyBeginAllowThreads();
14677 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14678 wxPyEndAllowThreads(__tstate);
14679 if (PyErr_Occurred()) SWIG_fail;
14680 }
14681 {
14682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14683 }
14684 {
14685 if (temp2)
14686 delete arg2;
14687 }
14688 return resultobj;
14689 fail:
14690 {
14691 if (temp2)
14692 delete arg2;
14693 }
14694 return NULL;
14695 }
14696
14697
14698 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14699 PyObject *resultobj = 0;
14700 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14701 wxFileSystem *arg2 = 0 ;
14702 wxString *arg3 = 0 ;
14703 wxFSFile *result = 0 ;
14704 void *argp1 = 0 ;
14705 int res1 = 0 ;
14706 void *argp2 = 0 ;
14707 int res2 = 0 ;
14708 bool temp3 = false ;
14709 PyObject * obj0 = 0 ;
14710 PyObject * obj1 = 0 ;
14711 PyObject * obj2 = 0 ;
14712 char * kwnames[] = {
14713 (char *) "self",(char *) "fs",(char *) "location", NULL
14714 };
14715
14716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14718 if (!SWIG_IsOK(res1)) {
14719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14720 }
14721 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14722 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14723 if (!SWIG_IsOK(res2)) {
14724 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14725 }
14726 if (!argp2) {
14727 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14728 }
14729 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14730 {
14731 arg3 = wxString_in_helper(obj2);
14732 if (arg3 == NULL) SWIG_fail;
14733 temp3 = true;
14734 }
14735 {
14736 PyThreadState* __tstate = wxPyBeginAllowThreads();
14737 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14738 wxPyEndAllowThreads(__tstate);
14739 if (PyErr_Occurred()) SWIG_fail;
14740 }
14741 {
14742 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14743 }
14744 {
14745 if (temp3)
14746 delete arg3;
14747 }
14748 return resultobj;
14749 fail:
14750 {
14751 if (temp3)
14752 delete arg3;
14753 }
14754 return NULL;
14755 }
14756
14757
14758 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14759 PyObject *resultobj = 0;
14760 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14761 wxString *arg2 = 0 ;
14762 int arg3 = (int) 0 ;
14763 wxString result;
14764 void *argp1 = 0 ;
14765 int res1 = 0 ;
14766 bool temp2 = false ;
14767 int val3 ;
14768 int ecode3 = 0 ;
14769 PyObject * obj0 = 0 ;
14770 PyObject * obj1 = 0 ;
14771 PyObject * obj2 = 0 ;
14772 char * kwnames[] = {
14773 (char *) "self",(char *) "spec",(char *) "flags", NULL
14774 };
14775
14776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14778 if (!SWIG_IsOK(res1)) {
14779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14780 }
14781 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14782 {
14783 arg2 = wxString_in_helper(obj1);
14784 if (arg2 == NULL) SWIG_fail;
14785 temp2 = true;
14786 }
14787 if (obj2) {
14788 ecode3 = SWIG_AsVal_int(obj2, &val3);
14789 if (!SWIG_IsOK(ecode3)) {
14790 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14791 }
14792 arg3 = static_cast< int >(val3);
14793 }
14794 {
14795 PyThreadState* __tstate = wxPyBeginAllowThreads();
14796 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14797 wxPyEndAllowThreads(__tstate);
14798 if (PyErr_Occurred()) SWIG_fail;
14799 }
14800 {
14801 #if wxUSE_UNICODE
14802 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14803 #else
14804 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14805 #endif
14806 }
14807 {
14808 if (temp2)
14809 delete arg2;
14810 }
14811 return resultobj;
14812 fail:
14813 {
14814 if (temp2)
14815 delete arg2;
14816 }
14817 return NULL;
14818 }
14819
14820
14821 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14822 PyObject *resultobj = 0;
14823 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14824 wxString result;
14825 void *argp1 = 0 ;
14826 int res1 = 0 ;
14827 PyObject *swig_obj[1] ;
14828
14829 if (!args) SWIG_fail;
14830 swig_obj[0] = args;
14831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14832 if (!SWIG_IsOK(res1)) {
14833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14834 }
14835 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14836 {
14837 PyThreadState* __tstate = wxPyBeginAllowThreads();
14838 result = (arg1)->FindNext();
14839 wxPyEndAllowThreads(__tstate);
14840 if (PyErr_Occurred()) SWIG_fail;
14841 }
14842 {
14843 #if wxUSE_UNICODE
14844 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14845 #else
14846 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14847 #endif
14848 }
14849 return resultobj;
14850 fail:
14851 return NULL;
14852 }
14853
14854
14855 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14856 PyObject *obj;
14857 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14858 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14859 return SWIG_Py_Void();
14860 }
14861
14862 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14863 return SWIG_Python_InitShadowInstance(args);
14864 }
14865
14866 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14867 PyObject *resultobj = 0;
14868 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14869 wxString result;
14870 void *argp1 = 0 ;
14871 int res1 = 0 ;
14872 PyObject *swig_obj[1] ;
14873
14874 if (!args) SWIG_fail;
14875 swig_obj[0] = args;
14876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14877 if (!SWIG_IsOK(res1)) {
14878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14879 }
14880 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14881 {
14882 PyThreadState* __tstate = wxPyBeginAllowThreads();
14883 result = (arg1)->GetName();
14884 wxPyEndAllowThreads(__tstate);
14885 if (PyErr_Occurred()) SWIG_fail;
14886 }
14887 {
14888 #if wxUSE_UNICODE
14889 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14890 #else
14891 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14892 #endif
14893 }
14894 return resultobj;
14895 fail:
14896 return NULL;
14897 }
14898
14899
14900 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14901 PyObject *resultobj = 0;
14902 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14903 wxString result;
14904 void *argp1 = 0 ;
14905 int res1 = 0 ;
14906 PyObject *swig_obj[1] ;
14907
14908 if (!args) SWIG_fail;
14909 swig_obj[0] = args;
14910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14911 if (!SWIG_IsOK(res1)) {
14912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14913 }
14914 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14915 {
14916 PyThreadState* __tstate = wxPyBeginAllowThreads();
14917 result = (arg1)->GetExtension();
14918 wxPyEndAllowThreads(__tstate);
14919 if (PyErr_Occurred()) SWIG_fail;
14920 }
14921 {
14922 #if wxUSE_UNICODE
14923 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14924 #else
14925 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14926 #endif
14927 }
14928 return resultobj;
14929 fail:
14930 return NULL;
14931 }
14932
14933
14934 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14935 PyObject *resultobj = 0;
14936 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14937 long result;
14938 void *argp1 = 0 ;
14939 int res1 = 0 ;
14940 PyObject *swig_obj[1] ;
14941
14942 if (!args) SWIG_fail;
14943 swig_obj[0] = args;
14944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14945 if (!SWIG_IsOK(res1)) {
14946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14947 }
14948 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14949 {
14950 PyThreadState* __tstate = wxPyBeginAllowThreads();
14951 result = (long)(arg1)->GetType();
14952 wxPyEndAllowThreads(__tstate);
14953 if (PyErr_Occurred()) SWIG_fail;
14954 }
14955 resultobj = SWIG_From_long(static_cast< long >(result));
14956 return resultobj;
14957 fail:
14958 return NULL;
14959 }
14960
14961
14962 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14963 PyObject *resultobj = 0;
14964 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14965 wxString result;
14966 void *argp1 = 0 ;
14967 int res1 = 0 ;
14968 PyObject *swig_obj[1] ;
14969
14970 if (!args) SWIG_fail;
14971 swig_obj[0] = args;
14972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14973 if (!SWIG_IsOK(res1)) {
14974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14975 }
14976 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14977 {
14978 PyThreadState* __tstate = wxPyBeginAllowThreads();
14979 result = (arg1)->GetMimeType();
14980 wxPyEndAllowThreads(__tstate);
14981 if (PyErr_Occurred()) SWIG_fail;
14982 }
14983 {
14984 #if wxUSE_UNICODE
14985 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14986 #else
14987 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14988 #endif
14989 }
14990 return resultobj;
14991 fail:
14992 return NULL;
14993 }
14994
14995
14996 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14997 PyObject *resultobj = 0;
14998 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14999 wxString *arg2 = 0 ;
15000 bool result;
15001 void *argp1 = 0 ;
15002 int res1 = 0 ;
15003 bool temp2 = false ;
15004 PyObject * obj0 = 0 ;
15005 PyObject * obj1 = 0 ;
15006 char * kwnames[] = {
15007 (char *) "self",(char *) "name", NULL
15008 };
15009
15010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
15011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15012 if (!SWIG_IsOK(res1)) {
15013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15014 }
15015 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15016 {
15017 arg2 = wxString_in_helper(obj1);
15018 if (arg2 == NULL) SWIG_fail;
15019 temp2 = true;
15020 }
15021 {
15022 PyThreadState* __tstate = wxPyBeginAllowThreads();
15023 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
15024 wxPyEndAllowThreads(__tstate);
15025 if (PyErr_Occurred()) SWIG_fail;
15026 }
15027 {
15028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15029 }
15030 {
15031 if (temp2)
15032 delete arg2;
15033 }
15034 return resultobj;
15035 fail:
15036 {
15037 if (temp2)
15038 delete arg2;
15039 }
15040 return NULL;
15041 }
15042
15043
15044 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15045 PyObject *resultobj = 0;
15046 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15047 wxInputStream *arg2 = 0 ;
15048 bool result;
15049 void *argp1 = 0 ;
15050 int res1 = 0 ;
15051 wxPyInputStream *temp2 ;
15052 bool created2 ;
15053 PyObject * obj0 = 0 ;
15054 PyObject * obj1 = 0 ;
15055 char * kwnames[] = {
15056 (char *) "self",(char *) "stream", NULL
15057 };
15058
15059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
15060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15061 if (!SWIG_IsOK(res1)) {
15062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15063 }
15064 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15065 {
15066 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15067 arg2 = temp2->m_wxis;
15068 created2 = false;
15069 } else {
15070 PyErr_Clear(); // clear the failure of the wxPyConvert above
15071 arg2 = wxPyCBInputStream_create(obj1, false);
15072 if (arg2 == NULL) {
15073 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15074 SWIG_fail;
15075 }
15076 created2 = true;
15077 }
15078 }
15079 {
15080 PyThreadState* __tstate = wxPyBeginAllowThreads();
15081 result = (bool)(arg1)->CanRead(*arg2);
15082 wxPyEndAllowThreads(__tstate);
15083 if (PyErr_Occurred()) SWIG_fail;
15084 }
15085 {
15086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15087 }
15088 {
15089 if (created2) delete arg2;
15090 }
15091 return resultobj;
15092 fail:
15093 {
15094 if (created2) delete arg2;
15095 }
15096 return NULL;
15097 }
15098
15099
15100 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15101 PyObject *resultobj = 0;
15102 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15103 wxString *arg2 = 0 ;
15104 void *argp1 = 0 ;
15105 int res1 = 0 ;
15106 bool temp2 = false ;
15107 PyObject * obj0 = 0 ;
15108 PyObject * obj1 = 0 ;
15109 char * kwnames[] = {
15110 (char *) "self",(char *) "name", NULL
15111 };
15112
15113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
15114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15115 if (!SWIG_IsOK(res1)) {
15116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15117 }
15118 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15119 {
15120 arg2 = wxString_in_helper(obj1);
15121 if (arg2 == NULL) SWIG_fail;
15122 temp2 = true;
15123 }
15124 {
15125 PyThreadState* __tstate = wxPyBeginAllowThreads();
15126 (arg1)->SetName((wxString const &)*arg2);
15127 wxPyEndAllowThreads(__tstate);
15128 if (PyErr_Occurred()) SWIG_fail;
15129 }
15130 resultobj = SWIG_Py_Void();
15131 {
15132 if (temp2)
15133 delete arg2;
15134 }
15135 return resultobj;
15136 fail:
15137 {
15138 if (temp2)
15139 delete arg2;
15140 }
15141 return NULL;
15142 }
15143
15144
15145 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15146 PyObject *resultobj = 0;
15147 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15148 wxString *arg2 = 0 ;
15149 void *argp1 = 0 ;
15150 int res1 = 0 ;
15151 bool temp2 = false ;
15152 PyObject * obj0 = 0 ;
15153 PyObject * obj1 = 0 ;
15154 char * kwnames[] = {
15155 (char *) "self",(char *) "extension", NULL
15156 };
15157
15158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
15159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15160 if (!SWIG_IsOK(res1)) {
15161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15162 }
15163 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15164 {
15165 arg2 = wxString_in_helper(obj1);
15166 if (arg2 == NULL) SWIG_fail;
15167 temp2 = true;
15168 }
15169 {
15170 PyThreadState* __tstate = wxPyBeginAllowThreads();
15171 (arg1)->SetExtension((wxString const &)*arg2);
15172 wxPyEndAllowThreads(__tstate);
15173 if (PyErr_Occurred()) SWIG_fail;
15174 }
15175 resultobj = SWIG_Py_Void();
15176 {
15177 if (temp2)
15178 delete arg2;
15179 }
15180 return resultobj;
15181 fail:
15182 {
15183 if (temp2)
15184 delete arg2;
15185 }
15186 return NULL;
15187 }
15188
15189
15190 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15191 PyObject *resultobj = 0;
15192 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15193 long arg2 ;
15194 void *argp1 = 0 ;
15195 int res1 = 0 ;
15196 long val2 ;
15197 int ecode2 = 0 ;
15198 PyObject * obj0 = 0 ;
15199 PyObject * obj1 = 0 ;
15200 char * kwnames[] = {
15201 (char *) "self",(char *) "type", NULL
15202 };
15203
15204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
15205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15206 if (!SWIG_IsOK(res1)) {
15207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15208 }
15209 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15210 ecode2 = SWIG_AsVal_long(obj1, &val2);
15211 if (!SWIG_IsOK(ecode2)) {
15212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
15213 }
15214 arg2 = static_cast< long >(val2);
15215 {
15216 PyThreadState* __tstate = wxPyBeginAllowThreads();
15217 (arg1)->SetType(arg2);
15218 wxPyEndAllowThreads(__tstate);
15219 if (PyErr_Occurred()) SWIG_fail;
15220 }
15221 resultobj = SWIG_Py_Void();
15222 return resultobj;
15223 fail:
15224 return NULL;
15225 }
15226
15227
15228 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15229 PyObject *resultobj = 0;
15230 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15231 wxString *arg2 = 0 ;
15232 void *argp1 = 0 ;
15233 int res1 = 0 ;
15234 bool temp2 = false ;
15235 PyObject * obj0 = 0 ;
15236 PyObject * obj1 = 0 ;
15237 char * kwnames[] = {
15238 (char *) "self",(char *) "mimetype", NULL
15239 };
15240
15241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
15242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15243 if (!SWIG_IsOK(res1)) {
15244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15245 }
15246 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15247 {
15248 arg2 = wxString_in_helper(obj1);
15249 if (arg2 == NULL) SWIG_fail;
15250 temp2 = true;
15251 }
15252 {
15253 PyThreadState* __tstate = wxPyBeginAllowThreads();
15254 (arg1)->SetMimeType((wxString const &)*arg2);
15255 wxPyEndAllowThreads(__tstate);
15256 if (PyErr_Occurred()) SWIG_fail;
15257 }
15258 resultobj = SWIG_Py_Void();
15259 {
15260 if (temp2)
15261 delete arg2;
15262 }
15263 return resultobj;
15264 fail:
15265 {
15266 if (temp2)
15267 delete arg2;
15268 }
15269 return NULL;
15270 }
15271
15272
15273 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15274 PyObject *obj;
15275 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15276 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
15277 return SWIG_Py_Void();
15278 }
15279
15280 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15281 PyObject *resultobj = 0;
15282 wxPyImageHandler *result = 0 ;
15283
15284 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
15285 {
15286 PyThreadState* __tstate = wxPyBeginAllowThreads();
15287 result = (wxPyImageHandler *)new wxPyImageHandler();
15288 wxPyEndAllowThreads(__tstate);
15289 if (PyErr_Occurred()) SWIG_fail;
15290 }
15291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
15292 return resultobj;
15293 fail:
15294 return NULL;
15295 }
15296
15297
15298 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15299 PyObject *resultobj = 0;
15300 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
15301 PyObject *arg2 = (PyObject *) 0 ;
15302 void *argp1 = 0 ;
15303 int res1 = 0 ;
15304 PyObject * obj0 = 0 ;
15305 PyObject * obj1 = 0 ;
15306 char * kwnames[] = {
15307 (char *) "self",(char *) "self", NULL
15308 };
15309
15310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
15311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
15312 if (!SWIG_IsOK(res1)) {
15313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
15314 }
15315 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
15316 arg2 = obj1;
15317 {
15318 PyThreadState* __tstate = wxPyBeginAllowThreads();
15319 (arg1)->_SetSelf(arg2);
15320 wxPyEndAllowThreads(__tstate);
15321 if (PyErr_Occurred()) SWIG_fail;
15322 }
15323 resultobj = SWIG_Py_Void();
15324 return resultobj;
15325 fail:
15326 return NULL;
15327 }
15328
15329
15330 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15331 PyObject *obj;
15332 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15333 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
15334 return SWIG_Py_Void();
15335 }
15336
15337 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15338 return SWIG_Python_InitShadowInstance(args);
15339 }
15340
15341 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15342 PyObject *resultobj = 0;
15343 wxImageHistogram *result = 0 ;
15344
15345 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
15346 {
15347 PyThreadState* __tstate = wxPyBeginAllowThreads();
15348 result = (wxImageHistogram *)new wxImageHistogram();
15349 wxPyEndAllowThreads(__tstate);
15350 if (PyErr_Occurred()) SWIG_fail;
15351 }
15352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
15353 return resultobj;
15354 fail:
15355 return NULL;
15356 }
15357
15358
15359 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15360 PyObject *resultobj = 0;
15361 byte arg1 ;
15362 byte arg2 ;
15363 byte arg3 ;
15364 unsigned long result;
15365 unsigned char val1 ;
15366 int ecode1 = 0 ;
15367 unsigned char val2 ;
15368 int ecode2 = 0 ;
15369 unsigned char val3 ;
15370 int ecode3 = 0 ;
15371 PyObject * obj0 = 0 ;
15372 PyObject * obj1 = 0 ;
15373 PyObject * obj2 = 0 ;
15374 char * kwnames[] = {
15375 (char *) "r",(char *) "g",(char *) "b", NULL
15376 };
15377
15378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15379 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15380 if (!SWIG_IsOK(ecode1)) {
15381 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
15382 }
15383 arg1 = static_cast< byte >(val1);
15384 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15385 if (!SWIG_IsOK(ecode2)) {
15386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
15387 }
15388 arg2 = static_cast< byte >(val2);
15389 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15390 if (!SWIG_IsOK(ecode3)) {
15391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
15392 }
15393 arg3 = static_cast< byte >(val3);
15394 {
15395 PyThreadState* __tstate = wxPyBeginAllowThreads();
15396 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
15397 wxPyEndAllowThreads(__tstate);
15398 if (PyErr_Occurred()) SWIG_fail;
15399 }
15400 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15401 return resultobj;
15402 fail:
15403 return NULL;
15404 }
15405
15406
15407 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15408 PyObject *resultobj = 0;
15409 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15410 byte *arg2 = (byte *) 0 ;
15411 byte *arg3 = (byte *) 0 ;
15412 byte *arg4 = (byte *) 0 ;
15413 byte arg5 = (byte) 1 ;
15414 byte arg6 = (byte) 0 ;
15415 byte arg7 = (byte) 0 ;
15416 bool result;
15417 void *argp1 = 0 ;
15418 int res1 = 0 ;
15419 byte temp2 ;
15420 int res2 = SWIG_TMPOBJ ;
15421 byte temp3 ;
15422 int res3 = SWIG_TMPOBJ ;
15423 byte temp4 ;
15424 int res4 = SWIG_TMPOBJ ;
15425 unsigned char val5 ;
15426 int ecode5 = 0 ;
15427 unsigned char val6 ;
15428 int ecode6 = 0 ;
15429 unsigned char val7 ;
15430 int ecode7 = 0 ;
15431 PyObject * obj0 = 0 ;
15432 PyObject * obj1 = 0 ;
15433 PyObject * obj2 = 0 ;
15434 PyObject * obj3 = 0 ;
15435 char * kwnames[] = {
15436 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
15437 };
15438
15439 arg2 = &temp2;
15440 arg3 = &temp3;
15441 arg4 = &temp4;
15442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15444 if (!SWIG_IsOK(res1)) {
15445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
15446 }
15447 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15448 if (obj1) {
15449 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
15450 if (!SWIG_IsOK(ecode5)) {
15451 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
15452 }
15453 arg5 = static_cast< byte >(val5);
15454 }
15455 if (obj2) {
15456 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
15457 if (!SWIG_IsOK(ecode6)) {
15458 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
15459 }
15460 arg6 = static_cast< byte >(val6);
15461 }
15462 if (obj3) {
15463 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
15464 if (!SWIG_IsOK(ecode7)) {
15465 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
15466 }
15467 arg7 = static_cast< byte >(val7);
15468 }
15469 {
15470 PyThreadState* __tstate = wxPyBeginAllowThreads();
15471 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
15472 wxPyEndAllowThreads(__tstate);
15473 if (PyErr_Occurred()) SWIG_fail;
15474 }
15475 {
15476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15477 }
15478 if (SWIG_IsTmpObj(res2)) {
15479 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15480 } else {
15481 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15482 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15483 }
15484 if (SWIG_IsTmpObj(res3)) {
15485 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15486 } else {
15487 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15488 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15489 }
15490 if (SWIG_IsTmpObj(res4)) {
15491 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15492 } else {
15493 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15494 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15495 }
15496 return resultobj;
15497 fail:
15498 return NULL;
15499 }
15500
15501
15502 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15503 PyObject *resultobj = 0;
15504 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15505 unsigned long arg2 ;
15506 unsigned long result;
15507 void *argp1 = 0 ;
15508 int res1 = 0 ;
15509 unsigned long val2 ;
15510 int ecode2 = 0 ;
15511 PyObject * obj0 = 0 ;
15512 PyObject * obj1 = 0 ;
15513 char * kwnames[] = {
15514 (char *) "self",(char *) "key", NULL
15515 };
15516
15517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
15518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15519 if (!SWIG_IsOK(res1)) {
15520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15521 }
15522 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15523 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
15524 if (!SWIG_IsOK(ecode2)) {
15525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
15526 }
15527 arg2 = static_cast< unsigned long >(val2);
15528 {
15529 PyThreadState* __tstate = wxPyBeginAllowThreads();
15530 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
15531 wxPyEndAllowThreads(__tstate);
15532 if (PyErr_Occurred()) SWIG_fail;
15533 }
15534 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15535 return resultobj;
15536 fail:
15537 return NULL;
15538 }
15539
15540
15541 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15542 PyObject *resultobj = 0;
15543 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15544 byte arg2 ;
15545 byte arg3 ;
15546 byte arg4 ;
15547 unsigned long result;
15548 void *argp1 = 0 ;
15549 int res1 = 0 ;
15550 unsigned char val2 ;
15551 int ecode2 = 0 ;
15552 unsigned char val3 ;
15553 int ecode3 = 0 ;
15554 unsigned char val4 ;
15555 int ecode4 = 0 ;
15556 PyObject * obj0 = 0 ;
15557 PyObject * obj1 = 0 ;
15558 PyObject * obj2 = 0 ;
15559 PyObject * obj3 = 0 ;
15560 char * kwnames[] = {
15561 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15562 };
15563
15564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15566 if (!SWIG_IsOK(res1)) {
15567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15568 }
15569 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15570 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15571 if (!SWIG_IsOK(ecode2)) {
15572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
15573 }
15574 arg2 = static_cast< byte >(val2);
15575 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15576 if (!SWIG_IsOK(ecode3)) {
15577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
15578 }
15579 arg3 = static_cast< byte >(val3);
15580 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15581 if (!SWIG_IsOK(ecode4)) {
15582 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
15583 }
15584 arg4 = static_cast< byte >(val4);
15585 {
15586 PyThreadState* __tstate = wxPyBeginAllowThreads();
15587 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
15588 wxPyEndAllowThreads(__tstate);
15589 if (PyErr_Occurred()) SWIG_fail;
15590 }
15591 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15592 return resultobj;
15593 fail:
15594 return NULL;
15595 }
15596
15597
15598 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15599 PyObject *resultobj = 0;
15600 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15601 wxColour *arg2 = 0 ;
15602 unsigned long result;
15603 void *argp1 = 0 ;
15604 int res1 = 0 ;
15605 wxColour temp2 ;
15606 PyObject * obj0 = 0 ;
15607 PyObject * obj1 = 0 ;
15608 char * kwnames[] = {
15609 (char *) "self",(char *) "colour", NULL
15610 };
15611
15612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15614 if (!SWIG_IsOK(res1)) {
15615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15616 }
15617 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15618 {
15619 arg2 = &temp2;
15620 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15621 }
15622 {
15623 PyThreadState* __tstate = wxPyBeginAllowThreads();
15624 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15625 wxPyEndAllowThreads(__tstate);
15626 if (PyErr_Occurred()) SWIG_fail;
15627 }
15628 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15629 return resultobj;
15630 fail:
15631 return NULL;
15632 }
15633
15634
15635 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15636 PyObject *obj;
15637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15638 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15639 return SWIG_Py_Void();
15640 }
15641
15642 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15643 return SWIG_Python_InitShadowInstance(args);
15644 }
15645
15646 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15647 PyObject *resultobj = 0;
15648 byte arg1 = (byte) 0 ;
15649 byte arg2 = (byte) 0 ;
15650 byte arg3 = (byte) 0 ;
15651 wxImage_RGBValue *result = 0 ;
15652 unsigned char val1 ;
15653 int ecode1 = 0 ;
15654 unsigned char val2 ;
15655 int ecode2 = 0 ;
15656 unsigned char val3 ;
15657 int ecode3 = 0 ;
15658 PyObject * obj0 = 0 ;
15659 PyObject * obj1 = 0 ;
15660 PyObject * obj2 = 0 ;
15661 char * kwnames[] = {
15662 (char *) "r",(char *) "g",(char *) "b", NULL
15663 };
15664
15665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15666 if (obj0) {
15667 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15668 if (!SWIG_IsOK(ecode1)) {
15669 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15670 }
15671 arg1 = static_cast< byte >(val1);
15672 }
15673 if (obj1) {
15674 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15675 if (!SWIG_IsOK(ecode2)) {
15676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15677 }
15678 arg2 = static_cast< byte >(val2);
15679 }
15680 if (obj2) {
15681 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15682 if (!SWIG_IsOK(ecode3)) {
15683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15684 }
15685 arg3 = static_cast< byte >(val3);
15686 }
15687 {
15688 PyThreadState* __tstate = wxPyBeginAllowThreads();
15689 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15690 wxPyEndAllowThreads(__tstate);
15691 if (PyErr_Occurred()) SWIG_fail;
15692 }
15693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15694 return resultobj;
15695 fail:
15696 return NULL;
15697 }
15698
15699
15700 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15701 PyObject *resultobj = 0;
15702 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15703 byte arg2 ;
15704 void *argp1 = 0 ;
15705 int res1 = 0 ;
15706 unsigned char val2 ;
15707 int ecode2 = 0 ;
15708 PyObject *swig_obj[2] ;
15709
15710 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15712 if (!SWIG_IsOK(res1)) {
15713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15714 }
15715 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15716 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15717 if (!SWIG_IsOK(ecode2)) {
15718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15719 }
15720 arg2 = static_cast< byte >(val2);
15721 if (arg1) (arg1)->red = arg2;
15722
15723 resultobj = SWIG_Py_Void();
15724 return resultobj;
15725 fail:
15726 return NULL;
15727 }
15728
15729
15730 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15731 PyObject *resultobj = 0;
15732 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15733 byte result;
15734 void *argp1 = 0 ;
15735 int res1 = 0 ;
15736 PyObject *swig_obj[1] ;
15737
15738 if (!args) SWIG_fail;
15739 swig_obj[0] = args;
15740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15741 if (!SWIG_IsOK(res1)) {
15742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15743 }
15744 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15745 result = (byte) ((arg1)->red);
15746 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15747 return resultobj;
15748 fail:
15749 return NULL;
15750 }
15751
15752
15753 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15754 PyObject *resultobj = 0;
15755 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15756 byte arg2 ;
15757 void *argp1 = 0 ;
15758 int res1 = 0 ;
15759 unsigned char val2 ;
15760 int ecode2 = 0 ;
15761 PyObject *swig_obj[2] ;
15762
15763 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15765 if (!SWIG_IsOK(res1)) {
15766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15767 }
15768 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15769 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15770 if (!SWIG_IsOK(ecode2)) {
15771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15772 }
15773 arg2 = static_cast< byte >(val2);
15774 if (arg1) (arg1)->green = arg2;
15775
15776 resultobj = SWIG_Py_Void();
15777 return resultobj;
15778 fail:
15779 return NULL;
15780 }
15781
15782
15783 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15784 PyObject *resultobj = 0;
15785 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15786 byte result;
15787 void *argp1 = 0 ;
15788 int res1 = 0 ;
15789 PyObject *swig_obj[1] ;
15790
15791 if (!args) SWIG_fail;
15792 swig_obj[0] = args;
15793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15794 if (!SWIG_IsOK(res1)) {
15795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15796 }
15797 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15798 result = (byte) ((arg1)->green);
15799 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15800 return resultobj;
15801 fail:
15802 return NULL;
15803 }
15804
15805
15806 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15807 PyObject *resultobj = 0;
15808 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15809 byte arg2 ;
15810 void *argp1 = 0 ;
15811 int res1 = 0 ;
15812 unsigned char val2 ;
15813 int ecode2 = 0 ;
15814 PyObject *swig_obj[2] ;
15815
15816 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15818 if (!SWIG_IsOK(res1)) {
15819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15820 }
15821 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15822 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15823 if (!SWIG_IsOK(ecode2)) {
15824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15825 }
15826 arg2 = static_cast< byte >(val2);
15827 if (arg1) (arg1)->blue = arg2;
15828
15829 resultobj = SWIG_Py_Void();
15830 return resultobj;
15831 fail:
15832 return NULL;
15833 }
15834
15835
15836 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15837 PyObject *resultobj = 0;
15838 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15839 byte result;
15840 void *argp1 = 0 ;
15841 int res1 = 0 ;
15842 PyObject *swig_obj[1] ;
15843
15844 if (!args) SWIG_fail;
15845 swig_obj[0] = args;
15846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15847 if (!SWIG_IsOK(res1)) {
15848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15849 }
15850 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15851 result = (byte) ((arg1)->blue);
15852 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15853 return resultobj;
15854 fail:
15855 return NULL;
15856 }
15857
15858
15859 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15860 PyObject *obj;
15861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15862 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15863 return SWIG_Py_Void();
15864 }
15865
15866 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15867 return SWIG_Python_InitShadowInstance(args);
15868 }
15869
15870 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15871 PyObject *resultobj = 0;
15872 double arg1 = (double) 0.0 ;
15873 double arg2 = (double) 0.0 ;
15874 double arg3 = (double) 0.0 ;
15875 wxImage_HSVValue *result = 0 ;
15876 double val1 ;
15877 int ecode1 = 0 ;
15878 double val2 ;
15879 int ecode2 = 0 ;
15880 double val3 ;
15881 int ecode3 = 0 ;
15882 PyObject * obj0 = 0 ;
15883 PyObject * obj1 = 0 ;
15884 PyObject * obj2 = 0 ;
15885 char * kwnames[] = {
15886 (char *) "h",(char *) "s",(char *) "v", NULL
15887 };
15888
15889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15890 if (obj0) {
15891 ecode1 = SWIG_AsVal_double(obj0, &val1);
15892 if (!SWIG_IsOK(ecode1)) {
15893 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15894 }
15895 arg1 = static_cast< double >(val1);
15896 }
15897 if (obj1) {
15898 ecode2 = SWIG_AsVal_double(obj1, &val2);
15899 if (!SWIG_IsOK(ecode2)) {
15900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15901 }
15902 arg2 = static_cast< double >(val2);
15903 }
15904 if (obj2) {
15905 ecode3 = SWIG_AsVal_double(obj2, &val3);
15906 if (!SWIG_IsOK(ecode3)) {
15907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15908 }
15909 arg3 = static_cast< double >(val3);
15910 }
15911 {
15912 PyThreadState* __tstate = wxPyBeginAllowThreads();
15913 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15914 wxPyEndAllowThreads(__tstate);
15915 if (PyErr_Occurred()) SWIG_fail;
15916 }
15917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15918 return resultobj;
15919 fail:
15920 return NULL;
15921 }
15922
15923
15924 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15925 PyObject *resultobj = 0;
15926 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15927 double arg2 ;
15928 void *argp1 = 0 ;
15929 int res1 = 0 ;
15930 double val2 ;
15931 int ecode2 = 0 ;
15932 PyObject *swig_obj[2] ;
15933
15934 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15936 if (!SWIG_IsOK(res1)) {
15937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15938 }
15939 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15940 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15941 if (!SWIG_IsOK(ecode2)) {
15942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15943 }
15944 arg2 = static_cast< double >(val2);
15945 if (arg1) (arg1)->hue = arg2;
15946
15947 resultobj = SWIG_Py_Void();
15948 return resultobj;
15949 fail:
15950 return NULL;
15951 }
15952
15953
15954 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15955 PyObject *resultobj = 0;
15956 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15957 double result;
15958 void *argp1 = 0 ;
15959 int res1 = 0 ;
15960 PyObject *swig_obj[1] ;
15961
15962 if (!args) SWIG_fail;
15963 swig_obj[0] = args;
15964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15965 if (!SWIG_IsOK(res1)) {
15966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15967 }
15968 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15969 result = (double) ((arg1)->hue);
15970 resultobj = SWIG_From_double(static_cast< double >(result));
15971 return resultobj;
15972 fail:
15973 return NULL;
15974 }
15975
15976
15977 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15978 PyObject *resultobj = 0;
15979 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15980 double arg2 ;
15981 void *argp1 = 0 ;
15982 int res1 = 0 ;
15983 double val2 ;
15984 int ecode2 = 0 ;
15985 PyObject *swig_obj[2] ;
15986
15987 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15989 if (!SWIG_IsOK(res1)) {
15990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15991 }
15992 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15993 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15994 if (!SWIG_IsOK(ecode2)) {
15995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15996 }
15997 arg2 = static_cast< double >(val2);
15998 if (arg1) (arg1)->saturation = arg2;
15999
16000 resultobj = SWIG_Py_Void();
16001 return resultobj;
16002 fail:
16003 return NULL;
16004 }
16005
16006
16007 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16008 PyObject *resultobj = 0;
16009 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
16010 double result;
16011 void *argp1 = 0 ;
16012 int res1 = 0 ;
16013 PyObject *swig_obj[1] ;
16014
16015 if (!args) SWIG_fail;
16016 swig_obj[0] = args;
16017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
16018 if (!SWIG_IsOK(res1)) {
16019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
16020 }
16021 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
16022 result = (double) ((arg1)->saturation);
16023 resultobj = SWIG_From_double(static_cast< double >(result));
16024 return resultobj;
16025 fail:
16026 return NULL;
16027 }
16028
16029
16030 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16031 PyObject *resultobj = 0;
16032 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
16033 double arg2 ;
16034 void *argp1 = 0 ;
16035 int res1 = 0 ;
16036 double val2 ;
16037 int ecode2 = 0 ;
16038 PyObject *swig_obj[2] ;
16039
16040 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
16041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
16042 if (!SWIG_IsOK(res1)) {
16043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
16044 }
16045 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
16046 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
16047 if (!SWIG_IsOK(ecode2)) {
16048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
16049 }
16050 arg2 = static_cast< double >(val2);
16051 if (arg1) (arg1)->value = arg2;
16052
16053 resultobj = SWIG_Py_Void();
16054 return resultobj;
16055 fail:
16056 return NULL;
16057 }
16058
16059
16060 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16061 PyObject *resultobj = 0;
16062 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
16063 double result;
16064 void *argp1 = 0 ;
16065 int res1 = 0 ;
16066 PyObject *swig_obj[1] ;
16067
16068 if (!args) SWIG_fail;
16069 swig_obj[0] = args;
16070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
16071 if (!SWIG_IsOK(res1)) {
16072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
16073 }
16074 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
16075 result = (double) ((arg1)->value);
16076 resultobj = SWIG_From_double(static_cast< double >(result));
16077 return resultobj;
16078 fail:
16079 return NULL;
16080 }
16081
16082
16083 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16084 PyObject *obj;
16085 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16086 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
16087 return SWIG_Py_Void();
16088 }
16089
16090 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16091 return SWIG_Python_InitShadowInstance(args);
16092 }
16093
16094 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16095 PyObject *resultobj = 0;
16096 wxString *arg1 = 0 ;
16097 long arg2 = (long) wxBITMAP_TYPE_ANY ;
16098 int arg3 = (int) -1 ;
16099 wxImage *result = 0 ;
16100 bool temp1 = false ;
16101 long val2 ;
16102 int ecode2 = 0 ;
16103 int val3 ;
16104 int ecode3 = 0 ;
16105 PyObject * obj0 = 0 ;
16106 PyObject * obj1 = 0 ;
16107 PyObject * obj2 = 0 ;
16108 char * kwnames[] = {
16109 (char *) "name",(char *) "type",(char *) "index", NULL
16110 };
16111
16112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16113 {
16114 arg1 = wxString_in_helper(obj0);
16115 if (arg1 == NULL) SWIG_fail;
16116 temp1 = true;
16117 }
16118 if (obj1) {
16119 ecode2 = SWIG_AsVal_long(obj1, &val2);
16120 if (!SWIG_IsOK(ecode2)) {
16121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
16122 }
16123 arg2 = static_cast< long >(val2);
16124 }
16125 if (obj2) {
16126 ecode3 = SWIG_AsVal_int(obj2, &val3);
16127 if (!SWIG_IsOK(ecode3)) {
16128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
16129 }
16130 arg3 = static_cast< int >(val3);
16131 }
16132 {
16133 PyThreadState* __tstate = wxPyBeginAllowThreads();
16134 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
16135 wxPyEndAllowThreads(__tstate);
16136 if (PyErr_Occurred()) SWIG_fail;
16137 }
16138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
16139 {
16140 if (temp1)
16141 delete arg1;
16142 }
16143 return resultobj;
16144 fail:
16145 {
16146 if (temp1)
16147 delete arg1;
16148 }
16149 return NULL;
16150 }
16151
16152
16153 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16154 PyObject *resultobj = 0;
16155 wxImage *arg1 = (wxImage *) 0 ;
16156 void *argp1 = 0 ;
16157 int res1 = 0 ;
16158 PyObject *swig_obj[1] ;
16159
16160 if (!args) SWIG_fail;
16161 swig_obj[0] = args;
16162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
16163 if (!SWIG_IsOK(res1)) {
16164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
16165 }
16166 arg1 = reinterpret_cast< wxImage * >(argp1);
16167 {
16168 PyThreadState* __tstate = wxPyBeginAllowThreads();
16169 delete arg1;
16170
16171 wxPyEndAllowThreads(__tstate);
16172 if (PyErr_Occurred()) SWIG_fail;
16173 }
16174 resultobj = SWIG_Py_Void();
16175 return resultobj;
16176 fail:
16177 return NULL;
16178 }
16179
16180
16181 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16182 PyObject *resultobj = 0;
16183 wxString *arg1 = 0 ;
16184 wxString *arg2 = 0 ;
16185 int arg3 = (int) -1 ;
16186 wxImage *result = 0 ;
16187 bool temp1 = false ;
16188 bool temp2 = false ;
16189 int val3 ;
16190 int ecode3 = 0 ;
16191 PyObject * obj0 = 0 ;
16192 PyObject * obj1 = 0 ;
16193 PyObject * obj2 = 0 ;
16194 char * kwnames[] = {
16195 (char *) "name",(char *) "mimetype",(char *) "index", NULL
16196 };
16197
16198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16199 {
16200 arg1 = wxString_in_helper(obj0);
16201 if (arg1 == NULL) SWIG_fail;
16202 temp1 = true;
16203 }
16204 {
16205 arg2 = wxString_in_helper(obj1);
16206 if (arg2 == NULL) SWIG_fail;
16207 temp2 = true;
16208 }
16209 if (obj2) {
16210 ecode3 = SWIG_AsVal_int(obj2, &val3);
16211 if (!SWIG_IsOK(ecode3)) {
16212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
16213 }
16214 arg3 = static_cast< int >(val3);
16215 }
16216 {
16217 PyThreadState* __tstate = wxPyBeginAllowThreads();
16218 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
16219 wxPyEndAllowThreads(__tstate);
16220 if (PyErr_Occurred()) SWIG_fail;
16221 }
16222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16223 {
16224 if (temp1)
16225 delete arg1;
16226 }
16227 {
16228 if (temp2)
16229 delete arg2;
16230 }
16231 return resultobj;
16232 fail:
16233 {
16234 if (temp1)
16235 delete arg1;
16236 }
16237 {
16238 if (temp2)
16239 delete arg2;
16240 }
16241 return NULL;
16242 }
16243
16244
16245 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16246 PyObject *resultobj = 0;
16247 wxInputStream *arg1 = 0 ;
16248 long arg2 = (long) wxBITMAP_TYPE_ANY ;
16249 int arg3 = (int) -1 ;
16250 wxImage *result = 0 ;
16251 wxPyInputStream *temp1 ;
16252 bool created1 ;
16253 long val2 ;
16254 int ecode2 = 0 ;
16255 int val3 ;
16256 int ecode3 = 0 ;
16257 PyObject * obj0 = 0 ;
16258 PyObject * obj1 = 0 ;
16259 PyObject * obj2 = 0 ;
16260 char * kwnames[] = {
16261 (char *) "stream",(char *) "type",(char *) "index", NULL
16262 };
16263
16264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16265 {
16266 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
16267 arg1 = temp1->m_wxis;
16268 created1 = false;
16269 } else {
16270 PyErr_Clear(); // clear the failure of the wxPyConvert above
16271 arg1 = wxPyCBInputStream_create(obj0, false);
16272 if (arg1 == NULL) {
16273 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
16274 SWIG_fail;
16275 }
16276 created1 = true;
16277 }
16278 }
16279 if (obj1) {
16280 ecode2 = SWIG_AsVal_long(obj1, &val2);
16281 if (!SWIG_IsOK(ecode2)) {
16282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
16283 }
16284 arg2 = static_cast< long >(val2);
16285 }
16286 if (obj2) {
16287 ecode3 = SWIG_AsVal_int(obj2, &val3);
16288 if (!SWIG_IsOK(ecode3)) {
16289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
16290 }
16291 arg3 = static_cast< int >(val3);
16292 }
16293 {
16294 PyThreadState* __tstate = wxPyBeginAllowThreads();
16295 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
16296 wxPyEndAllowThreads(__tstate);
16297 if (PyErr_Occurred()) SWIG_fail;
16298 }
16299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16300 {
16301 if (created1) delete arg1;
16302 }
16303 return resultobj;
16304 fail:
16305 {
16306 if (created1) delete arg1;
16307 }
16308 return NULL;
16309 }
16310
16311
16312 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16313 PyObject *resultobj = 0;
16314 wxInputStream *arg1 = 0 ;
16315 wxString *arg2 = 0 ;
16316 int arg3 = (int) -1 ;
16317 wxImage *result = 0 ;
16318 wxPyInputStream *temp1 ;
16319 bool created1 ;
16320 bool temp2 = false ;
16321 int val3 ;
16322 int ecode3 = 0 ;
16323 PyObject * obj0 = 0 ;
16324 PyObject * obj1 = 0 ;
16325 PyObject * obj2 = 0 ;
16326 char * kwnames[] = {
16327 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
16328 };
16329
16330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16331 {
16332 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
16333 arg1 = temp1->m_wxis;
16334 created1 = false;
16335 } else {
16336 PyErr_Clear(); // clear the failure of the wxPyConvert above
16337 arg1 = wxPyCBInputStream_create(obj0, false);
16338 if (arg1 == NULL) {
16339 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
16340 SWIG_fail;
16341 }
16342 created1 = true;
16343 }
16344 }
16345 {
16346 arg2 = wxString_in_helper(obj1);
16347 if (arg2 == NULL) SWIG_fail;
16348 temp2 = true;
16349 }
16350 if (obj2) {
16351 ecode3 = SWIG_AsVal_int(obj2, &val3);
16352 if (!SWIG_IsOK(ecode3)) {
16353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
16354 }
16355 arg3 = static_cast< int >(val3);
16356 }
16357 {
16358 PyThreadState* __tstate = wxPyBeginAllowThreads();
16359 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
16360 wxPyEndAllowThreads(__tstate);
16361 if (PyErr_Occurred()) SWIG_fail;
16362 }
16363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16364 {
16365 if (created1) delete arg1;
16366 }
16367 {
16368 if (temp2)
16369 delete arg2;
16370 }
16371 return resultobj;
16372 fail:
16373 {
16374 if (created1) delete arg1;
16375 }
16376 {
16377 if (temp2)
16378 delete arg2;
16379 }
16380 return NULL;
16381 }
16382
16383
16384 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16385 PyObject *resultobj = 0;
16386 int arg1 = (int) 0 ;
16387 int arg2 = (int) 0 ;
16388 bool arg3 = (bool) true ;
16389 wxImage *result = 0 ;
16390 int val1 ;
16391 int ecode1 = 0 ;
16392 int val2 ;
16393 int ecode2 = 0 ;
16394 bool val3 ;
16395 int ecode3 = 0 ;
16396 PyObject * obj0 = 0 ;
16397 PyObject * obj1 = 0 ;
16398 PyObject * obj2 = 0 ;
16399 char * kwnames[] = {
16400 (char *) "width",(char *) "height",(char *) "clear", NULL
16401 };
16402
16403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16404 if (obj0) {
16405 ecode1 = SWIG_AsVal_int(obj0, &val1);
16406 if (!SWIG_IsOK(ecode1)) {
16407 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
16408 }
16409 arg1 = static_cast< int >(val1);
16410 }
16411 if (obj1) {
16412 ecode2 = SWIG_AsVal_int(obj1, &val2);
16413 if (!SWIG_IsOK(ecode2)) {
16414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
16415 }
16416 arg2 = static_cast< int >(val2);
16417 }
16418 if (obj2) {
16419 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16420 if (!SWIG_IsOK(ecode3)) {
16421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
16422 }
16423 arg3 = static_cast< bool >(val3);
16424 }
16425 {
16426 PyThreadState* __tstate = wxPyBeginAllowThreads();
16427 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
16428 wxPyEndAllowThreads(__tstate);
16429 if (PyErr_Occurred()) SWIG_fail;
16430 }
16431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16432 return resultobj;
16433 fail:
16434 return NULL;
16435 }
16436
16437
16438 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16439 PyObject *resultobj = 0;
16440 wxBitmap *arg1 = 0 ;
16441 wxImage *result = 0 ;
16442 void *argp1 = 0 ;
16443 int res1 = 0 ;
16444 PyObject * obj0 = 0 ;
16445 char * kwnames[] = {
16446 (char *) "bitmap", NULL
16447 };
16448
16449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
16450 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
16451 if (!SWIG_IsOK(res1)) {
16452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
16453 }
16454 if (!argp1) {
16455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
16456 }
16457 arg1 = reinterpret_cast< wxBitmap * >(argp1);
16458 {
16459 if (!wxPyCheckForApp()) SWIG_fail;
16460 PyThreadState* __tstate = wxPyBeginAllowThreads();
16461 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
16462 wxPyEndAllowThreads(__tstate);
16463 if (PyErr_Occurred()) SWIG_fail;
16464 }
16465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16466 return resultobj;
16467 fail:
16468 return NULL;
16469 }
16470
16471
16472 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16473 PyObject *resultobj = 0;
16474 int arg1 ;
16475 int arg2 ;
16476 buffer arg3 ;
16477 int arg4 ;
16478 wxImage *result = 0 ;
16479 int val1 ;
16480 int ecode1 = 0 ;
16481 int val2 ;
16482 int ecode2 = 0 ;
16483 Py_ssize_t temp3 ;
16484 PyObject * obj0 = 0 ;
16485 PyObject * obj1 = 0 ;
16486 PyObject * obj2 = 0 ;
16487 char * kwnames[] = {
16488 (char *) "width",(char *) "height",(char *) "data", NULL
16489 };
16490
16491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16492 ecode1 = SWIG_AsVal_int(obj0, &val1);
16493 if (!SWIG_IsOK(ecode1)) {
16494 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
16495 }
16496 arg1 = static_cast< int >(val1);
16497 ecode2 = SWIG_AsVal_int(obj1, &val2);
16498 if (!SWIG_IsOK(ecode2)) {
16499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
16500 }
16501 arg2 = static_cast< int >(val2);
16502 {
16503 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
16504 arg4 = (int)temp3;
16505 }
16506 {
16507 PyThreadState* __tstate = wxPyBeginAllowThreads();
16508 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
16509 wxPyEndAllowThreads(__tstate);
16510 if (PyErr_Occurred()) SWIG_fail;
16511 }
16512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16513 return resultobj;
16514 fail:
16515 return NULL;
16516 }
16517
16518
16519 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16520 PyObject *resultobj = 0;
16521 int arg1 ;
16522 int arg2 ;
16523 buffer arg3 ;
16524 int arg4 ;
16525 buffer arg5 ;
16526 int arg6 ;
16527 wxImage *result = 0 ;
16528 int val1 ;
16529 int ecode1 = 0 ;
16530 int val2 ;
16531 int ecode2 = 0 ;
16532 Py_ssize_t temp3 ;
16533 Py_ssize_t temp5 ;
16534 PyObject * obj0 = 0 ;
16535 PyObject * obj1 = 0 ;
16536 PyObject * obj2 = 0 ;
16537 PyObject * obj3 = 0 ;
16538 char * kwnames[] = {
16539 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
16540 };
16541
16542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16543 ecode1 = SWIG_AsVal_int(obj0, &val1);
16544 if (!SWIG_IsOK(ecode1)) {
16545 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
16546 }
16547 arg1 = static_cast< int >(val1);
16548 ecode2 = SWIG_AsVal_int(obj1, &val2);
16549 if (!SWIG_IsOK(ecode2)) {
16550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
16551 }
16552 arg2 = static_cast< int >(val2);
16553 {
16554 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
16555 arg4 = (int)temp3;
16556 }
16557 {
16558 if (obj3 != Py_None) {
16559 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
16560 arg6 = (int)temp5;
16561 }
16562 }
16563 {
16564 PyThreadState* __tstate = wxPyBeginAllowThreads();
16565 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
16566 wxPyEndAllowThreads(__tstate);
16567 if (PyErr_Occurred()) SWIG_fail;
16568 }
16569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16570 return resultobj;
16571 fail:
16572 return NULL;
16573 }
16574
16575
16576 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16577 PyObject *resultobj = 0;
16578 wxImage *arg1 = (wxImage *) 0 ;
16579 int arg2 ;
16580 int arg3 ;
16581 bool arg4 = (bool) true ;
16582 void *argp1 = 0 ;
16583 int res1 = 0 ;
16584 int val2 ;
16585 int ecode2 = 0 ;
16586 int val3 ;
16587 int ecode3 = 0 ;
16588 bool val4 ;
16589 int ecode4 = 0 ;
16590 PyObject * obj0 = 0 ;
16591 PyObject * obj1 = 0 ;
16592 PyObject * obj2 = 0 ;
16593 PyObject * obj3 = 0 ;
16594 char * kwnames[] = {
16595 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
16596 };
16597
16598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16600 if (!SWIG_IsOK(res1)) {
16601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
16602 }
16603 arg1 = reinterpret_cast< wxImage * >(argp1);
16604 ecode2 = SWIG_AsVal_int(obj1, &val2);
16605 if (!SWIG_IsOK(ecode2)) {
16606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
16607 }
16608 arg2 = static_cast< int >(val2);
16609 ecode3 = SWIG_AsVal_int(obj2, &val3);
16610 if (!SWIG_IsOK(ecode3)) {
16611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16612 }
16613 arg3 = static_cast< int >(val3);
16614 if (obj3) {
16615 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16616 if (!SWIG_IsOK(ecode4)) {
16617 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16618 }
16619 arg4 = static_cast< bool >(val4);
16620 }
16621 {
16622 PyThreadState* __tstate = wxPyBeginAllowThreads();
16623 (arg1)->Create(arg2,arg3,arg4);
16624 wxPyEndAllowThreads(__tstate);
16625 if (PyErr_Occurred()) SWIG_fail;
16626 }
16627 resultobj = SWIG_Py_Void();
16628 return resultobj;
16629 fail:
16630 return NULL;
16631 }
16632
16633
16634 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16635 PyObject *resultobj = 0;
16636 wxImage *arg1 = (wxImage *) 0 ;
16637 void *argp1 = 0 ;
16638 int res1 = 0 ;
16639 PyObject *swig_obj[1] ;
16640
16641 if (!args) SWIG_fail;
16642 swig_obj[0] = args;
16643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16644 if (!SWIG_IsOK(res1)) {
16645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16646 }
16647 arg1 = reinterpret_cast< wxImage * >(argp1);
16648 {
16649 PyThreadState* __tstate = wxPyBeginAllowThreads();
16650 (arg1)->Destroy();
16651 wxPyEndAllowThreads(__tstate);
16652 if (PyErr_Occurred()) SWIG_fail;
16653 }
16654 resultobj = SWIG_Py_Void();
16655 return resultobj;
16656 fail:
16657 return NULL;
16658 }
16659
16660
16661 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16662 PyObject *resultobj = 0;
16663 wxImage *arg1 = (wxImage *) 0 ;
16664 int arg2 ;
16665 int arg3 ;
16666 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16667 SwigValueWrapper<wxImage > result;
16668 void *argp1 = 0 ;
16669 int res1 = 0 ;
16670 int val2 ;
16671 int ecode2 = 0 ;
16672 int val3 ;
16673 int ecode3 = 0 ;
16674 int val4 ;
16675 int ecode4 = 0 ;
16676 PyObject * obj0 = 0 ;
16677 PyObject * obj1 = 0 ;
16678 PyObject * obj2 = 0 ;
16679 PyObject * obj3 = 0 ;
16680 char * kwnames[] = {
16681 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16682 };
16683
16684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16686 if (!SWIG_IsOK(res1)) {
16687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16688 }
16689 arg1 = reinterpret_cast< wxImage * >(argp1);
16690 ecode2 = SWIG_AsVal_int(obj1, &val2);
16691 if (!SWIG_IsOK(ecode2)) {
16692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16693 }
16694 arg2 = static_cast< int >(val2);
16695 ecode3 = SWIG_AsVal_int(obj2, &val3);
16696 if (!SWIG_IsOK(ecode3)) {
16697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16698 }
16699 arg3 = static_cast< int >(val3);
16700 if (obj3) {
16701 ecode4 = SWIG_AsVal_int(obj3, &val4);
16702 if (!SWIG_IsOK(ecode4)) {
16703 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16704 }
16705 arg4 = static_cast< int >(val4);
16706 }
16707 {
16708 PyThreadState* __tstate = wxPyBeginAllowThreads();
16709 result = (arg1)->Scale(arg2,arg3,arg4);
16710 wxPyEndAllowThreads(__tstate);
16711 if (PyErr_Occurred()) SWIG_fail;
16712 }
16713 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16714 return resultobj;
16715 fail:
16716 return NULL;
16717 }
16718
16719
16720 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16721 PyObject *resultobj = 0;
16722 wxImage *arg1 = (wxImage *) 0 ;
16723 int arg2 ;
16724 int arg3 ;
16725 SwigValueWrapper<wxImage > result;
16726 void *argp1 = 0 ;
16727 int res1 = 0 ;
16728 int val2 ;
16729 int ecode2 = 0 ;
16730 int val3 ;
16731 int ecode3 = 0 ;
16732 PyObject * obj0 = 0 ;
16733 PyObject * obj1 = 0 ;
16734 PyObject * obj2 = 0 ;
16735 char * kwnames[] = {
16736 (char *) "self",(char *) "width",(char *) "height", NULL
16737 };
16738
16739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16741 if (!SWIG_IsOK(res1)) {
16742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16743 }
16744 arg1 = reinterpret_cast< wxImage * >(argp1);
16745 ecode2 = SWIG_AsVal_int(obj1, &val2);
16746 if (!SWIG_IsOK(ecode2)) {
16747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16748 }
16749 arg2 = static_cast< int >(val2);
16750 ecode3 = SWIG_AsVal_int(obj2, &val3);
16751 if (!SWIG_IsOK(ecode3)) {
16752 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16753 }
16754 arg3 = static_cast< int >(val3);
16755 {
16756 PyThreadState* __tstate = wxPyBeginAllowThreads();
16757 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16758 wxPyEndAllowThreads(__tstate);
16759 if (PyErr_Occurred()) SWIG_fail;
16760 }
16761 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16762 return resultobj;
16763 fail:
16764 return NULL;
16765 }
16766
16767
16768 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16769 PyObject *resultobj = 0;
16770 wxImage *arg1 = (wxImage *) 0 ;
16771 int arg2 ;
16772 int arg3 ;
16773 SwigValueWrapper<wxImage > result;
16774 void *argp1 = 0 ;
16775 int res1 = 0 ;
16776 int val2 ;
16777 int ecode2 = 0 ;
16778 int val3 ;
16779 int ecode3 = 0 ;
16780 PyObject * obj0 = 0 ;
16781 PyObject * obj1 = 0 ;
16782 PyObject * obj2 = 0 ;
16783 char * kwnames[] = {
16784 (char *) "self",(char *) "width",(char *) "height", NULL
16785 };
16786
16787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16789 if (!SWIG_IsOK(res1)) {
16790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16791 }
16792 arg1 = reinterpret_cast< wxImage * >(argp1);
16793 ecode2 = SWIG_AsVal_int(obj1, &val2);
16794 if (!SWIG_IsOK(ecode2)) {
16795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16796 }
16797 arg2 = static_cast< int >(val2);
16798 ecode3 = SWIG_AsVal_int(obj2, &val3);
16799 if (!SWIG_IsOK(ecode3)) {
16800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16801 }
16802 arg3 = static_cast< int >(val3);
16803 {
16804 PyThreadState* __tstate = wxPyBeginAllowThreads();
16805 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16806 wxPyEndAllowThreads(__tstate);
16807 if (PyErr_Occurred()) SWIG_fail;
16808 }
16809 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16810 return resultobj;
16811 fail:
16812 return NULL;
16813 }
16814
16815
16816 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16817 PyObject *resultobj = 0;
16818 wxImage *arg1 = (wxImage *) 0 ;
16819 int arg2 ;
16820 SwigValueWrapper<wxImage > result;
16821 void *argp1 = 0 ;
16822 int res1 = 0 ;
16823 int val2 ;
16824 int ecode2 = 0 ;
16825 PyObject * obj0 = 0 ;
16826 PyObject * obj1 = 0 ;
16827 char * kwnames[] = {
16828 (char *) "self",(char *) "radius", NULL
16829 };
16830
16831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16833 if (!SWIG_IsOK(res1)) {
16834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16835 }
16836 arg1 = reinterpret_cast< wxImage * >(argp1);
16837 ecode2 = SWIG_AsVal_int(obj1, &val2);
16838 if (!SWIG_IsOK(ecode2)) {
16839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16840 }
16841 arg2 = static_cast< int >(val2);
16842 {
16843 PyThreadState* __tstate = wxPyBeginAllowThreads();
16844 result = (arg1)->Blur(arg2);
16845 wxPyEndAllowThreads(__tstate);
16846 if (PyErr_Occurred()) SWIG_fail;
16847 }
16848 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16849 return resultobj;
16850 fail:
16851 return NULL;
16852 }
16853
16854
16855 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16856 PyObject *resultobj = 0;
16857 wxImage *arg1 = (wxImage *) 0 ;
16858 int arg2 ;
16859 SwigValueWrapper<wxImage > result;
16860 void *argp1 = 0 ;
16861 int res1 = 0 ;
16862 int val2 ;
16863 int ecode2 = 0 ;
16864 PyObject * obj0 = 0 ;
16865 PyObject * obj1 = 0 ;
16866 char * kwnames[] = {
16867 (char *) "self",(char *) "radius", NULL
16868 };
16869
16870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16872 if (!SWIG_IsOK(res1)) {
16873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16874 }
16875 arg1 = reinterpret_cast< wxImage * >(argp1);
16876 ecode2 = SWIG_AsVal_int(obj1, &val2);
16877 if (!SWIG_IsOK(ecode2)) {
16878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16879 }
16880 arg2 = static_cast< int >(val2);
16881 {
16882 PyThreadState* __tstate = wxPyBeginAllowThreads();
16883 result = (arg1)->BlurHorizontal(arg2);
16884 wxPyEndAllowThreads(__tstate);
16885 if (PyErr_Occurred()) SWIG_fail;
16886 }
16887 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16888 return resultobj;
16889 fail:
16890 return NULL;
16891 }
16892
16893
16894 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16895 PyObject *resultobj = 0;
16896 wxImage *arg1 = (wxImage *) 0 ;
16897 int arg2 ;
16898 SwigValueWrapper<wxImage > result;
16899 void *argp1 = 0 ;
16900 int res1 = 0 ;
16901 int val2 ;
16902 int ecode2 = 0 ;
16903 PyObject * obj0 = 0 ;
16904 PyObject * obj1 = 0 ;
16905 char * kwnames[] = {
16906 (char *) "self",(char *) "radius", NULL
16907 };
16908
16909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16911 if (!SWIG_IsOK(res1)) {
16912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16913 }
16914 arg1 = reinterpret_cast< wxImage * >(argp1);
16915 ecode2 = SWIG_AsVal_int(obj1, &val2);
16916 if (!SWIG_IsOK(ecode2)) {
16917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16918 }
16919 arg2 = static_cast< int >(val2);
16920 {
16921 PyThreadState* __tstate = wxPyBeginAllowThreads();
16922 result = (arg1)->BlurVertical(arg2);
16923 wxPyEndAllowThreads(__tstate);
16924 if (PyErr_Occurred()) SWIG_fail;
16925 }
16926 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16927 return resultobj;
16928 fail:
16929 return NULL;
16930 }
16931
16932
16933 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16934 PyObject *resultobj = 0;
16935 wxImage *arg1 = (wxImage *) 0 ;
16936 int arg2 ;
16937 int arg3 ;
16938 SwigValueWrapper<wxImage > result;
16939 void *argp1 = 0 ;
16940 int res1 = 0 ;
16941 int val2 ;
16942 int ecode2 = 0 ;
16943 int val3 ;
16944 int ecode3 = 0 ;
16945 PyObject * obj0 = 0 ;
16946 PyObject * obj1 = 0 ;
16947 PyObject * obj2 = 0 ;
16948 char * kwnames[] = {
16949 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16950 };
16951
16952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16954 if (!SWIG_IsOK(res1)) {
16955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16956 }
16957 arg1 = reinterpret_cast< wxImage * >(argp1);
16958 ecode2 = SWIG_AsVal_int(obj1, &val2);
16959 if (!SWIG_IsOK(ecode2)) {
16960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16961 }
16962 arg2 = static_cast< int >(val2);
16963 ecode3 = SWIG_AsVal_int(obj2, &val3);
16964 if (!SWIG_IsOK(ecode3)) {
16965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16966 }
16967 arg3 = static_cast< int >(val3);
16968 {
16969 PyThreadState* __tstate = wxPyBeginAllowThreads();
16970 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16971 wxPyEndAllowThreads(__tstate);
16972 if (PyErr_Occurred()) SWIG_fail;
16973 }
16974 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16975 return resultobj;
16976 fail:
16977 return NULL;
16978 }
16979
16980
16981 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16982 PyObject *resultobj = 0;
16983 wxImage *arg1 = (wxImage *) 0 ;
16984 int arg2 ;
16985 int arg3 ;
16986 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16987 wxImage *result = 0 ;
16988 void *argp1 = 0 ;
16989 int res1 = 0 ;
16990 int val2 ;
16991 int ecode2 = 0 ;
16992 int val3 ;
16993 int ecode3 = 0 ;
16994 int val4 ;
16995 int ecode4 = 0 ;
16996 PyObject * obj0 = 0 ;
16997 PyObject * obj1 = 0 ;
16998 PyObject * obj2 = 0 ;
16999 PyObject * obj3 = 0 ;
17000 char * kwnames[] = {
17001 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
17002 };
17003
17004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17006 if (!SWIG_IsOK(res1)) {
17007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
17008 }
17009 arg1 = reinterpret_cast< wxImage * >(argp1);
17010 ecode2 = SWIG_AsVal_int(obj1, &val2);
17011 if (!SWIG_IsOK(ecode2)) {
17012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
17013 }
17014 arg2 = static_cast< int >(val2);
17015 ecode3 = SWIG_AsVal_int(obj2, &val3);
17016 if (!SWIG_IsOK(ecode3)) {
17017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
17018 }
17019 arg3 = static_cast< int >(val3);
17020 if (obj3) {
17021 ecode4 = SWIG_AsVal_int(obj3, &val4);
17022 if (!SWIG_IsOK(ecode4)) {
17023 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
17024 }
17025 arg4 = static_cast< int >(val4);
17026 }
17027 {
17028 PyThreadState* __tstate = wxPyBeginAllowThreads();
17029 {
17030 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
17031 result = (wxImage *) &_result_ref;
17032 }
17033 wxPyEndAllowThreads(__tstate);
17034 if (PyErr_Occurred()) SWIG_fail;
17035 }
17036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
17037 return resultobj;
17038 fail:
17039 return NULL;
17040 }
17041
17042
17043 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17044 PyObject *resultobj = 0;
17045 wxImage *arg1 = (wxImage *) 0 ;
17046 wxSize *arg2 = 0 ;
17047 wxPoint *arg3 = 0 ;
17048 int arg4 = (int) -1 ;
17049 int arg5 = (int) -1 ;
17050 int arg6 = (int) -1 ;
17051 wxImage *result = 0 ;
17052 void *argp1 = 0 ;
17053 int res1 = 0 ;
17054 wxSize temp2 ;
17055 wxPoint temp3 ;
17056 int val4 ;
17057 int ecode4 = 0 ;
17058 int val5 ;
17059 int ecode5 = 0 ;
17060 int val6 ;
17061 int ecode6 = 0 ;
17062 PyObject * obj0 = 0 ;
17063 PyObject * obj1 = 0 ;
17064 PyObject * obj2 = 0 ;
17065 PyObject * obj3 = 0 ;
17066 PyObject * obj4 = 0 ;
17067 PyObject * obj5 = 0 ;
17068 char * kwnames[] = {
17069 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
17070 };
17071
17072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17074 if (!SWIG_IsOK(res1)) {
17075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
17076 }
17077 arg1 = reinterpret_cast< wxImage * >(argp1);
17078 {
17079 arg2 = &temp2;
17080 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17081 }
17082 {
17083 arg3 = &temp3;
17084 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17085 }
17086 if (obj3) {
17087 ecode4 = SWIG_AsVal_int(obj3, &val4);
17088 if (!SWIG_IsOK(ecode4)) {
17089 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
17090 }
17091 arg4 = static_cast< int >(val4);
17092 }
17093 if (obj4) {
17094 ecode5 = SWIG_AsVal_int(obj4, &val5);
17095 if (!SWIG_IsOK(ecode5)) {
17096 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
17097 }
17098 arg5 = static_cast< int >(val5);
17099 }
17100 if (obj5) {
17101 ecode6 = SWIG_AsVal_int(obj5, &val6);
17102 if (!SWIG_IsOK(ecode6)) {
17103 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
17104 }
17105 arg6 = static_cast< int >(val6);
17106 }
17107 {
17108 PyThreadState* __tstate = wxPyBeginAllowThreads();
17109 {
17110 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
17111 result = (wxImage *) &_result_ref;
17112 }
17113 wxPyEndAllowThreads(__tstate);
17114 if (PyErr_Occurred()) SWIG_fail;
17115 }
17116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
17117 return resultobj;
17118 fail:
17119 return NULL;
17120 }
17121
17122
17123 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17124 PyObject *resultobj = 0;
17125 wxImage *arg1 = (wxImage *) 0 ;
17126 int arg2 ;
17127 int arg3 ;
17128 byte arg4 ;
17129 byte arg5 ;
17130 byte arg6 ;
17131 void *argp1 = 0 ;
17132 int res1 = 0 ;
17133 int val2 ;
17134 int ecode2 = 0 ;
17135 int val3 ;
17136 int ecode3 = 0 ;
17137 unsigned char val4 ;
17138 int ecode4 = 0 ;
17139 unsigned char val5 ;
17140 int ecode5 = 0 ;
17141 unsigned char val6 ;
17142 int ecode6 = 0 ;
17143 PyObject * obj0 = 0 ;
17144 PyObject * obj1 = 0 ;
17145 PyObject * obj2 = 0 ;
17146 PyObject * obj3 = 0 ;
17147 PyObject * obj4 = 0 ;
17148 PyObject * obj5 = 0 ;
17149 char * kwnames[] = {
17150 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
17151 };
17152
17153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17155 if (!SWIG_IsOK(res1)) {
17156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
17157 }
17158 arg1 = reinterpret_cast< wxImage * >(argp1);
17159 ecode2 = SWIG_AsVal_int(obj1, &val2);
17160 if (!SWIG_IsOK(ecode2)) {
17161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
17162 }
17163 arg2 = static_cast< int >(val2);
17164 ecode3 = SWIG_AsVal_int(obj2, &val3);
17165 if (!SWIG_IsOK(ecode3)) {
17166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
17167 }
17168 arg3 = static_cast< int >(val3);
17169 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17170 if (!SWIG_IsOK(ecode4)) {
17171 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
17172 }
17173 arg4 = static_cast< byte >(val4);
17174 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17175 if (!SWIG_IsOK(ecode5)) {
17176 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
17177 }
17178 arg5 = static_cast< byte >(val5);
17179 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
17180 if (!SWIG_IsOK(ecode6)) {
17181 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
17182 }
17183 arg6 = static_cast< byte >(val6);
17184 {
17185 PyThreadState* __tstate = wxPyBeginAllowThreads();
17186 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
17187 wxPyEndAllowThreads(__tstate);
17188 if (PyErr_Occurred()) SWIG_fail;
17189 }
17190 resultobj = SWIG_Py_Void();
17191 return resultobj;
17192 fail:
17193 return NULL;
17194 }
17195
17196
17197 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17198 PyObject *resultobj = 0;
17199 wxImage *arg1 = (wxImage *) 0 ;
17200 wxRect *arg2 = 0 ;
17201 byte arg3 ;
17202 byte arg4 ;
17203 byte arg5 ;
17204 void *argp1 = 0 ;
17205 int res1 = 0 ;
17206 wxRect temp2 ;
17207 unsigned char val3 ;
17208 int ecode3 = 0 ;
17209 unsigned char val4 ;
17210 int ecode4 = 0 ;
17211 unsigned char val5 ;
17212 int ecode5 = 0 ;
17213 PyObject * obj0 = 0 ;
17214 PyObject * obj1 = 0 ;
17215 PyObject * obj2 = 0 ;
17216 PyObject * obj3 = 0 ;
17217 PyObject * obj4 = 0 ;
17218 char * kwnames[] = {
17219 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
17220 };
17221
17222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17224 if (!SWIG_IsOK(res1)) {
17225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
17226 }
17227 arg1 = reinterpret_cast< wxImage * >(argp1);
17228 {
17229 arg2 = &temp2;
17230 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17231 }
17232 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17233 if (!SWIG_IsOK(ecode3)) {
17234 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
17235 }
17236 arg3 = static_cast< byte >(val3);
17237 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17238 if (!SWIG_IsOK(ecode4)) {
17239 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
17240 }
17241 arg4 = static_cast< byte >(val4);
17242 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17243 if (!SWIG_IsOK(ecode5)) {
17244 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
17245 }
17246 arg5 = static_cast< byte >(val5);
17247 {
17248 PyThreadState* __tstate = wxPyBeginAllowThreads();
17249 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
17250 wxPyEndAllowThreads(__tstate);
17251 if (PyErr_Occurred()) SWIG_fail;
17252 }
17253 resultobj = SWIG_Py_Void();
17254 return resultobj;
17255 fail:
17256 return NULL;
17257 }
17258
17259
17260 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17261 PyObject *resultobj = 0;
17262 wxImage *arg1 = (wxImage *) 0 ;
17263 int arg2 ;
17264 int arg3 ;
17265 byte result;
17266 void *argp1 = 0 ;
17267 int res1 = 0 ;
17268 int val2 ;
17269 int ecode2 = 0 ;
17270 int val3 ;
17271 int ecode3 = 0 ;
17272 PyObject * obj0 = 0 ;
17273 PyObject * obj1 = 0 ;
17274 PyObject * obj2 = 0 ;
17275 char * kwnames[] = {
17276 (char *) "self",(char *) "x",(char *) "y", NULL
17277 };
17278
17279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17281 if (!SWIG_IsOK(res1)) {
17282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
17283 }
17284 arg1 = reinterpret_cast< wxImage * >(argp1);
17285 ecode2 = SWIG_AsVal_int(obj1, &val2);
17286 if (!SWIG_IsOK(ecode2)) {
17287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
17288 }
17289 arg2 = static_cast< int >(val2);
17290 ecode3 = SWIG_AsVal_int(obj2, &val3);
17291 if (!SWIG_IsOK(ecode3)) {
17292 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
17293 }
17294 arg3 = static_cast< int >(val3);
17295 {
17296 PyThreadState* __tstate = wxPyBeginAllowThreads();
17297 result = (byte)(arg1)->GetRed(arg2,arg3);
17298 wxPyEndAllowThreads(__tstate);
17299 if (PyErr_Occurred()) SWIG_fail;
17300 }
17301 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17302 return resultobj;
17303 fail:
17304 return NULL;
17305 }
17306
17307
17308 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17309 PyObject *resultobj = 0;
17310 wxImage *arg1 = (wxImage *) 0 ;
17311 int arg2 ;
17312 int arg3 ;
17313 byte result;
17314 void *argp1 = 0 ;
17315 int res1 = 0 ;
17316 int val2 ;
17317 int ecode2 = 0 ;
17318 int val3 ;
17319 int ecode3 = 0 ;
17320 PyObject * obj0 = 0 ;
17321 PyObject * obj1 = 0 ;
17322 PyObject * obj2 = 0 ;
17323 char * kwnames[] = {
17324 (char *) "self",(char *) "x",(char *) "y", NULL
17325 };
17326
17327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17329 if (!SWIG_IsOK(res1)) {
17330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
17331 }
17332 arg1 = reinterpret_cast< wxImage * >(argp1);
17333 ecode2 = SWIG_AsVal_int(obj1, &val2);
17334 if (!SWIG_IsOK(ecode2)) {
17335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
17336 }
17337 arg2 = static_cast< int >(val2);
17338 ecode3 = SWIG_AsVal_int(obj2, &val3);
17339 if (!SWIG_IsOK(ecode3)) {
17340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
17341 }
17342 arg3 = static_cast< int >(val3);
17343 {
17344 PyThreadState* __tstate = wxPyBeginAllowThreads();
17345 result = (byte)(arg1)->GetGreen(arg2,arg3);
17346 wxPyEndAllowThreads(__tstate);
17347 if (PyErr_Occurred()) SWIG_fail;
17348 }
17349 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17350 return resultobj;
17351 fail:
17352 return NULL;
17353 }
17354
17355
17356 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17357 PyObject *resultobj = 0;
17358 wxImage *arg1 = (wxImage *) 0 ;
17359 int arg2 ;
17360 int arg3 ;
17361 byte result;
17362 void *argp1 = 0 ;
17363 int res1 = 0 ;
17364 int val2 ;
17365 int ecode2 = 0 ;
17366 int val3 ;
17367 int ecode3 = 0 ;
17368 PyObject * obj0 = 0 ;
17369 PyObject * obj1 = 0 ;
17370 PyObject * obj2 = 0 ;
17371 char * kwnames[] = {
17372 (char *) "self",(char *) "x",(char *) "y", NULL
17373 };
17374
17375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17377 if (!SWIG_IsOK(res1)) {
17378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
17379 }
17380 arg1 = reinterpret_cast< wxImage * >(argp1);
17381 ecode2 = SWIG_AsVal_int(obj1, &val2);
17382 if (!SWIG_IsOK(ecode2)) {
17383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
17384 }
17385 arg2 = static_cast< int >(val2);
17386 ecode3 = SWIG_AsVal_int(obj2, &val3);
17387 if (!SWIG_IsOK(ecode3)) {
17388 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
17389 }
17390 arg3 = static_cast< int >(val3);
17391 {
17392 PyThreadState* __tstate = wxPyBeginAllowThreads();
17393 result = (byte)(arg1)->GetBlue(arg2,arg3);
17394 wxPyEndAllowThreads(__tstate);
17395 if (PyErr_Occurred()) SWIG_fail;
17396 }
17397 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17398 return resultobj;
17399 fail:
17400 return NULL;
17401 }
17402
17403
17404 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17405 PyObject *resultobj = 0;
17406 wxImage *arg1 = (wxImage *) 0 ;
17407 int arg2 ;
17408 int arg3 ;
17409 byte arg4 ;
17410 void *argp1 = 0 ;
17411 int res1 = 0 ;
17412 int val2 ;
17413 int ecode2 = 0 ;
17414 int val3 ;
17415 int ecode3 = 0 ;
17416 unsigned char val4 ;
17417 int ecode4 = 0 ;
17418 PyObject * obj0 = 0 ;
17419 PyObject * obj1 = 0 ;
17420 PyObject * obj2 = 0 ;
17421 PyObject * obj3 = 0 ;
17422 char * kwnames[] = {
17423 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
17424 };
17425
17426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17428 if (!SWIG_IsOK(res1)) {
17429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17430 }
17431 arg1 = reinterpret_cast< wxImage * >(argp1);
17432 ecode2 = SWIG_AsVal_int(obj1, &val2);
17433 if (!SWIG_IsOK(ecode2)) {
17434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
17435 }
17436 arg2 = static_cast< int >(val2);
17437 ecode3 = SWIG_AsVal_int(obj2, &val3);
17438 if (!SWIG_IsOK(ecode3)) {
17439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
17440 }
17441 arg3 = static_cast< int >(val3);
17442 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17443 if (!SWIG_IsOK(ecode4)) {
17444 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
17445 }
17446 arg4 = static_cast< byte >(val4);
17447 {
17448 PyThreadState* __tstate = wxPyBeginAllowThreads();
17449 (arg1)->SetAlpha(arg2,arg3,arg4);
17450 wxPyEndAllowThreads(__tstate);
17451 if (PyErr_Occurred()) SWIG_fail;
17452 }
17453 resultobj = SWIG_Py_Void();
17454 return resultobj;
17455 fail:
17456 return NULL;
17457 }
17458
17459
17460 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17461 PyObject *resultobj = 0;
17462 wxImage *arg1 = (wxImage *) 0 ;
17463 int arg2 ;
17464 int arg3 ;
17465 byte result;
17466 void *argp1 = 0 ;
17467 int res1 = 0 ;
17468 int val2 ;
17469 int ecode2 = 0 ;
17470 int val3 ;
17471 int ecode3 = 0 ;
17472 PyObject * obj0 = 0 ;
17473 PyObject * obj1 = 0 ;
17474 PyObject * obj2 = 0 ;
17475 char * kwnames[] = {
17476 (char *) "self",(char *) "x",(char *) "y", NULL
17477 };
17478
17479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17481 if (!SWIG_IsOK(res1)) {
17482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17483 }
17484 arg1 = reinterpret_cast< wxImage * >(argp1);
17485 ecode2 = SWIG_AsVal_int(obj1, &val2);
17486 if (!SWIG_IsOK(ecode2)) {
17487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
17488 }
17489 arg2 = static_cast< int >(val2);
17490 ecode3 = SWIG_AsVal_int(obj2, &val3);
17491 if (!SWIG_IsOK(ecode3)) {
17492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
17493 }
17494 arg3 = static_cast< int >(val3);
17495 {
17496 PyThreadState* __tstate = wxPyBeginAllowThreads();
17497 result = (byte)(arg1)->GetAlpha(arg2,arg3);
17498 wxPyEndAllowThreads(__tstate);
17499 if (PyErr_Occurred()) SWIG_fail;
17500 }
17501 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17502 return resultobj;
17503 fail:
17504 return NULL;
17505 }
17506
17507
17508 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17509 PyObject *resultobj = 0;
17510 wxImage *arg1 = (wxImage *) 0 ;
17511 bool result;
17512 void *argp1 = 0 ;
17513 int res1 = 0 ;
17514 PyObject *swig_obj[1] ;
17515
17516 if (!args) SWIG_fail;
17517 swig_obj[0] = args;
17518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17519 if (!SWIG_IsOK(res1)) {
17520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17521 }
17522 arg1 = reinterpret_cast< wxImage * >(argp1);
17523 {
17524 PyThreadState* __tstate = wxPyBeginAllowThreads();
17525 result = (bool)(arg1)->HasAlpha();
17526 wxPyEndAllowThreads(__tstate);
17527 if (PyErr_Occurred()) SWIG_fail;
17528 }
17529 {
17530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17531 }
17532 return resultobj;
17533 fail:
17534 return NULL;
17535 }
17536
17537
17538 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17539 PyObject *resultobj = 0;
17540 wxImage *arg1 = (wxImage *) 0 ;
17541 void *argp1 = 0 ;
17542 int res1 = 0 ;
17543 PyObject *swig_obj[1] ;
17544
17545 if (!args) SWIG_fail;
17546 swig_obj[0] = args;
17547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17548 if (!SWIG_IsOK(res1)) {
17549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17550 }
17551 arg1 = reinterpret_cast< wxImage * >(argp1);
17552 {
17553 PyThreadState* __tstate = wxPyBeginAllowThreads();
17554 (arg1)->InitAlpha();
17555 wxPyEndAllowThreads(__tstate);
17556 if (PyErr_Occurred()) SWIG_fail;
17557 }
17558 resultobj = SWIG_Py_Void();
17559 return resultobj;
17560 fail:
17561 return NULL;
17562 }
17563
17564
17565 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17566 PyObject *resultobj = 0;
17567 wxImage *arg1 = (wxImage *) 0 ;
17568 int arg2 ;
17569 int arg3 ;
17570 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17571 bool result;
17572 void *argp1 = 0 ;
17573 int res1 = 0 ;
17574 int val2 ;
17575 int ecode2 = 0 ;
17576 int val3 ;
17577 int ecode3 = 0 ;
17578 unsigned char val4 ;
17579 int ecode4 = 0 ;
17580 PyObject * obj0 = 0 ;
17581 PyObject * obj1 = 0 ;
17582 PyObject * obj2 = 0 ;
17583 PyObject * obj3 = 0 ;
17584 char * kwnames[] = {
17585 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
17586 };
17587
17588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17590 if (!SWIG_IsOK(res1)) {
17591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
17592 }
17593 arg1 = reinterpret_cast< wxImage * >(argp1);
17594 ecode2 = SWIG_AsVal_int(obj1, &val2);
17595 if (!SWIG_IsOK(ecode2)) {
17596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
17597 }
17598 arg2 = static_cast< int >(val2);
17599 ecode3 = SWIG_AsVal_int(obj2, &val3);
17600 if (!SWIG_IsOK(ecode3)) {
17601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
17602 }
17603 arg3 = static_cast< int >(val3);
17604 if (obj3) {
17605 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17606 if (!SWIG_IsOK(ecode4)) {
17607 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
17608 }
17609 arg4 = static_cast< byte >(val4);
17610 }
17611 {
17612 PyThreadState* __tstate = wxPyBeginAllowThreads();
17613 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17614 wxPyEndAllowThreads(__tstate);
17615 if (PyErr_Occurred()) SWIG_fail;
17616 }
17617 {
17618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17619 }
17620 return resultobj;
17621 fail:
17622 return NULL;
17623 }
17624
17625
17626 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17627 PyObject *resultobj = 0;
17628 wxImage *arg1 = (wxImage *) 0 ;
17629 byte *arg2 = (byte *) 0 ;
17630 byte *arg3 = (byte *) 0 ;
17631 byte *arg4 = (byte *) 0 ;
17632 byte arg5 = (byte) 0 ;
17633 byte arg6 = (byte) 0 ;
17634 byte arg7 = (byte) 0 ;
17635 bool result;
17636 void *argp1 = 0 ;
17637 int res1 = 0 ;
17638 byte temp2 ;
17639 int res2 = SWIG_TMPOBJ ;
17640 byte temp3 ;
17641 int res3 = SWIG_TMPOBJ ;
17642 byte temp4 ;
17643 int res4 = SWIG_TMPOBJ ;
17644 unsigned char val5 ;
17645 int ecode5 = 0 ;
17646 unsigned char val6 ;
17647 int ecode6 = 0 ;
17648 unsigned char val7 ;
17649 int ecode7 = 0 ;
17650 PyObject * obj0 = 0 ;
17651 PyObject * obj1 = 0 ;
17652 PyObject * obj2 = 0 ;
17653 PyObject * obj3 = 0 ;
17654 char * kwnames[] = {
17655 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17656 };
17657
17658 arg2 = &temp2;
17659 arg3 = &temp3;
17660 arg4 = &temp4;
17661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17663 if (!SWIG_IsOK(res1)) {
17664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17665 }
17666 arg1 = reinterpret_cast< wxImage * >(argp1);
17667 if (obj1) {
17668 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17669 if (!SWIG_IsOK(ecode5)) {
17670 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17671 }
17672 arg5 = static_cast< byte >(val5);
17673 }
17674 if (obj2) {
17675 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17676 if (!SWIG_IsOK(ecode6)) {
17677 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17678 }
17679 arg6 = static_cast< byte >(val6);
17680 }
17681 if (obj3) {
17682 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17683 if (!SWIG_IsOK(ecode7)) {
17684 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17685 }
17686 arg7 = static_cast< byte >(val7);
17687 }
17688 {
17689 PyThreadState* __tstate = wxPyBeginAllowThreads();
17690 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17691 wxPyEndAllowThreads(__tstate);
17692 if (PyErr_Occurred()) SWIG_fail;
17693 }
17694 {
17695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17696 }
17697 if (SWIG_IsTmpObj(res2)) {
17698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17699 } else {
17700 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17702 }
17703 if (SWIG_IsTmpObj(res3)) {
17704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17705 } else {
17706 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17707 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17708 }
17709 if (SWIG_IsTmpObj(res4)) {
17710 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17711 } else {
17712 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17713 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17714 }
17715 return resultobj;
17716 fail:
17717 return NULL;
17718 }
17719
17720
17721 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17722 PyObject *resultobj = 0;
17723 wxImage *arg1 = (wxImage *) 0 ;
17724 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17725 bool result;
17726 void *argp1 = 0 ;
17727 int res1 = 0 ;
17728 unsigned char val2 ;
17729 int ecode2 = 0 ;
17730 PyObject * obj0 = 0 ;
17731 PyObject * obj1 = 0 ;
17732 char * kwnames[] = {
17733 (char *) "self",(char *) "threshold", NULL
17734 };
17735
17736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17738 if (!SWIG_IsOK(res1)) {
17739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17740 }
17741 arg1 = reinterpret_cast< wxImage * >(argp1);
17742 if (obj1) {
17743 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17744 if (!SWIG_IsOK(ecode2)) {
17745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17746 }
17747 arg2 = static_cast< byte >(val2);
17748 }
17749 {
17750 PyThreadState* __tstate = wxPyBeginAllowThreads();
17751 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17752 wxPyEndAllowThreads(__tstate);
17753 if (PyErr_Occurred()) SWIG_fail;
17754 }
17755 {
17756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17757 }
17758 return resultobj;
17759 fail:
17760 return NULL;
17761 }
17762
17763
17764 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17765 PyObject *resultobj = 0;
17766 wxImage *arg1 = (wxImage *) 0 ;
17767 byte arg2 ;
17768 byte arg3 ;
17769 byte arg4 ;
17770 bool result;
17771 void *argp1 = 0 ;
17772 int res1 = 0 ;
17773 unsigned char val2 ;
17774 int ecode2 = 0 ;
17775 unsigned char val3 ;
17776 int ecode3 = 0 ;
17777 unsigned char val4 ;
17778 int ecode4 = 0 ;
17779 PyObject * obj0 = 0 ;
17780 PyObject * obj1 = 0 ;
17781 PyObject * obj2 = 0 ;
17782 PyObject * obj3 = 0 ;
17783 char * kwnames[] = {
17784 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17785 };
17786
17787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17789 if (!SWIG_IsOK(res1)) {
17790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17791 }
17792 arg1 = reinterpret_cast< wxImage * >(argp1);
17793 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17794 if (!SWIG_IsOK(ecode2)) {
17795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17796 }
17797 arg2 = static_cast< byte >(val2);
17798 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17799 if (!SWIG_IsOK(ecode3)) {
17800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17801 }
17802 arg3 = static_cast< byte >(val3);
17803 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17804 if (!SWIG_IsOK(ecode4)) {
17805 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17806 }
17807 arg4 = static_cast< byte >(val4);
17808 {
17809 PyThreadState* __tstate = wxPyBeginAllowThreads();
17810 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17811 wxPyEndAllowThreads(__tstate);
17812 if (PyErr_Occurred()) SWIG_fail;
17813 }
17814 {
17815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17816 }
17817 return resultobj;
17818 fail:
17819 return NULL;
17820 }
17821
17822
17823 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17824 PyObject *resultobj = 0;
17825 wxImage *arg1 = (wxImage *) 0 ;
17826 wxImage *arg2 = 0 ;
17827 byte arg3 ;
17828 byte arg4 ;
17829 byte arg5 ;
17830 bool result;
17831 void *argp1 = 0 ;
17832 int res1 = 0 ;
17833 void *argp2 = 0 ;
17834 int res2 = 0 ;
17835 unsigned char val3 ;
17836 int ecode3 = 0 ;
17837 unsigned char val4 ;
17838 int ecode4 = 0 ;
17839 unsigned char val5 ;
17840 int ecode5 = 0 ;
17841 PyObject * obj0 = 0 ;
17842 PyObject * obj1 = 0 ;
17843 PyObject * obj2 = 0 ;
17844 PyObject * obj3 = 0 ;
17845 PyObject * obj4 = 0 ;
17846 char * kwnames[] = {
17847 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17848 };
17849
17850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17852 if (!SWIG_IsOK(res1)) {
17853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17854 }
17855 arg1 = reinterpret_cast< wxImage * >(argp1);
17856 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17857 if (!SWIG_IsOK(res2)) {
17858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17859 }
17860 if (!argp2) {
17861 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17862 }
17863 arg2 = reinterpret_cast< wxImage * >(argp2);
17864 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17865 if (!SWIG_IsOK(ecode3)) {
17866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17867 }
17868 arg3 = static_cast< byte >(val3);
17869 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17870 if (!SWIG_IsOK(ecode4)) {
17871 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17872 }
17873 arg4 = static_cast< byte >(val4);
17874 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17875 if (!SWIG_IsOK(ecode5)) {
17876 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17877 }
17878 arg5 = static_cast< byte >(val5);
17879 {
17880 PyThreadState* __tstate = wxPyBeginAllowThreads();
17881 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17882 wxPyEndAllowThreads(__tstate);
17883 if (PyErr_Occurred()) SWIG_fail;
17884 }
17885 {
17886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17887 }
17888 return resultobj;
17889 fail:
17890 return NULL;
17891 }
17892
17893
17894 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17895 PyObject *resultobj = 0;
17896 wxString *arg1 = 0 ;
17897 bool result;
17898 bool temp1 = false ;
17899 PyObject * obj0 = 0 ;
17900 char * kwnames[] = {
17901 (char *) "filename", NULL
17902 };
17903
17904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17905 {
17906 arg1 = wxString_in_helper(obj0);
17907 if (arg1 == NULL) SWIG_fail;
17908 temp1 = true;
17909 }
17910 {
17911 PyThreadState* __tstate = wxPyBeginAllowThreads();
17912 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17913 wxPyEndAllowThreads(__tstate);
17914 if (PyErr_Occurred()) SWIG_fail;
17915 }
17916 {
17917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17918 }
17919 {
17920 if (temp1)
17921 delete arg1;
17922 }
17923 return resultobj;
17924 fail:
17925 {
17926 if (temp1)
17927 delete arg1;
17928 }
17929 return NULL;
17930 }
17931
17932
17933 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17934 PyObject *resultobj = 0;
17935 wxString *arg1 = 0 ;
17936 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17937 int result;
17938 bool temp1 = false ;
17939 long val2 ;
17940 int ecode2 = 0 ;
17941 PyObject * obj0 = 0 ;
17942 PyObject * obj1 = 0 ;
17943 char * kwnames[] = {
17944 (char *) "filename",(char *) "type", NULL
17945 };
17946
17947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17948 {
17949 arg1 = wxString_in_helper(obj0);
17950 if (arg1 == NULL) SWIG_fail;
17951 temp1 = true;
17952 }
17953 if (obj1) {
17954 ecode2 = SWIG_AsVal_long(obj1, &val2);
17955 if (!SWIG_IsOK(ecode2)) {
17956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17957 }
17958 arg2 = static_cast< long >(val2);
17959 }
17960 {
17961 PyThreadState* __tstate = wxPyBeginAllowThreads();
17962 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17963 wxPyEndAllowThreads(__tstate);
17964 if (PyErr_Occurred()) SWIG_fail;
17965 }
17966 resultobj = SWIG_From_int(static_cast< int >(result));
17967 {
17968 if (temp1)
17969 delete arg1;
17970 }
17971 return resultobj;
17972 fail:
17973 {
17974 if (temp1)
17975 delete arg1;
17976 }
17977 return NULL;
17978 }
17979
17980
17981 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17982 PyObject *resultobj = 0;
17983 wxImage *arg1 = (wxImage *) 0 ;
17984 wxString *arg2 = 0 ;
17985 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17986 int arg4 = (int) -1 ;
17987 bool result;
17988 void *argp1 = 0 ;
17989 int res1 = 0 ;
17990 bool temp2 = false ;
17991 long val3 ;
17992 int ecode3 = 0 ;
17993 int val4 ;
17994 int ecode4 = 0 ;
17995 PyObject * obj0 = 0 ;
17996 PyObject * obj1 = 0 ;
17997 PyObject * obj2 = 0 ;
17998 PyObject * obj3 = 0 ;
17999 char * kwnames[] = {
18000 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
18001 };
18002
18003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18005 if (!SWIG_IsOK(res1)) {
18006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
18007 }
18008 arg1 = reinterpret_cast< wxImage * >(argp1);
18009 {
18010 arg2 = wxString_in_helper(obj1);
18011 if (arg2 == NULL) SWIG_fail;
18012 temp2 = true;
18013 }
18014 if (obj2) {
18015 ecode3 = SWIG_AsVal_long(obj2, &val3);
18016 if (!SWIG_IsOK(ecode3)) {
18017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
18018 }
18019 arg3 = static_cast< long >(val3);
18020 }
18021 if (obj3) {
18022 ecode4 = SWIG_AsVal_int(obj3, &val4);
18023 if (!SWIG_IsOK(ecode4)) {
18024 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
18025 }
18026 arg4 = static_cast< int >(val4);
18027 }
18028 {
18029 PyThreadState* __tstate = wxPyBeginAllowThreads();
18030 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
18031 wxPyEndAllowThreads(__tstate);
18032 if (PyErr_Occurred()) SWIG_fail;
18033 }
18034 {
18035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18036 }
18037 {
18038 if (temp2)
18039 delete arg2;
18040 }
18041 return resultobj;
18042 fail:
18043 {
18044 if (temp2)
18045 delete arg2;
18046 }
18047 return NULL;
18048 }
18049
18050
18051 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18052 PyObject *resultobj = 0;
18053 wxImage *arg1 = (wxImage *) 0 ;
18054 wxString *arg2 = 0 ;
18055 wxString *arg3 = 0 ;
18056 int arg4 = (int) -1 ;
18057 bool result;
18058 void *argp1 = 0 ;
18059 int res1 = 0 ;
18060 bool temp2 = false ;
18061 bool temp3 = false ;
18062 int val4 ;
18063 int ecode4 = 0 ;
18064 PyObject * obj0 = 0 ;
18065 PyObject * obj1 = 0 ;
18066 PyObject * obj2 = 0 ;
18067 PyObject * obj3 = 0 ;
18068 char * kwnames[] = {
18069 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
18070 };
18071
18072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18074 if (!SWIG_IsOK(res1)) {
18075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
18076 }
18077 arg1 = reinterpret_cast< wxImage * >(argp1);
18078 {
18079 arg2 = wxString_in_helper(obj1);
18080 if (arg2 == NULL) SWIG_fail;
18081 temp2 = true;
18082 }
18083 {
18084 arg3 = wxString_in_helper(obj2);
18085 if (arg3 == NULL) SWIG_fail;
18086 temp3 = true;
18087 }
18088 if (obj3) {
18089 ecode4 = SWIG_AsVal_int(obj3, &val4);
18090 if (!SWIG_IsOK(ecode4)) {
18091 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
18092 }
18093 arg4 = static_cast< int >(val4);
18094 }
18095 {
18096 PyThreadState* __tstate = wxPyBeginAllowThreads();
18097 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18098 wxPyEndAllowThreads(__tstate);
18099 if (PyErr_Occurred()) SWIG_fail;
18100 }
18101 {
18102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18103 }
18104 {
18105 if (temp2)
18106 delete arg2;
18107 }
18108 {
18109 if (temp3)
18110 delete arg3;
18111 }
18112 return resultobj;
18113 fail:
18114 {
18115 if (temp2)
18116 delete arg2;
18117 }
18118 {
18119 if (temp3)
18120 delete arg3;
18121 }
18122 return NULL;
18123 }
18124
18125
18126 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18127 PyObject *resultobj = 0;
18128 wxImage *arg1 = (wxImage *) 0 ;
18129 wxString *arg2 = 0 ;
18130 int arg3 ;
18131 bool result;
18132 void *argp1 = 0 ;
18133 int res1 = 0 ;
18134 bool temp2 = false ;
18135 int val3 ;
18136 int ecode3 = 0 ;
18137 PyObject * obj0 = 0 ;
18138 PyObject * obj1 = 0 ;
18139 PyObject * obj2 = 0 ;
18140 char * kwnames[] = {
18141 (char *) "self",(char *) "name",(char *) "type", NULL
18142 };
18143
18144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18146 if (!SWIG_IsOK(res1)) {
18147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
18148 }
18149 arg1 = reinterpret_cast< wxImage * >(argp1);
18150 {
18151 arg2 = wxString_in_helper(obj1);
18152 if (arg2 == NULL) SWIG_fail;
18153 temp2 = true;
18154 }
18155 ecode3 = SWIG_AsVal_int(obj2, &val3);
18156 if (!SWIG_IsOK(ecode3)) {
18157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
18158 }
18159 arg3 = static_cast< int >(val3);
18160 {
18161 PyThreadState* __tstate = wxPyBeginAllowThreads();
18162 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
18163 wxPyEndAllowThreads(__tstate);
18164 if (PyErr_Occurred()) SWIG_fail;
18165 }
18166 {
18167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18168 }
18169 {
18170 if (temp2)
18171 delete arg2;
18172 }
18173 return resultobj;
18174 fail:
18175 {
18176 if (temp2)
18177 delete arg2;
18178 }
18179 return NULL;
18180 }
18181
18182
18183 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18184 PyObject *resultobj = 0;
18185 wxImage *arg1 = (wxImage *) 0 ;
18186 wxString *arg2 = 0 ;
18187 wxString *arg3 = 0 ;
18188 bool result;
18189 void *argp1 = 0 ;
18190 int res1 = 0 ;
18191 bool temp2 = false ;
18192 bool temp3 = false ;
18193 PyObject * obj0 = 0 ;
18194 PyObject * obj1 = 0 ;
18195 PyObject * obj2 = 0 ;
18196 char * kwnames[] = {
18197 (char *) "self",(char *) "name",(char *) "mimetype", NULL
18198 };
18199
18200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18202 if (!SWIG_IsOK(res1)) {
18203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
18204 }
18205 arg1 = reinterpret_cast< wxImage * >(argp1);
18206 {
18207 arg2 = wxString_in_helper(obj1);
18208 if (arg2 == NULL) SWIG_fail;
18209 temp2 = true;
18210 }
18211 {
18212 arg3 = wxString_in_helper(obj2);
18213 if (arg3 == NULL) SWIG_fail;
18214 temp3 = true;
18215 }
18216 {
18217 PyThreadState* __tstate = wxPyBeginAllowThreads();
18218 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
18219 wxPyEndAllowThreads(__tstate);
18220 if (PyErr_Occurred()) SWIG_fail;
18221 }
18222 {
18223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18224 }
18225 {
18226 if (temp2)
18227 delete arg2;
18228 }
18229 {
18230 if (temp3)
18231 delete arg3;
18232 }
18233 return resultobj;
18234 fail:
18235 {
18236 if (temp2)
18237 delete arg2;
18238 }
18239 {
18240 if (temp3)
18241 delete arg3;
18242 }
18243 return NULL;
18244 }
18245
18246
18247 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18248 PyObject *resultobj = 0;
18249 wxInputStream *arg1 = 0 ;
18250 bool result;
18251 wxPyInputStream *temp1 ;
18252 bool created1 ;
18253 PyObject * obj0 = 0 ;
18254 char * kwnames[] = {
18255 (char *) "stream", NULL
18256 };
18257
18258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
18259 {
18260 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
18261 arg1 = temp1->m_wxis;
18262 created1 = false;
18263 } else {
18264 PyErr_Clear(); // clear the failure of the wxPyConvert above
18265 arg1 = wxPyCBInputStream_create(obj0, false);
18266 if (arg1 == NULL) {
18267 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
18268 SWIG_fail;
18269 }
18270 created1 = true;
18271 }
18272 }
18273 {
18274 PyThreadState* __tstate = wxPyBeginAllowThreads();
18275 result = (bool)wxImage::CanRead(*arg1);
18276 wxPyEndAllowThreads(__tstate);
18277 if (PyErr_Occurred()) SWIG_fail;
18278 }
18279 {
18280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18281 }
18282 {
18283 if (created1) delete arg1;
18284 }
18285 return resultobj;
18286 fail:
18287 {
18288 if (created1) delete arg1;
18289 }
18290 return NULL;
18291 }
18292
18293
18294 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18295 PyObject *resultobj = 0;
18296 wxImage *arg1 = (wxImage *) 0 ;
18297 wxInputStream *arg2 = 0 ;
18298 long arg3 = (long) wxBITMAP_TYPE_ANY ;
18299 int arg4 = (int) -1 ;
18300 bool result;
18301 void *argp1 = 0 ;
18302 int res1 = 0 ;
18303 wxPyInputStream *temp2 ;
18304 bool created2 ;
18305 long val3 ;
18306 int ecode3 = 0 ;
18307 int val4 ;
18308 int ecode4 = 0 ;
18309 PyObject * obj0 = 0 ;
18310 PyObject * obj1 = 0 ;
18311 PyObject * obj2 = 0 ;
18312 PyObject * obj3 = 0 ;
18313 char * kwnames[] = {
18314 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
18315 };
18316
18317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18319 if (!SWIG_IsOK(res1)) {
18320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
18321 }
18322 arg1 = reinterpret_cast< wxImage * >(argp1);
18323 {
18324 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
18325 arg2 = temp2->m_wxis;
18326 created2 = false;
18327 } else {
18328 PyErr_Clear(); // clear the failure of the wxPyConvert above
18329 arg2 = wxPyCBInputStream_create(obj1, false);
18330 if (arg2 == NULL) {
18331 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
18332 SWIG_fail;
18333 }
18334 created2 = true;
18335 }
18336 }
18337 if (obj2) {
18338 ecode3 = SWIG_AsVal_long(obj2, &val3);
18339 if (!SWIG_IsOK(ecode3)) {
18340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
18341 }
18342 arg3 = static_cast< long >(val3);
18343 }
18344 if (obj3) {
18345 ecode4 = SWIG_AsVal_int(obj3, &val4);
18346 if (!SWIG_IsOK(ecode4)) {
18347 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
18348 }
18349 arg4 = static_cast< int >(val4);
18350 }
18351 {
18352 PyThreadState* __tstate = wxPyBeginAllowThreads();
18353 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
18354 wxPyEndAllowThreads(__tstate);
18355 if (PyErr_Occurred()) SWIG_fail;
18356 }
18357 {
18358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18359 }
18360 {
18361 if (created2) delete arg2;
18362 }
18363 return resultobj;
18364 fail:
18365 {
18366 if (created2) delete arg2;
18367 }
18368 return NULL;
18369 }
18370
18371
18372 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18373 PyObject *resultobj = 0;
18374 wxImage *arg1 = (wxImage *) 0 ;
18375 wxInputStream *arg2 = 0 ;
18376 wxString *arg3 = 0 ;
18377 int arg4 = (int) -1 ;
18378 bool result;
18379 void *argp1 = 0 ;
18380 int res1 = 0 ;
18381 wxPyInputStream *temp2 ;
18382 bool created2 ;
18383 bool temp3 = false ;
18384 int val4 ;
18385 int ecode4 = 0 ;
18386 PyObject * obj0 = 0 ;
18387 PyObject * obj1 = 0 ;
18388 PyObject * obj2 = 0 ;
18389 PyObject * obj3 = 0 ;
18390 char * kwnames[] = {
18391 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
18392 };
18393
18394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18396 if (!SWIG_IsOK(res1)) {
18397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
18398 }
18399 arg1 = reinterpret_cast< wxImage * >(argp1);
18400 {
18401 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
18402 arg2 = temp2->m_wxis;
18403 created2 = false;
18404 } else {
18405 PyErr_Clear(); // clear the failure of the wxPyConvert above
18406 arg2 = wxPyCBInputStream_create(obj1, false);
18407 if (arg2 == NULL) {
18408 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
18409 SWIG_fail;
18410 }
18411 created2 = true;
18412 }
18413 }
18414 {
18415 arg3 = wxString_in_helper(obj2);
18416 if (arg3 == NULL) SWIG_fail;
18417 temp3 = true;
18418 }
18419 if (obj3) {
18420 ecode4 = SWIG_AsVal_int(obj3, &val4);
18421 if (!SWIG_IsOK(ecode4)) {
18422 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
18423 }
18424 arg4 = static_cast< int >(val4);
18425 }
18426 {
18427 PyThreadState* __tstate = wxPyBeginAllowThreads();
18428 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
18429 wxPyEndAllowThreads(__tstate);
18430 if (PyErr_Occurred()) SWIG_fail;
18431 }
18432 {
18433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18434 }
18435 {
18436 if (created2) delete arg2;
18437 }
18438 {
18439 if (temp3)
18440 delete arg3;
18441 }
18442 return resultobj;
18443 fail:
18444 {
18445 if (created2) delete arg2;
18446 }
18447 {
18448 if (temp3)
18449 delete arg3;
18450 }
18451 return NULL;
18452 }
18453
18454
18455 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18456 PyObject *resultobj = 0;
18457 wxImage *arg1 = (wxImage *) 0 ;
18458 bool result;
18459 void *argp1 = 0 ;
18460 int res1 = 0 ;
18461 PyObject *swig_obj[1] ;
18462
18463 if (!args) SWIG_fail;
18464 swig_obj[0] = args;
18465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18466 if (!SWIG_IsOK(res1)) {
18467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
18468 }
18469 arg1 = reinterpret_cast< wxImage * >(argp1);
18470 {
18471 PyThreadState* __tstate = wxPyBeginAllowThreads();
18472 result = (bool)(arg1)->IsOk();
18473 wxPyEndAllowThreads(__tstate);
18474 if (PyErr_Occurred()) SWIG_fail;
18475 }
18476 {
18477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18478 }
18479 return resultobj;
18480 fail:
18481 return NULL;
18482 }
18483
18484
18485 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18486 PyObject *resultobj = 0;
18487 wxImage *arg1 = (wxImage *) 0 ;
18488 int result;
18489 void *argp1 = 0 ;
18490 int res1 = 0 ;
18491 PyObject *swig_obj[1] ;
18492
18493 if (!args) SWIG_fail;
18494 swig_obj[0] = args;
18495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18496 if (!SWIG_IsOK(res1)) {
18497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
18498 }
18499 arg1 = reinterpret_cast< wxImage * >(argp1);
18500 {
18501 PyThreadState* __tstate = wxPyBeginAllowThreads();
18502 result = (int)(arg1)->GetWidth();
18503 wxPyEndAllowThreads(__tstate);
18504 if (PyErr_Occurred()) SWIG_fail;
18505 }
18506 resultobj = SWIG_From_int(static_cast< int >(result));
18507 return resultobj;
18508 fail:
18509 return NULL;
18510 }
18511
18512
18513 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18514 PyObject *resultobj = 0;
18515 wxImage *arg1 = (wxImage *) 0 ;
18516 int result;
18517 void *argp1 = 0 ;
18518 int res1 = 0 ;
18519 PyObject *swig_obj[1] ;
18520
18521 if (!args) SWIG_fail;
18522 swig_obj[0] = args;
18523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18524 if (!SWIG_IsOK(res1)) {
18525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
18526 }
18527 arg1 = reinterpret_cast< wxImage * >(argp1);
18528 {
18529 PyThreadState* __tstate = wxPyBeginAllowThreads();
18530 result = (int)(arg1)->GetHeight();
18531 wxPyEndAllowThreads(__tstate);
18532 if (PyErr_Occurred()) SWIG_fail;
18533 }
18534 resultobj = SWIG_From_int(static_cast< int >(result));
18535 return resultobj;
18536 fail:
18537 return NULL;
18538 }
18539
18540
18541 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18542 PyObject *resultobj = 0;
18543 wxImage *arg1 = (wxImage *) 0 ;
18544 wxSize result;
18545 void *argp1 = 0 ;
18546 int res1 = 0 ;
18547 PyObject *swig_obj[1] ;
18548
18549 if (!args) SWIG_fail;
18550 swig_obj[0] = args;
18551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18552 if (!SWIG_IsOK(res1)) {
18553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
18554 }
18555 arg1 = reinterpret_cast< wxImage * >(argp1);
18556 {
18557 PyThreadState* __tstate = wxPyBeginAllowThreads();
18558 result = wxImage_GetSize(arg1);
18559 wxPyEndAllowThreads(__tstate);
18560 if (PyErr_Occurred()) SWIG_fail;
18561 }
18562 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
18563 return resultobj;
18564 fail:
18565 return NULL;
18566 }
18567
18568
18569 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18570 PyObject *resultobj = 0;
18571 wxImage *arg1 = (wxImage *) 0 ;
18572 wxRect *arg2 = 0 ;
18573 SwigValueWrapper<wxImage > result;
18574 void *argp1 = 0 ;
18575 int res1 = 0 ;
18576 wxRect temp2 ;
18577 PyObject * obj0 = 0 ;
18578 PyObject * obj1 = 0 ;
18579 char * kwnames[] = {
18580 (char *) "self",(char *) "rect", NULL
18581 };
18582
18583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
18584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18585 if (!SWIG_IsOK(res1)) {
18586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
18587 }
18588 arg1 = reinterpret_cast< wxImage * >(argp1);
18589 {
18590 arg2 = &temp2;
18591 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18592 }
18593 {
18594 PyThreadState* __tstate = wxPyBeginAllowThreads();
18595 result = (arg1)->GetSubImage((wxRect const &)*arg2);
18596 wxPyEndAllowThreads(__tstate);
18597 if (PyErr_Occurred()) SWIG_fail;
18598 }
18599 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18600 return resultobj;
18601 fail:
18602 return NULL;
18603 }
18604
18605
18606 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18607 PyObject *resultobj = 0;
18608 wxImage *arg1 = (wxImage *) 0 ;
18609 wxSize *arg2 = 0 ;
18610 wxPoint *arg3 = 0 ;
18611 int arg4 = (int) -1 ;
18612 int arg5 = (int) -1 ;
18613 int arg6 = (int) -1 ;
18614 SwigValueWrapper<wxImage > result;
18615 void *argp1 = 0 ;
18616 int res1 = 0 ;
18617 wxSize temp2 ;
18618 wxPoint temp3 ;
18619 int val4 ;
18620 int ecode4 = 0 ;
18621 int val5 ;
18622 int ecode5 = 0 ;
18623 int val6 ;
18624 int ecode6 = 0 ;
18625 PyObject * obj0 = 0 ;
18626 PyObject * obj1 = 0 ;
18627 PyObject * obj2 = 0 ;
18628 PyObject * obj3 = 0 ;
18629 PyObject * obj4 = 0 ;
18630 PyObject * obj5 = 0 ;
18631 char * kwnames[] = {
18632 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18633 };
18634
18635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18637 if (!SWIG_IsOK(res1)) {
18638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18639 }
18640 arg1 = reinterpret_cast< wxImage * >(argp1);
18641 {
18642 arg2 = &temp2;
18643 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18644 }
18645 {
18646 arg3 = &temp3;
18647 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18648 }
18649 if (obj3) {
18650 ecode4 = SWIG_AsVal_int(obj3, &val4);
18651 if (!SWIG_IsOK(ecode4)) {
18652 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18653 }
18654 arg4 = static_cast< int >(val4);
18655 }
18656 if (obj4) {
18657 ecode5 = SWIG_AsVal_int(obj4, &val5);
18658 if (!SWIG_IsOK(ecode5)) {
18659 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18660 }
18661 arg5 = static_cast< int >(val5);
18662 }
18663 if (obj5) {
18664 ecode6 = SWIG_AsVal_int(obj5, &val6);
18665 if (!SWIG_IsOK(ecode6)) {
18666 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18667 }
18668 arg6 = static_cast< int >(val6);
18669 }
18670 {
18671 PyThreadState* __tstate = wxPyBeginAllowThreads();
18672 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18673 wxPyEndAllowThreads(__tstate);
18674 if (PyErr_Occurred()) SWIG_fail;
18675 }
18676 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18677 return resultobj;
18678 fail:
18679 return NULL;
18680 }
18681
18682
18683 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18684 PyObject *resultobj = 0;
18685 wxImage *arg1 = (wxImage *) 0 ;
18686 SwigValueWrapper<wxImage > result;
18687 void *argp1 = 0 ;
18688 int res1 = 0 ;
18689 PyObject *swig_obj[1] ;
18690
18691 if (!args) SWIG_fail;
18692 swig_obj[0] = args;
18693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18694 if (!SWIG_IsOK(res1)) {
18695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18696 }
18697 arg1 = reinterpret_cast< wxImage * >(argp1);
18698 {
18699 PyThreadState* __tstate = wxPyBeginAllowThreads();
18700 result = (arg1)->Copy();
18701 wxPyEndAllowThreads(__tstate);
18702 if (PyErr_Occurred()) SWIG_fail;
18703 }
18704 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18705 return resultobj;
18706 fail:
18707 return NULL;
18708 }
18709
18710
18711 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18712 PyObject *resultobj = 0;
18713 wxImage *arg1 = (wxImage *) 0 ;
18714 wxImage *arg2 = 0 ;
18715 int arg3 ;
18716 int arg4 ;
18717 void *argp1 = 0 ;
18718 int res1 = 0 ;
18719 void *argp2 = 0 ;
18720 int res2 = 0 ;
18721 int val3 ;
18722 int ecode3 = 0 ;
18723 int val4 ;
18724 int ecode4 = 0 ;
18725 PyObject * obj0 = 0 ;
18726 PyObject * obj1 = 0 ;
18727 PyObject * obj2 = 0 ;
18728 PyObject * obj3 = 0 ;
18729 char * kwnames[] = {
18730 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18731 };
18732
18733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18735 if (!SWIG_IsOK(res1)) {
18736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18737 }
18738 arg1 = reinterpret_cast< wxImage * >(argp1);
18739 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18740 if (!SWIG_IsOK(res2)) {
18741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18742 }
18743 if (!argp2) {
18744 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18745 }
18746 arg2 = reinterpret_cast< wxImage * >(argp2);
18747 ecode3 = SWIG_AsVal_int(obj2, &val3);
18748 if (!SWIG_IsOK(ecode3)) {
18749 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18750 }
18751 arg3 = static_cast< int >(val3);
18752 ecode4 = SWIG_AsVal_int(obj3, &val4);
18753 if (!SWIG_IsOK(ecode4)) {
18754 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18755 }
18756 arg4 = static_cast< int >(val4);
18757 {
18758 PyThreadState* __tstate = wxPyBeginAllowThreads();
18759 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18760 wxPyEndAllowThreads(__tstate);
18761 if (PyErr_Occurred()) SWIG_fail;
18762 }
18763 resultobj = SWIG_Py_Void();
18764 return resultobj;
18765 fail:
18766 return NULL;
18767 }
18768
18769
18770 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18771 PyObject *resultobj = 0;
18772 wxImage *arg1 = (wxImage *) 0 ;
18773 PyObject *result = 0 ;
18774 void *argp1 = 0 ;
18775 int res1 = 0 ;
18776 PyObject *swig_obj[1] ;
18777
18778 if (!args) SWIG_fail;
18779 swig_obj[0] = args;
18780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18781 if (!SWIG_IsOK(res1)) {
18782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18783 }
18784 arg1 = reinterpret_cast< wxImage * >(argp1);
18785 {
18786 PyThreadState* __tstate = wxPyBeginAllowThreads();
18787 result = (PyObject *)wxImage_GetData(arg1);
18788 wxPyEndAllowThreads(__tstate);
18789 if (PyErr_Occurred()) SWIG_fail;
18790 }
18791 resultobj = result;
18792 return resultobj;
18793 fail:
18794 return NULL;
18795 }
18796
18797
18798 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18799 PyObject *resultobj = 0;
18800 wxImage *arg1 = (wxImage *) 0 ;
18801 buffer arg2 ;
18802 int arg3 ;
18803 void *argp1 = 0 ;
18804 int res1 = 0 ;
18805 Py_ssize_t temp2 ;
18806 PyObject * obj0 = 0 ;
18807 PyObject * obj1 = 0 ;
18808 char * kwnames[] = {
18809 (char *) "self",(char *) "data", NULL
18810 };
18811
18812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18814 if (!SWIG_IsOK(res1)) {
18815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18816 }
18817 arg1 = reinterpret_cast< wxImage * >(argp1);
18818 {
18819 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18820 arg3 = (int)temp2;
18821 }
18822 {
18823 PyThreadState* __tstate = wxPyBeginAllowThreads();
18824 wxImage_SetData(arg1,arg2,arg3);
18825 wxPyEndAllowThreads(__tstate);
18826 if (PyErr_Occurred()) SWIG_fail;
18827 }
18828 resultobj = SWIG_Py_Void();
18829 return resultobj;
18830 fail:
18831 return NULL;
18832 }
18833
18834
18835 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18836 PyObject *resultobj = 0;
18837 wxImage *arg1 = (wxImage *) 0 ;
18838 PyObject *result = 0 ;
18839 void *argp1 = 0 ;
18840 int res1 = 0 ;
18841 PyObject *swig_obj[1] ;
18842
18843 if (!args) SWIG_fail;
18844 swig_obj[0] = args;
18845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18846 if (!SWIG_IsOK(res1)) {
18847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18848 }
18849 arg1 = reinterpret_cast< wxImage * >(argp1);
18850 {
18851 PyThreadState* __tstate = wxPyBeginAllowThreads();
18852 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18853 wxPyEndAllowThreads(__tstate);
18854 if (PyErr_Occurred()) SWIG_fail;
18855 }
18856 resultobj = result;
18857 return resultobj;
18858 fail:
18859 return NULL;
18860 }
18861
18862
18863 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18864 PyObject *resultobj = 0;
18865 wxImage *arg1 = (wxImage *) 0 ;
18866 buffer arg2 ;
18867 int arg3 ;
18868 void *argp1 = 0 ;
18869 int res1 = 0 ;
18870 Py_ssize_t temp2 ;
18871 PyObject * obj0 = 0 ;
18872 PyObject * obj1 = 0 ;
18873 char * kwnames[] = {
18874 (char *) "self",(char *) "data", NULL
18875 };
18876
18877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18879 if (!SWIG_IsOK(res1)) {
18880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18881 }
18882 arg1 = reinterpret_cast< wxImage * >(argp1);
18883 {
18884 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18885 arg3 = (int)temp2;
18886 }
18887 {
18888 PyThreadState* __tstate = wxPyBeginAllowThreads();
18889 wxImage_SetDataBuffer(arg1,arg2,arg3);
18890 wxPyEndAllowThreads(__tstate);
18891 if (PyErr_Occurred()) SWIG_fail;
18892 }
18893 resultobj = SWIG_Py_Void();
18894 return resultobj;
18895 fail:
18896 return NULL;
18897 }
18898
18899
18900 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18901 PyObject *resultobj = 0;
18902 wxImage *arg1 = (wxImage *) 0 ;
18903 PyObject *result = 0 ;
18904 void *argp1 = 0 ;
18905 int res1 = 0 ;
18906 PyObject *swig_obj[1] ;
18907
18908 if (!args) SWIG_fail;
18909 swig_obj[0] = args;
18910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18911 if (!SWIG_IsOK(res1)) {
18912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18913 }
18914 arg1 = reinterpret_cast< wxImage * >(argp1);
18915 {
18916 PyThreadState* __tstate = wxPyBeginAllowThreads();
18917 result = (PyObject *)wxImage_GetAlphaData(arg1);
18918 wxPyEndAllowThreads(__tstate);
18919 if (PyErr_Occurred()) SWIG_fail;
18920 }
18921 resultobj = result;
18922 return resultobj;
18923 fail:
18924 return NULL;
18925 }
18926
18927
18928 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18929 PyObject *resultobj = 0;
18930 wxImage *arg1 = (wxImage *) 0 ;
18931 buffer arg2 ;
18932 int arg3 ;
18933 void *argp1 = 0 ;
18934 int res1 = 0 ;
18935 Py_ssize_t temp2 ;
18936 PyObject * obj0 = 0 ;
18937 PyObject * obj1 = 0 ;
18938 char * kwnames[] = {
18939 (char *) "self",(char *) "alpha", NULL
18940 };
18941
18942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18944 if (!SWIG_IsOK(res1)) {
18945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18946 }
18947 arg1 = reinterpret_cast< wxImage * >(argp1);
18948 {
18949 if (obj1 != Py_None) {
18950 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18951 arg3 = (int)temp2;
18952 }
18953 }
18954 {
18955 PyThreadState* __tstate = wxPyBeginAllowThreads();
18956 wxImage_SetAlphaData(arg1,arg2,arg3);
18957 wxPyEndAllowThreads(__tstate);
18958 if (PyErr_Occurred()) SWIG_fail;
18959 }
18960 resultobj = SWIG_Py_Void();
18961 return resultobj;
18962 fail:
18963 return NULL;
18964 }
18965
18966
18967 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18968 PyObject *resultobj = 0;
18969 wxImage *arg1 = (wxImage *) 0 ;
18970 PyObject *result = 0 ;
18971 void *argp1 = 0 ;
18972 int res1 = 0 ;
18973 PyObject *swig_obj[1] ;
18974
18975 if (!args) SWIG_fail;
18976 swig_obj[0] = args;
18977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18978 if (!SWIG_IsOK(res1)) {
18979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18980 }
18981 arg1 = reinterpret_cast< wxImage * >(argp1);
18982 {
18983 PyThreadState* __tstate = wxPyBeginAllowThreads();
18984 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18985 wxPyEndAllowThreads(__tstate);
18986 if (PyErr_Occurred()) SWIG_fail;
18987 }
18988 resultobj = result;
18989 return resultobj;
18990 fail:
18991 return NULL;
18992 }
18993
18994
18995 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18996 PyObject *resultobj = 0;
18997 wxImage *arg1 = (wxImage *) 0 ;
18998 buffer arg2 ;
18999 int arg3 ;
19000 void *argp1 = 0 ;
19001 int res1 = 0 ;
19002 Py_ssize_t temp2 ;
19003 PyObject * obj0 = 0 ;
19004 PyObject * obj1 = 0 ;
19005 char * kwnames[] = {
19006 (char *) "self",(char *) "alpha", NULL
19007 };
19008
19009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
19010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19011 if (!SWIG_IsOK(res1)) {
19012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
19013 }
19014 arg1 = reinterpret_cast< wxImage * >(argp1);
19015 {
19016 if (obj1 != Py_None) {
19017 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
19018 arg3 = (int)temp2;
19019 }
19020 }
19021 {
19022 PyThreadState* __tstate = wxPyBeginAllowThreads();
19023 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
19024 wxPyEndAllowThreads(__tstate);
19025 if (PyErr_Occurred()) SWIG_fail;
19026 }
19027 resultobj = SWIG_Py_Void();
19028 return resultobj;
19029 fail:
19030 return NULL;
19031 }
19032
19033
19034 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19035 PyObject *resultobj = 0;
19036 wxImage *arg1 = (wxImage *) 0 ;
19037 byte arg2 ;
19038 byte arg3 ;
19039 byte arg4 ;
19040 void *argp1 = 0 ;
19041 int res1 = 0 ;
19042 unsigned char val2 ;
19043 int ecode2 = 0 ;
19044 unsigned char val3 ;
19045 int ecode3 = 0 ;
19046 unsigned char val4 ;
19047 int ecode4 = 0 ;
19048 PyObject * obj0 = 0 ;
19049 PyObject * obj1 = 0 ;
19050 PyObject * obj2 = 0 ;
19051 PyObject * obj3 = 0 ;
19052 char * kwnames[] = {
19053 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19054 };
19055
19056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19058 if (!SWIG_IsOK(res1)) {
19059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
19060 }
19061 arg1 = reinterpret_cast< wxImage * >(argp1);
19062 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19063 if (!SWIG_IsOK(ecode2)) {
19064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
19065 }
19066 arg2 = static_cast< byte >(val2);
19067 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19068 if (!SWIG_IsOK(ecode3)) {
19069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
19070 }
19071 arg3 = static_cast< byte >(val3);
19072 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19073 if (!SWIG_IsOK(ecode4)) {
19074 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
19075 }
19076 arg4 = static_cast< byte >(val4);
19077 {
19078 PyThreadState* __tstate = wxPyBeginAllowThreads();
19079 (arg1)->SetMaskColour(arg2,arg3,arg4);
19080 wxPyEndAllowThreads(__tstate);
19081 if (PyErr_Occurred()) SWIG_fail;
19082 }
19083 resultobj = SWIG_Py_Void();
19084 return resultobj;
19085 fail:
19086 return NULL;
19087 }
19088
19089
19090 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19091 PyObject *resultobj = 0;
19092 wxImage *arg1 = (wxImage *) 0 ;
19093 byte *arg2 = (byte *) 0 ;
19094 byte *arg3 = (byte *) 0 ;
19095 byte *arg4 = (byte *) 0 ;
19096 void *argp1 = 0 ;
19097 int res1 = 0 ;
19098 byte temp2 ;
19099 int res2 = SWIG_TMPOBJ ;
19100 byte temp3 ;
19101 int res3 = SWIG_TMPOBJ ;
19102 byte temp4 ;
19103 int res4 = SWIG_TMPOBJ ;
19104 PyObject *swig_obj[1] ;
19105
19106 arg2 = &temp2;
19107 arg3 = &temp3;
19108 arg4 = &temp4;
19109 if (!args) SWIG_fail;
19110 swig_obj[0] = args;
19111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19112 if (!SWIG_IsOK(res1)) {
19113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
19114 }
19115 arg1 = reinterpret_cast< wxImage * >(argp1);
19116 {
19117 PyThreadState* __tstate = wxPyBeginAllowThreads();
19118 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
19119 wxPyEndAllowThreads(__tstate);
19120 if (PyErr_Occurred()) SWIG_fail;
19121 }
19122 resultobj = SWIG_Py_Void();
19123 if (SWIG_IsTmpObj(res2)) {
19124 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
19125 } else {
19126 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19127 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
19128 }
19129 if (SWIG_IsTmpObj(res3)) {
19130 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
19131 } else {
19132 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19133 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
19134 }
19135 if (SWIG_IsTmpObj(res4)) {
19136 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
19137 } else {
19138 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19139 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
19140 }
19141 return resultobj;
19142 fail:
19143 return NULL;
19144 }
19145
19146
19147 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19148 PyObject *resultobj = 0;
19149 wxImage *arg1 = (wxImage *) 0 ;
19150 byte result;
19151 void *argp1 = 0 ;
19152 int res1 = 0 ;
19153 PyObject *swig_obj[1] ;
19154
19155 if (!args) SWIG_fail;
19156 swig_obj[0] = args;
19157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19158 if (!SWIG_IsOK(res1)) {
19159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
19160 }
19161 arg1 = reinterpret_cast< wxImage * >(argp1);
19162 {
19163 PyThreadState* __tstate = wxPyBeginAllowThreads();
19164 result = (byte)(arg1)->GetMaskRed();
19165 wxPyEndAllowThreads(__tstate);
19166 if (PyErr_Occurred()) SWIG_fail;
19167 }
19168 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
19169 return resultobj;
19170 fail:
19171 return NULL;
19172 }
19173
19174
19175 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19176 PyObject *resultobj = 0;
19177 wxImage *arg1 = (wxImage *) 0 ;
19178 byte result;
19179 void *argp1 = 0 ;
19180 int res1 = 0 ;
19181 PyObject *swig_obj[1] ;
19182
19183 if (!args) SWIG_fail;
19184 swig_obj[0] = args;
19185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19186 if (!SWIG_IsOK(res1)) {
19187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
19188 }
19189 arg1 = reinterpret_cast< wxImage * >(argp1);
19190 {
19191 PyThreadState* __tstate = wxPyBeginAllowThreads();
19192 result = (byte)(arg1)->GetMaskGreen();
19193 wxPyEndAllowThreads(__tstate);
19194 if (PyErr_Occurred()) SWIG_fail;
19195 }
19196 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
19197 return resultobj;
19198 fail:
19199 return NULL;
19200 }
19201
19202
19203 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19204 PyObject *resultobj = 0;
19205 wxImage *arg1 = (wxImage *) 0 ;
19206 byte result;
19207 void *argp1 = 0 ;
19208 int res1 = 0 ;
19209 PyObject *swig_obj[1] ;
19210
19211 if (!args) SWIG_fail;
19212 swig_obj[0] = args;
19213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19214 if (!SWIG_IsOK(res1)) {
19215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
19216 }
19217 arg1 = reinterpret_cast< wxImage * >(argp1);
19218 {
19219 PyThreadState* __tstate = wxPyBeginAllowThreads();
19220 result = (byte)(arg1)->GetMaskBlue();
19221 wxPyEndAllowThreads(__tstate);
19222 if (PyErr_Occurred()) SWIG_fail;
19223 }
19224 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
19225 return resultobj;
19226 fail:
19227 return NULL;
19228 }
19229
19230
19231 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19232 PyObject *resultobj = 0;
19233 wxImage *arg1 = (wxImage *) 0 ;
19234 bool arg2 = (bool) true ;
19235 void *argp1 = 0 ;
19236 int res1 = 0 ;
19237 bool val2 ;
19238 int ecode2 = 0 ;
19239 PyObject * obj0 = 0 ;
19240 PyObject * obj1 = 0 ;
19241 char * kwnames[] = {
19242 (char *) "self",(char *) "mask", NULL
19243 };
19244
19245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
19246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19247 if (!SWIG_IsOK(res1)) {
19248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
19249 }
19250 arg1 = reinterpret_cast< wxImage * >(argp1);
19251 if (obj1) {
19252 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19253 if (!SWIG_IsOK(ecode2)) {
19254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
19255 }
19256 arg2 = static_cast< bool >(val2);
19257 }
19258 {
19259 PyThreadState* __tstate = wxPyBeginAllowThreads();
19260 (arg1)->SetMask(arg2);
19261 wxPyEndAllowThreads(__tstate);
19262 if (PyErr_Occurred()) SWIG_fail;
19263 }
19264 resultobj = SWIG_Py_Void();
19265 return resultobj;
19266 fail:
19267 return NULL;
19268 }
19269
19270
19271 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19272 PyObject *resultobj = 0;
19273 wxImage *arg1 = (wxImage *) 0 ;
19274 bool result;
19275 void *argp1 = 0 ;
19276 int res1 = 0 ;
19277 PyObject *swig_obj[1] ;
19278
19279 if (!args) SWIG_fail;
19280 swig_obj[0] = args;
19281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19282 if (!SWIG_IsOK(res1)) {
19283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
19284 }
19285 arg1 = reinterpret_cast< wxImage * >(argp1);
19286 {
19287 PyThreadState* __tstate = wxPyBeginAllowThreads();
19288 result = (bool)(arg1)->HasMask();
19289 wxPyEndAllowThreads(__tstate);
19290 if (PyErr_Occurred()) SWIG_fail;
19291 }
19292 {
19293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19294 }
19295 return resultobj;
19296 fail:
19297 return NULL;
19298 }
19299
19300
19301 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19302 PyObject *resultobj = 0;
19303 wxImage *arg1 = (wxImage *) 0 ;
19304 double arg2 ;
19305 wxPoint *arg3 = 0 ;
19306 bool arg4 = (bool) true ;
19307 wxPoint *arg5 = (wxPoint *) NULL ;
19308 SwigValueWrapper<wxImage > result;
19309 void *argp1 = 0 ;
19310 int res1 = 0 ;
19311 double val2 ;
19312 int ecode2 = 0 ;
19313 wxPoint temp3 ;
19314 bool val4 ;
19315 int ecode4 = 0 ;
19316 void *argp5 = 0 ;
19317 int res5 = 0 ;
19318 PyObject * obj0 = 0 ;
19319 PyObject * obj1 = 0 ;
19320 PyObject * obj2 = 0 ;
19321 PyObject * obj3 = 0 ;
19322 PyObject * obj4 = 0 ;
19323 char * kwnames[] = {
19324 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
19325 };
19326
19327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19329 if (!SWIG_IsOK(res1)) {
19330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
19331 }
19332 arg1 = reinterpret_cast< wxImage * >(argp1);
19333 ecode2 = SWIG_AsVal_double(obj1, &val2);
19334 if (!SWIG_IsOK(ecode2)) {
19335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
19336 }
19337 arg2 = static_cast< double >(val2);
19338 {
19339 arg3 = &temp3;
19340 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
19341 }
19342 if (obj3) {
19343 ecode4 = SWIG_AsVal_bool(obj3, &val4);
19344 if (!SWIG_IsOK(ecode4)) {
19345 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
19346 }
19347 arg4 = static_cast< bool >(val4);
19348 }
19349 if (obj4) {
19350 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
19351 if (!SWIG_IsOK(res5)) {
19352 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
19353 }
19354 arg5 = reinterpret_cast< wxPoint * >(argp5);
19355 }
19356 {
19357 PyThreadState* __tstate = wxPyBeginAllowThreads();
19358 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
19359 wxPyEndAllowThreads(__tstate);
19360 if (PyErr_Occurred()) SWIG_fail;
19361 }
19362 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19363 return resultobj;
19364 fail:
19365 return NULL;
19366 }
19367
19368
19369 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19370 PyObject *resultobj = 0;
19371 wxImage *arg1 = (wxImage *) 0 ;
19372 bool arg2 = (bool) true ;
19373 SwigValueWrapper<wxImage > result;
19374 void *argp1 = 0 ;
19375 int res1 = 0 ;
19376 bool val2 ;
19377 int ecode2 = 0 ;
19378 PyObject * obj0 = 0 ;
19379 PyObject * obj1 = 0 ;
19380 char * kwnames[] = {
19381 (char *) "self",(char *) "clockwise", NULL
19382 };
19383
19384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
19385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19386 if (!SWIG_IsOK(res1)) {
19387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
19388 }
19389 arg1 = reinterpret_cast< wxImage * >(argp1);
19390 if (obj1) {
19391 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19392 if (!SWIG_IsOK(ecode2)) {
19393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
19394 }
19395 arg2 = static_cast< bool >(val2);
19396 }
19397 {
19398 PyThreadState* __tstate = wxPyBeginAllowThreads();
19399 result = (arg1)->Rotate90(arg2);
19400 wxPyEndAllowThreads(__tstate);
19401 if (PyErr_Occurred()) SWIG_fail;
19402 }
19403 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19404 return resultobj;
19405 fail:
19406 return NULL;
19407 }
19408
19409
19410 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19411 PyObject *resultobj = 0;
19412 wxImage *arg1 = (wxImage *) 0 ;
19413 bool arg2 = (bool) true ;
19414 SwigValueWrapper<wxImage > result;
19415 void *argp1 = 0 ;
19416 int res1 = 0 ;
19417 bool val2 ;
19418 int ecode2 = 0 ;
19419 PyObject * obj0 = 0 ;
19420 PyObject * obj1 = 0 ;
19421 char * kwnames[] = {
19422 (char *) "self",(char *) "horizontally", NULL
19423 };
19424
19425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
19426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19427 if (!SWIG_IsOK(res1)) {
19428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
19429 }
19430 arg1 = reinterpret_cast< wxImage * >(argp1);
19431 if (obj1) {
19432 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19433 if (!SWIG_IsOK(ecode2)) {
19434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
19435 }
19436 arg2 = static_cast< bool >(val2);
19437 }
19438 {
19439 PyThreadState* __tstate = wxPyBeginAllowThreads();
19440 result = (arg1)->Mirror(arg2);
19441 wxPyEndAllowThreads(__tstate);
19442 if (PyErr_Occurred()) SWIG_fail;
19443 }
19444 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19445 return resultobj;
19446 fail:
19447 return NULL;
19448 }
19449
19450
19451 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19452 PyObject *resultobj = 0;
19453 wxImage *arg1 = (wxImage *) 0 ;
19454 byte arg2 ;
19455 byte arg3 ;
19456 byte arg4 ;
19457 byte arg5 ;
19458 byte arg6 ;
19459 byte arg7 ;
19460 void *argp1 = 0 ;
19461 int res1 = 0 ;
19462 unsigned char val2 ;
19463 int ecode2 = 0 ;
19464 unsigned char val3 ;
19465 int ecode3 = 0 ;
19466 unsigned char val4 ;
19467 int ecode4 = 0 ;
19468 unsigned char val5 ;
19469 int ecode5 = 0 ;
19470 unsigned char val6 ;
19471 int ecode6 = 0 ;
19472 unsigned char val7 ;
19473 int ecode7 = 0 ;
19474 PyObject * obj0 = 0 ;
19475 PyObject * obj1 = 0 ;
19476 PyObject * obj2 = 0 ;
19477 PyObject * obj3 = 0 ;
19478 PyObject * obj4 = 0 ;
19479 PyObject * obj5 = 0 ;
19480 PyObject * obj6 = 0 ;
19481 char * kwnames[] = {
19482 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
19483 };
19484
19485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
19486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19487 if (!SWIG_IsOK(res1)) {
19488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
19489 }
19490 arg1 = reinterpret_cast< wxImage * >(argp1);
19491 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19492 if (!SWIG_IsOK(ecode2)) {
19493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
19494 }
19495 arg2 = static_cast< byte >(val2);
19496 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19497 if (!SWIG_IsOK(ecode3)) {
19498 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
19499 }
19500 arg3 = static_cast< byte >(val3);
19501 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19502 if (!SWIG_IsOK(ecode4)) {
19503 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
19504 }
19505 arg4 = static_cast< byte >(val4);
19506 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
19507 if (!SWIG_IsOK(ecode5)) {
19508 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
19509 }
19510 arg5 = static_cast< byte >(val5);
19511 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
19512 if (!SWIG_IsOK(ecode6)) {
19513 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
19514 }
19515 arg6 = static_cast< byte >(val6);
19516 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
19517 if (!SWIG_IsOK(ecode7)) {
19518 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
19519 }
19520 arg7 = static_cast< byte >(val7);
19521 {
19522 PyThreadState* __tstate = wxPyBeginAllowThreads();
19523 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
19524 wxPyEndAllowThreads(__tstate);
19525 if (PyErr_Occurred()) SWIG_fail;
19526 }
19527 resultobj = SWIG_Py_Void();
19528 return resultobj;
19529 fail:
19530 return NULL;
19531 }
19532
19533
19534 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19535 PyObject *resultobj = 0;
19536 wxImage *arg1 = (wxImage *) 0 ;
19537 double arg2 = (double) 0.299 ;
19538 double arg3 = (double) 0.587 ;
19539 double arg4 = (double) 0.114 ;
19540 SwigValueWrapper<wxImage > result;
19541 void *argp1 = 0 ;
19542 int res1 = 0 ;
19543 double val2 ;
19544 int ecode2 = 0 ;
19545 double val3 ;
19546 int ecode3 = 0 ;
19547 double val4 ;
19548 int ecode4 = 0 ;
19549 PyObject * obj0 = 0 ;
19550 PyObject * obj1 = 0 ;
19551 PyObject * obj2 = 0 ;
19552 PyObject * obj3 = 0 ;
19553 char * kwnames[] = {
19554 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
19555 };
19556
19557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19559 if (!SWIG_IsOK(res1)) {
19560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
19561 }
19562 arg1 = reinterpret_cast< wxImage * >(argp1);
19563 if (obj1) {
19564 ecode2 = SWIG_AsVal_double(obj1, &val2);
19565 if (!SWIG_IsOK(ecode2)) {
19566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
19567 }
19568 arg2 = static_cast< double >(val2);
19569 }
19570 if (obj2) {
19571 ecode3 = SWIG_AsVal_double(obj2, &val3);
19572 if (!SWIG_IsOK(ecode3)) {
19573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
19574 }
19575 arg3 = static_cast< double >(val3);
19576 }
19577 if (obj3) {
19578 ecode4 = SWIG_AsVal_double(obj3, &val4);
19579 if (!SWIG_IsOK(ecode4)) {
19580 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
19581 }
19582 arg4 = static_cast< double >(val4);
19583 }
19584 {
19585 PyThreadState* __tstate = wxPyBeginAllowThreads();
19586 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
19587 wxPyEndAllowThreads(__tstate);
19588 if (PyErr_Occurred()) SWIG_fail;
19589 }
19590 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19591 return resultobj;
19592 fail:
19593 return NULL;
19594 }
19595
19596
19597 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19598 PyObject *resultobj = 0;
19599 wxImage *arg1 = (wxImage *) 0 ;
19600 byte arg2 ;
19601 byte arg3 ;
19602 byte arg4 ;
19603 SwigValueWrapper<wxImage > result;
19604 void *argp1 = 0 ;
19605 int res1 = 0 ;
19606 unsigned char val2 ;
19607 int ecode2 = 0 ;
19608 unsigned char val3 ;
19609 int ecode3 = 0 ;
19610 unsigned char val4 ;
19611 int ecode4 = 0 ;
19612 PyObject * obj0 = 0 ;
19613 PyObject * obj1 = 0 ;
19614 PyObject * obj2 = 0 ;
19615 PyObject * obj3 = 0 ;
19616 char * kwnames[] = {
19617 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19618 };
19619
19620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19622 if (!SWIG_IsOK(res1)) {
19623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19624 }
19625 arg1 = reinterpret_cast< wxImage * >(argp1);
19626 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19627 if (!SWIG_IsOK(ecode2)) {
19628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19629 }
19630 arg2 = static_cast< byte >(val2);
19631 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19632 if (!SWIG_IsOK(ecode3)) {
19633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19634 }
19635 arg3 = static_cast< byte >(val3);
19636 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19637 if (!SWIG_IsOK(ecode4)) {
19638 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19639 }
19640 arg4 = static_cast< byte >(val4);
19641 {
19642 PyThreadState* __tstate = wxPyBeginAllowThreads();
19643 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19644 wxPyEndAllowThreads(__tstate);
19645 if (PyErr_Occurred()) SWIG_fail;
19646 }
19647 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19648 return resultobj;
19649 fail:
19650 return NULL;
19651 }
19652
19653
19654 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19655 PyObject *resultobj = 0;
19656 wxImage *arg1 = (wxImage *) 0 ;
19657 wxString *arg2 = 0 ;
19658 wxString *arg3 = 0 ;
19659 void *argp1 = 0 ;
19660 int res1 = 0 ;
19661 bool temp2 = false ;
19662 bool temp3 = false ;
19663 PyObject * obj0 = 0 ;
19664 PyObject * obj1 = 0 ;
19665 PyObject * obj2 = 0 ;
19666 char * kwnames[] = {
19667 (char *) "self",(char *) "name",(char *) "value", NULL
19668 };
19669
19670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19672 if (!SWIG_IsOK(res1)) {
19673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19674 }
19675 arg1 = reinterpret_cast< wxImage * >(argp1);
19676 {
19677 arg2 = wxString_in_helper(obj1);
19678 if (arg2 == NULL) SWIG_fail;
19679 temp2 = true;
19680 }
19681 {
19682 arg3 = wxString_in_helper(obj2);
19683 if (arg3 == NULL) SWIG_fail;
19684 temp3 = true;
19685 }
19686 {
19687 PyThreadState* __tstate = wxPyBeginAllowThreads();
19688 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19689 wxPyEndAllowThreads(__tstate);
19690 if (PyErr_Occurred()) SWIG_fail;
19691 }
19692 resultobj = SWIG_Py_Void();
19693 {
19694 if (temp2)
19695 delete arg2;
19696 }
19697 {
19698 if (temp3)
19699 delete arg3;
19700 }
19701 return resultobj;
19702 fail:
19703 {
19704 if (temp2)
19705 delete arg2;
19706 }
19707 {
19708 if (temp3)
19709 delete arg3;
19710 }
19711 return NULL;
19712 }
19713
19714
19715 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19716 PyObject *resultobj = 0;
19717 wxImage *arg1 = (wxImage *) 0 ;
19718 wxString *arg2 = 0 ;
19719 int arg3 ;
19720 void *argp1 = 0 ;
19721 int res1 = 0 ;
19722 bool temp2 = false ;
19723 int val3 ;
19724 int ecode3 = 0 ;
19725 PyObject * obj0 = 0 ;
19726 PyObject * obj1 = 0 ;
19727 PyObject * obj2 = 0 ;
19728 char * kwnames[] = {
19729 (char *) "self",(char *) "name",(char *) "value", NULL
19730 };
19731
19732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19734 if (!SWIG_IsOK(res1)) {
19735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19736 }
19737 arg1 = reinterpret_cast< wxImage * >(argp1);
19738 {
19739 arg2 = wxString_in_helper(obj1);
19740 if (arg2 == NULL) SWIG_fail;
19741 temp2 = true;
19742 }
19743 ecode3 = SWIG_AsVal_int(obj2, &val3);
19744 if (!SWIG_IsOK(ecode3)) {
19745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19746 }
19747 arg3 = static_cast< int >(val3);
19748 {
19749 PyThreadState* __tstate = wxPyBeginAllowThreads();
19750 (arg1)->SetOption((wxString const &)*arg2,arg3);
19751 wxPyEndAllowThreads(__tstate);
19752 if (PyErr_Occurred()) SWIG_fail;
19753 }
19754 resultobj = SWIG_Py_Void();
19755 {
19756 if (temp2)
19757 delete arg2;
19758 }
19759 return resultobj;
19760 fail:
19761 {
19762 if (temp2)
19763 delete arg2;
19764 }
19765 return NULL;
19766 }
19767
19768
19769 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19770 PyObject *resultobj = 0;
19771 wxImage *arg1 = (wxImage *) 0 ;
19772 wxString *arg2 = 0 ;
19773 wxString result;
19774 void *argp1 = 0 ;
19775 int res1 = 0 ;
19776 bool temp2 = false ;
19777 PyObject * obj0 = 0 ;
19778 PyObject * obj1 = 0 ;
19779 char * kwnames[] = {
19780 (char *) "self",(char *) "name", NULL
19781 };
19782
19783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19785 if (!SWIG_IsOK(res1)) {
19786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19787 }
19788 arg1 = reinterpret_cast< wxImage * >(argp1);
19789 {
19790 arg2 = wxString_in_helper(obj1);
19791 if (arg2 == NULL) SWIG_fail;
19792 temp2 = true;
19793 }
19794 {
19795 PyThreadState* __tstate = wxPyBeginAllowThreads();
19796 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19797 wxPyEndAllowThreads(__tstate);
19798 if (PyErr_Occurred()) SWIG_fail;
19799 }
19800 {
19801 #if wxUSE_UNICODE
19802 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19803 #else
19804 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19805 #endif
19806 }
19807 {
19808 if (temp2)
19809 delete arg2;
19810 }
19811 return resultobj;
19812 fail:
19813 {
19814 if (temp2)
19815 delete arg2;
19816 }
19817 return NULL;
19818 }
19819
19820
19821 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19822 PyObject *resultobj = 0;
19823 wxImage *arg1 = (wxImage *) 0 ;
19824 wxString *arg2 = 0 ;
19825 int result;
19826 void *argp1 = 0 ;
19827 int res1 = 0 ;
19828 bool temp2 = false ;
19829 PyObject * obj0 = 0 ;
19830 PyObject * obj1 = 0 ;
19831 char * kwnames[] = {
19832 (char *) "self",(char *) "name", NULL
19833 };
19834
19835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19837 if (!SWIG_IsOK(res1)) {
19838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19839 }
19840 arg1 = reinterpret_cast< wxImage * >(argp1);
19841 {
19842 arg2 = wxString_in_helper(obj1);
19843 if (arg2 == NULL) SWIG_fail;
19844 temp2 = true;
19845 }
19846 {
19847 PyThreadState* __tstate = wxPyBeginAllowThreads();
19848 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19849 wxPyEndAllowThreads(__tstate);
19850 if (PyErr_Occurred()) SWIG_fail;
19851 }
19852 resultobj = SWIG_From_int(static_cast< int >(result));
19853 {
19854 if (temp2)
19855 delete arg2;
19856 }
19857 return resultobj;
19858 fail:
19859 {
19860 if (temp2)
19861 delete arg2;
19862 }
19863 return NULL;
19864 }
19865
19866
19867 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19868 PyObject *resultobj = 0;
19869 wxImage *arg1 = (wxImage *) 0 ;
19870 wxString *arg2 = 0 ;
19871 bool result;
19872 void *argp1 = 0 ;
19873 int res1 = 0 ;
19874 bool temp2 = false ;
19875 PyObject * obj0 = 0 ;
19876 PyObject * obj1 = 0 ;
19877 char * kwnames[] = {
19878 (char *) "self",(char *) "name", NULL
19879 };
19880
19881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19883 if (!SWIG_IsOK(res1)) {
19884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19885 }
19886 arg1 = reinterpret_cast< wxImage * >(argp1);
19887 {
19888 arg2 = wxString_in_helper(obj1);
19889 if (arg2 == NULL) SWIG_fail;
19890 temp2 = true;
19891 }
19892 {
19893 PyThreadState* __tstate = wxPyBeginAllowThreads();
19894 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19895 wxPyEndAllowThreads(__tstate);
19896 if (PyErr_Occurred()) SWIG_fail;
19897 }
19898 {
19899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19900 }
19901 {
19902 if (temp2)
19903 delete arg2;
19904 }
19905 return resultobj;
19906 fail:
19907 {
19908 if (temp2)
19909 delete arg2;
19910 }
19911 return NULL;
19912 }
19913
19914
19915 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19916 PyObject *resultobj = 0;
19917 wxImage *arg1 = (wxImage *) 0 ;
19918 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19919 unsigned long result;
19920 void *argp1 = 0 ;
19921 int res1 = 0 ;
19922 unsigned long val2 ;
19923 int ecode2 = 0 ;
19924 PyObject * obj0 = 0 ;
19925 PyObject * obj1 = 0 ;
19926 char * kwnames[] = {
19927 (char *) "self",(char *) "stopafter", NULL
19928 };
19929
19930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19932 if (!SWIG_IsOK(res1)) {
19933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19934 }
19935 arg1 = reinterpret_cast< wxImage * >(argp1);
19936 if (obj1) {
19937 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19938 if (!SWIG_IsOK(ecode2)) {
19939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19940 }
19941 arg2 = static_cast< unsigned long >(val2);
19942 }
19943 {
19944 PyThreadState* __tstate = wxPyBeginAllowThreads();
19945 result = (unsigned long)(arg1)->CountColours(arg2);
19946 wxPyEndAllowThreads(__tstate);
19947 if (PyErr_Occurred()) SWIG_fail;
19948 }
19949 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19950 return resultobj;
19951 fail:
19952 return NULL;
19953 }
19954
19955
19956 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19957 PyObject *resultobj = 0;
19958 wxImage *arg1 = (wxImage *) 0 ;
19959 wxImageHistogram *arg2 = 0 ;
19960 unsigned long result;
19961 void *argp1 = 0 ;
19962 int res1 = 0 ;
19963 void *argp2 = 0 ;
19964 int res2 = 0 ;
19965 PyObject * obj0 = 0 ;
19966 PyObject * obj1 = 0 ;
19967 char * kwnames[] = {
19968 (char *) "self",(char *) "h", NULL
19969 };
19970
19971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19973 if (!SWIG_IsOK(res1)) {
19974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19975 }
19976 arg1 = reinterpret_cast< wxImage * >(argp1);
19977 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19978 if (!SWIG_IsOK(res2)) {
19979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19980 }
19981 if (!argp2) {
19982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19983 }
19984 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19985 {
19986 PyThreadState* __tstate = wxPyBeginAllowThreads();
19987 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19988 wxPyEndAllowThreads(__tstate);
19989 if (PyErr_Occurred()) SWIG_fail;
19990 }
19991 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19992 return resultobj;
19993 fail:
19994 return NULL;
19995 }
19996
19997
19998 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19999 PyObject *resultobj = 0;
20000 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
20001 void *argp1 = 0 ;
20002 int res1 = 0 ;
20003 PyObject * obj0 = 0 ;
20004 char * kwnames[] = {
20005 (char *) "handler", NULL
20006 };
20007
20008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
20009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
20010 if (!SWIG_IsOK(res1)) {
20011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
20012 }
20013 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
20014 {
20015 PyThreadState* __tstate = wxPyBeginAllowThreads();
20016 wxImage::AddHandler(arg1);
20017 wxPyEndAllowThreads(__tstate);
20018 if (PyErr_Occurred()) SWIG_fail;
20019 }
20020 resultobj = SWIG_Py_Void();
20021 return resultobj;
20022 fail:
20023 return NULL;
20024 }
20025
20026
20027 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20028 PyObject *resultobj = 0;
20029 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
20030 void *argp1 = 0 ;
20031 int res1 = 0 ;
20032 PyObject * obj0 = 0 ;
20033 char * kwnames[] = {
20034 (char *) "handler", NULL
20035 };
20036
20037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
20038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
20039 if (!SWIG_IsOK(res1)) {
20040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
20041 }
20042 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
20043 {
20044 PyThreadState* __tstate = wxPyBeginAllowThreads();
20045 wxImage::InsertHandler(arg1);
20046 wxPyEndAllowThreads(__tstate);
20047 if (PyErr_Occurred()) SWIG_fail;
20048 }
20049 resultobj = SWIG_Py_Void();
20050 return resultobj;
20051 fail:
20052 return NULL;
20053 }
20054
20055
20056 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20057 PyObject *resultobj = 0;
20058 wxString *arg1 = 0 ;
20059 bool result;
20060 bool temp1 = false ;
20061 PyObject * obj0 = 0 ;
20062 char * kwnames[] = {
20063 (char *) "name", NULL
20064 };
20065
20066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
20067 {
20068 arg1 = wxString_in_helper(obj0);
20069 if (arg1 == NULL) SWIG_fail;
20070 temp1 = true;
20071 }
20072 {
20073 PyThreadState* __tstate = wxPyBeginAllowThreads();
20074 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
20075 wxPyEndAllowThreads(__tstate);
20076 if (PyErr_Occurred()) SWIG_fail;
20077 }
20078 {
20079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20080 }
20081 {
20082 if (temp1)
20083 delete arg1;
20084 }
20085 return resultobj;
20086 fail:
20087 {
20088 if (temp1)
20089 delete arg1;
20090 }
20091 return NULL;
20092 }
20093
20094
20095 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20096 PyObject *resultobj = 0;
20097 PyObject *result = 0 ;
20098
20099 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
20100 {
20101 PyThreadState* __tstate = wxPyBeginAllowThreads();
20102 result = (PyObject *)wxImage_GetHandlers();
20103 wxPyEndAllowThreads(__tstate);
20104 if (PyErr_Occurred()) SWIG_fail;
20105 }
20106 resultobj = result;
20107 return resultobj;
20108 fail:
20109 return NULL;
20110 }
20111
20112
20113 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20114 PyObject *resultobj = 0;
20115 wxString result;
20116
20117 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
20118 {
20119 PyThreadState* __tstate = wxPyBeginAllowThreads();
20120 result = wxImage::GetImageExtWildcard();
20121 wxPyEndAllowThreads(__tstate);
20122 if (PyErr_Occurred()) SWIG_fail;
20123 }
20124 {
20125 #if wxUSE_UNICODE
20126 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20127 #else
20128 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20129 #endif
20130 }
20131 return resultobj;
20132 fail:
20133 return NULL;
20134 }
20135
20136
20137 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20138 PyObject *resultobj = 0;
20139 wxImage *arg1 = (wxImage *) 0 ;
20140 int arg2 = (int) -1 ;
20141 wxBitmap 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 *) "depth", NULL
20150 };
20151
20152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
20153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
20154 if (!SWIG_IsOK(res1)) {
20155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
20156 }
20157 arg1 = reinterpret_cast< wxImage * >(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 '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
20162 }
20163 arg2 = static_cast< int >(val2);
20164 }
20165 {
20166 if (!wxPyCheckForApp()) SWIG_fail;
20167 PyThreadState* __tstate = wxPyBeginAllowThreads();
20168 result = wxImage_ConvertToBitmap(arg1,arg2);
20169 wxPyEndAllowThreads(__tstate);
20170 if (PyErr_Occurred()) SWIG_fail;
20171 }
20172 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20173 return resultobj;
20174 fail:
20175 return NULL;
20176 }
20177
20178
20179 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20180 PyObject *resultobj = 0;
20181 wxImage *arg1 = (wxImage *) 0 ;
20182 byte arg2 ;
20183 byte arg3 ;
20184 byte arg4 ;
20185 wxBitmap result;
20186 void *argp1 = 0 ;
20187 int res1 = 0 ;
20188 unsigned char val2 ;
20189 int ecode2 = 0 ;
20190 unsigned char val3 ;
20191 int ecode3 = 0 ;
20192 unsigned char val4 ;
20193 int ecode4 = 0 ;
20194 PyObject * obj0 = 0 ;
20195 PyObject * obj1 = 0 ;
20196 PyObject * obj2 = 0 ;
20197 PyObject * obj3 = 0 ;
20198 char * kwnames[] = {
20199 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
20200 };
20201
20202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
20204 if (!SWIG_IsOK(res1)) {
20205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
20206 }
20207 arg1 = reinterpret_cast< wxImage * >(argp1);
20208 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
20209 if (!SWIG_IsOK(ecode2)) {
20210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
20211 }
20212 arg2 = static_cast< byte >(val2);
20213 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
20214 if (!SWIG_IsOK(ecode3)) {
20215 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
20216 }
20217 arg3 = static_cast< byte >(val3);
20218 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
20219 if (!SWIG_IsOK(ecode4)) {
20220 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
20221 }
20222 arg4 = static_cast< byte >(val4);
20223 {
20224 if (!wxPyCheckForApp()) SWIG_fail;
20225 PyThreadState* __tstate = wxPyBeginAllowThreads();
20226 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
20227 wxPyEndAllowThreads(__tstate);
20228 if (PyErr_Occurred()) SWIG_fail;
20229 }
20230 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20231 return resultobj;
20232 fail:
20233 return NULL;
20234 }
20235
20236
20237 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20238 PyObject *resultobj = 0;
20239 wxImage *arg1 = (wxImage *) 0 ;
20240 double arg2 ;
20241 void *argp1 = 0 ;
20242 int res1 = 0 ;
20243 double val2 ;
20244 int ecode2 = 0 ;
20245 PyObject * obj0 = 0 ;
20246 PyObject * obj1 = 0 ;
20247 char * kwnames[] = {
20248 (char *) "self",(char *) "angle", NULL
20249 };
20250
20251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
20252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
20253 if (!SWIG_IsOK(res1)) {
20254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
20255 }
20256 arg1 = reinterpret_cast< wxImage * >(argp1);
20257 ecode2 = SWIG_AsVal_double(obj1, &val2);
20258 if (!SWIG_IsOK(ecode2)) {
20259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
20260 }
20261 arg2 = static_cast< double >(val2);
20262 {
20263 PyThreadState* __tstate = wxPyBeginAllowThreads();
20264 (arg1)->RotateHue(arg2);
20265 wxPyEndAllowThreads(__tstate);
20266 if (PyErr_Occurred()) SWIG_fail;
20267 }
20268 resultobj = SWIG_Py_Void();
20269 return resultobj;
20270 fail:
20271 return NULL;
20272 }
20273
20274
20275 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20276 PyObject *resultobj = 0;
20277 wxImage_RGBValue arg1 ;
20278 wxImage_HSVValue result;
20279 void *argp1 ;
20280 int res1 = 0 ;
20281 PyObject * obj0 = 0 ;
20282 char * kwnames[] = {
20283 (char *) "rgb", NULL
20284 };
20285
20286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
20287 {
20288 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
20289 if (!SWIG_IsOK(res1)) {
20290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
20291 }
20292 if (!argp1) {
20293 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
20294 } else {
20295 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
20296 arg1 = *temp;
20297 if (SWIG_IsNewObj(res1)) delete temp;
20298 }
20299 }
20300 {
20301 PyThreadState* __tstate = wxPyBeginAllowThreads();
20302 result = wxImage::RGBtoHSV(arg1);
20303 wxPyEndAllowThreads(__tstate);
20304 if (PyErr_Occurred()) SWIG_fail;
20305 }
20306 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
20307 return resultobj;
20308 fail:
20309 return NULL;
20310 }
20311
20312
20313 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20314 PyObject *resultobj = 0;
20315 wxImage_HSVValue arg1 ;
20316 wxImage_RGBValue result;
20317 void *argp1 ;
20318 int res1 = 0 ;
20319 PyObject * obj0 = 0 ;
20320 char * kwnames[] = {
20321 (char *) "hsv", NULL
20322 };
20323
20324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
20325 {
20326 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
20327 if (!SWIG_IsOK(res1)) {
20328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
20329 }
20330 if (!argp1) {
20331 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
20332 } else {
20333 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
20334 arg1 = *temp;
20335 if (SWIG_IsNewObj(res1)) delete temp;
20336 }
20337 }
20338 {
20339 PyThreadState* __tstate = wxPyBeginAllowThreads();
20340 result = wxImage::HSVtoRGB(arg1);
20341 wxPyEndAllowThreads(__tstate);
20342 if (PyErr_Occurred()) SWIG_fail;
20343 }
20344 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
20345 return resultobj;
20346 fail:
20347 return NULL;
20348 }
20349
20350
20351 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20352 PyObject *obj;
20353 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20354 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
20355 return SWIG_Py_Void();
20356 }
20357
20358 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20359 return SWIG_Python_InitShadowInstance(args);
20360 }
20361
20362 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20363 PyObject *resultobj = 0;
20364 int arg1 ;
20365 int arg2 ;
20366 buffer arg3 ;
20367 int arg4 ;
20368 buffer arg5 = (buffer) NULL ;
20369 int arg6 = (int) 0 ;
20370 wxImage *result = 0 ;
20371 int val1 ;
20372 int ecode1 = 0 ;
20373 int val2 ;
20374 int ecode2 = 0 ;
20375 Py_ssize_t temp3 ;
20376 Py_ssize_t temp5 ;
20377 PyObject * obj0 = 0 ;
20378 PyObject * obj1 = 0 ;
20379 PyObject * obj2 = 0 ;
20380 PyObject * obj3 = 0 ;
20381 char * kwnames[] = {
20382 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
20383 };
20384
20385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20386 ecode1 = SWIG_AsVal_int(obj0, &val1);
20387 if (!SWIG_IsOK(ecode1)) {
20388 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
20389 }
20390 arg1 = static_cast< int >(val1);
20391 ecode2 = SWIG_AsVal_int(obj1, &val2);
20392 if (!SWIG_IsOK(ecode2)) {
20393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
20394 }
20395 arg2 = static_cast< int >(val2);
20396 {
20397 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
20398 arg4 = (int)temp3;
20399 }
20400 if (obj3) {
20401 {
20402 if (obj3 != Py_None) {
20403 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
20404 arg6 = (int)temp5;
20405 }
20406 }
20407 }
20408 {
20409 PyThreadState* __tstate = wxPyBeginAllowThreads();
20410 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
20411 wxPyEndAllowThreads(__tstate);
20412 if (PyErr_Occurred()) SWIG_fail;
20413 }
20414 {
20415 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
20416 }
20417 return resultobj;
20418 fail:
20419 return NULL;
20420 }
20421
20422
20423 SWIGINTERN int NullImage_set(PyObject *) {
20424 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
20425 return 1;
20426 }
20427
20428
20429 SWIGINTERN PyObject *NullImage_get(void) {
20430 PyObject *pyobj = 0;
20431
20432 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
20433 return pyobj;
20434 }
20435
20436
20437 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
20438 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
20439 return 1;
20440 }
20441
20442
20443 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
20444 PyObject *pyobj = 0;
20445
20446 {
20447 #if wxUSE_UNICODE
20448 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
20449 #else
20450 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
20451 #endif
20452 }
20453 return pyobj;
20454 }
20455
20456
20457 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
20458 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
20459 return 1;
20460 }
20461
20462
20463 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
20464 PyObject *pyobj = 0;
20465
20466 {
20467 #if wxUSE_UNICODE
20468 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
20469 #else
20470 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
20471 #endif
20472 }
20473 return pyobj;
20474 }
20475
20476
20477 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
20478 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
20479 return 1;
20480 }
20481
20482
20483 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
20484 PyObject *pyobj = 0;
20485
20486 {
20487 #if wxUSE_UNICODE
20488 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
20489 #else
20490 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
20491 #endif
20492 }
20493 return pyobj;
20494 }
20495
20496
20497 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
20498 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
20499 return 1;
20500 }
20501
20502
20503 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
20504 PyObject *pyobj = 0;
20505
20506 {
20507 #if wxUSE_UNICODE
20508 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
20509 #else
20510 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
20511 #endif
20512 }
20513 return pyobj;
20514 }
20515
20516
20517 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
20518 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
20519 return 1;
20520 }
20521
20522
20523 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
20524 PyObject *pyobj = 0;
20525
20526 {
20527 #if wxUSE_UNICODE
20528 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
20529 #else
20530 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
20531 #endif
20532 }
20533 return pyobj;
20534 }
20535
20536
20537 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
20538 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
20539 return 1;
20540 }
20541
20542
20543 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
20544 PyObject *pyobj = 0;
20545
20546 {
20547 #if wxUSE_UNICODE
20548 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
20549 #else
20550 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
20551 #endif
20552 }
20553 return pyobj;
20554 }
20555
20556
20557 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
20558 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
20559 return 1;
20560 }
20561
20562
20563 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
20564 PyObject *pyobj = 0;
20565
20566 {
20567 #if wxUSE_UNICODE
20568 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20569 #else
20570 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20571 #endif
20572 }
20573 return pyobj;
20574 }
20575
20576
20577 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
20578 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
20579 return 1;
20580 }
20581
20582
20583 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
20584 PyObject *pyobj = 0;
20585
20586 {
20587 #if wxUSE_UNICODE
20588 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20589 #else
20590 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20591 #endif
20592 }
20593 return pyobj;
20594 }
20595
20596
20597 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
20598 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
20599 return 1;
20600 }
20601
20602
20603 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
20604 PyObject *pyobj = 0;
20605
20606 {
20607 #if wxUSE_UNICODE
20608 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20609 #else
20610 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20611 #endif
20612 }
20613 return pyobj;
20614 }
20615
20616
20617 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20618 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20619 return 1;
20620 }
20621
20622
20623 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20624 PyObject *pyobj = 0;
20625
20626 {
20627 #if wxUSE_UNICODE
20628 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20629 #else
20630 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20631 #endif
20632 }
20633 return pyobj;
20634 }
20635
20636
20637 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20638 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20639 return 1;
20640 }
20641
20642
20643 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20644 PyObject *pyobj = 0;
20645
20646 {
20647 #if wxUSE_UNICODE
20648 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20649 #else
20650 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20651 #endif
20652 }
20653 return pyobj;
20654 }
20655
20656
20657 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20658 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20659 return 1;
20660 }
20661
20662
20663 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20664 PyObject *pyobj = 0;
20665
20666 {
20667 #if wxUSE_UNICODE
20668 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20669 #else
20670 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20671 #endif
20672 }
20673 return pyobj;
20674 }
20675
20676
20677 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20678 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20679 return 1;
20680 }
20681
20682
20683 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20684 PyObject *pyobj = 0;
20685
20686 {
20687 #if wxUSE_UNICODE
20688 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20689 #else
20690 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20691 #endif
20692 }
20693 return pyobj;
20694 }
20695
20696
20697 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20698 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20699 return 1;
20700 }
20701
20702
20703 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20704 PyObject *pyobj = 0;
20705
20706 {
20707 #if wxUSE_UNICODE
20708 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20709 #else
20710 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20711 #endif
20712 }
20713 return pyobj;
20714 }
20715
20716
20717 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20718 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20719 return 1;
20720 }
20721
20722
20723 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20724 PyObject *pyobj = 0;
20725
20726 {
20727 #if wxUSE_UNICODE
20728 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20729 #else
20730 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20731 #endif
20732 }
20733 return pyobj;
20734 }
20735
20736
20737 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20738 PyObject *resultobj = 0;
20739 wxBMPHandler *result = 0 ;
20740
20741 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20742 {
20743 PyThreadState* __tstate = wxPyBeginAllowThreads();
20744 result = (wxBMPHandler *)new wxBMPHandler();
20745 wxPyEndAllowThreads(__tstate);
20746 if (PyErr_Occurred()) SWIG_fail;
20747 }
20748 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20749 return resultobj;
20750 fail:
20751 return NULL;
20752 }
20753
20754
20755 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20756 PyObject *obj;
20757 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20758 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20759 return SWIG_Py_Void();
20760 }
20761
20762 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20763 return SWIG_Python_InitShadowInstance(args);
20764 }
20765
20766 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20767 PyObject *resultobj = 0;
20768 wxICOHandler *result = 0 ;
20769
20770 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20771 {
20772 PyThreadState* __tstate = wxPyBeginAllowThreads();
20773 result = (wxICOHandler *)new wxICOHandler();
20774 wxPyEndAllowThreads(__tstate);
20775 if (PyErr_Occurred()) SWIG_fail;
20776 }
20777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20778 return resultobj;
20779 fail:
20780 return NULL;
20781 }
20782
20783
20784 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20785 PyObject *obj;
20786 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20787 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20788 return SWIG_Py_Void();
20789 }
20790
20791 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20792 return SWIG_Python_InitShadowInstance(args);
20793 }
20794
20795 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20796 PyObject *resultobj = 0;
20797 wxCURHandler *result = 0 ;
20798
20799 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20800 {
20801 PyThreadState* __tstate = wxPyBeginAllowThreads();
20802 result = (wxCURHandler *)new wxCURHandler();
20803 wxPyEndAllowThreads(__tstate);
20804 if (PyErr_Occurred()) SWIG_fail;
20805 }
20806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20807 return resultobj;
20808 fail:
20809 return NULL;
20810 }
20811
20812
20813 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20814 PyObject *obj;
20815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20816 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20817 return SWIG_Py_Void();
20818 }
20819
20820 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20821 return SWIG_Python_InitShadowInstance(args);
20822 }
20823
20824 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20825 PyObject *resultobj = 0;
20826 wxANIHandler *result = 0 ;
20827
20828 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20829 {
20830 PyThreadState* __tstate = wxPyBeginAllowThreads();
20831 result = (wxANIHandler *)new wxANIHandler();
20832 wxPyEndAllowThreads(__tstate);
20833 if (PyErr_Occurred()) SWIG_fail;
20834 }
20835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20836 return resultobj;
20837 fail:
20838 return NULL;
20839 }
20840
20841
20842 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20843 PyObject *obj;
20844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20845 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20846 return SWIG_Py_Void();
20847 }
20848
20849 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20850 return SWIG_Python_InitShadowInstance(args);
20851 }
20852
20853 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20854 PyObject *resultobj = 0;
20855 wxPNGHandler *result = 0 ;
20856
20857 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20858 {
20859 PyThreadState* __tstate = wxPyBeginAllowThreads();
20860 result = (wxPNGHandler *)new wxPNGHandler();
20861 wxPyEndAllowThreads(__tstate);
20862 if (PyErr_Occurred()) SWIG_fail;
20863 }
20864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20865 return resultobj;
20866 fail:
20867 return NULL;
20868 }
20869
20870
20871 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20872 PyObject *obj;
20873 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20874 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20875 return SWIG_Py_Void();
20876 }
20877
20878 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20879 return SWIG_Python_InitShadowInstance(args);
20880 }
20881
20882 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20883 PyObject *resultobj = 0;
20884 wxGIFHandler *result = 0 ;
20885
20886 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20887 {
20888 PyThreadState* __tstate = wxPyBeginAllowThreads();
20889 result = (wxGIFHandler *)new wxGIFHandler();
20890 wxPyEndAllowThreads(__tstate);
20891 if (PyErr_Occurred()) SWIG_fail;
20892 }
20893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20894 return resultobj;
20895 fail:
20896 return NULL;
20897 }
20898
20899
20900 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20901 PyObject *obj;
20902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20903 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20904 return SWIG_Py_Void();
20905 }
20906
20907 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20908 return SWIG_Python_InitShadowInstance(args);
20909 }
20910
20911 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20912 PyObject *resultobj = 0;
20913 wxPCXHandler *result = 0 ;
20914
20915 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20916 {
20917 PyThreadState* __tstate = wxPyBeginAllowThreads();
20918 result = (wxPCXHandler *)new wxPCXHandler();
20919 wxPyEndAllowThreads(__tstate);
20920 if (PyErr_Occurred()) SWIG_fail;
20921 }
20922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20923 return resultobj;
20924 fail:
20925 return NULL;
20926 }
20927
20928
20929 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20930 PyObject *obj;
20931 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20932 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20933 return SWIG_Py_Void();
20934 }
20935
20936 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20937 return SWIG_Python_InitShadowInstance(args);
20938 }
20939
20940 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20941 PyObject *resultobj = 0;
20942 wxJPEGHandler *result = 0 ;
20943
20944 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20945 {
20946 PyThreadState* __tstate = wxPyBeginAllowThreads();
20947 result = (wxJPEGHandler *)new wxJPEGHandler();
20948 wxPyEndAllowThreads(__tstate);
20949 if (PyErr_Occurred()) SWIG_fail;
20950 }
20951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20952 return resultobj;
20953 fail:
20954 return NULL;
20955 }
20956
20957
20958 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20959 PyObject *obj;
20960 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20961 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20962 return SWIG_Py_Void();
20963 }
20964
20965 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20966 return SWIG_Python_InitShadowInstance(args);
20967 }
20968
20969 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20970 PyObject *resultobj = 0;
20971 wxPNMHandler *result = 0 ;
20972
20973 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20974 {
20975 PyThreadState* __tstate = wxPyBeginAllowThreads();
20976 result = (wxPNMHandler *)new wxPNMHandler();
20977 wxPyEndAllowThreads(__tstate);
20978 if (PyErr_Occurred()) SWIG_fail;
20979 }
20980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20981 return resultobj;
20982 fail:
20983 return NULL;
20984 }
20985
20986
20987 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20988 PyObject *obj;
20989 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20990 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20991 return SWIG_Py_Void();
20992 }
20993
20994 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20995 return SWIG_Python_InitShadowInstance(args);
20996 }
20997
20998 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20999 PyObject *resultobj = 0;
21000 wxXPMHandler *result = 0 ;
21001
21002 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
21003 {
21004 PyThreadState* __tstate = wxPyBeginAllowThreads();
21005 result = (wxXPMHandler *)new wxXPMHandler();
21006 wxPyEndAllowThreads(__tstate);
21007 if (PyErr_Occurred()) SWIG_fail;
21008 }
21009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
21010 return resultobj;
21011 fail:
21012 return NULL;
21013 }
21014
21015
21016 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21017 PyObject *obj;
21018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21019 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
21020 return SWIG_Py_Void();
21021 }
21022
21023 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21024 return SWIG_Python_InitShadowInstance(args);
21025 }
21026
21027 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21028 PyObject *resultobj = 0;
21029 wxTIFFHandler *result = 0 ;
21030
21031 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
21032 {
21033 PyThreadState* __tstate = wxPyBeginAllowThreads();
21034 result = (wxTIFFHandler *)new wxTIFFHandler();
21035 wxPyEndAllowThreads(__tstate);
21036 if (PyErr_Occurred()) SWIG_fail;
21037 }
21038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
21039 return resultobj;
21040 fail:
21041 return NULL;
21042 }
21043
21044
21045 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21046 PyObject *obj;
21047 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21048 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
21049 return SWIG_Py_Void();
21050 }
21051
21052 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21053 return SWIG_Python_InitShadowInstance(args);
21054 }
21055
21056 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21057 PyObject *resultobj = 0;
21058 wxTGAHandler *result = 0 ;
21059
21060 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
21061 {
21062 PyThreadState* __tstate = wxPyBeginAllowThreads();
21063 result = (wxTGAHandler *)new wxTGAHandler();
21064 wxPyEndAllowThreads(__tstate);
21065 if (PyErr_Occurred()) SWIG_fail;
21066 }
21067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
21068 return resultobj;
21069 fail:
21070 return NULL;
21071 }
21072
21073
21074 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21075 PyObject *obj;
21076 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21077 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
21078 return SWIG_Py_Void();
21079 }
21080
21081 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21082 return SWIG_Python_InitShadowInstance(args);
21083 }
21084
21085 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21086 PyObject *resultobj = 0;
21087 wxImage *arg1 = 0 ;
21088 wxImage *arg2 = 0 ;
21089 int arg3 = (int) 236 ;
21090 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
21091 bool result;
21092 void *argp1 = 0 ;
21093 int res1 = 0 ;
21094 void *argp2 = 0 ;
21095 int res2 = 0 ;
21096 int val3 ;
21097 int ecode3 = 0 ;
21098 int val4 ;
21099 int ecode4 = 0 ;
21100 PyObject * obj0 = 0 ;
21101 PyObject * obj1 = 0 ;
21102 PyObject * obj2 = 0 ;
21103 PyObject * obj3 = 0 ;
21104 char * kwnames[] = {
21105 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
21106 };
21107
21108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21109 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
21110 if (!SWIG_IsOK(res1)) {
21111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
21112 }
21113 if (!argp1) {
21114 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
21115 }
21116 arg1 = reinterpret_cast< wxImage * >(argp1);
21117 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
21118 if (!SWIG_IsOK(res2)) {
21119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
21120 }
21121 if (!argp2) {
21122 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
21123 }
21124 arg2 = reinterpret_cast< wxImage * >(argp2);
21125 if (obj2) {
21126 ecode3 = SWIG_AsVal_int(obj2, &val3);
21127 if (!SWIG_IsOK(ecode3)) {
21128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
21129 }
21130 arg3 = static_cast< int >(val3);
21131 }
21132 if (obj3) {
21133 ecode4 = SWIG_AsVal_int(obj3, &val4);
21134 if (!SWIG_IsOK(ecode4)) {
21135 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
21136 }
21137 arg4 = static_cast< int >(val4);
21138 }
21139 {
21140 PyThreadState* __tstate = wxPyBeginAllowThreads();
21141 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
21142 wxPyEndAllowThreads(__tstate);
21143 if (PyErr_Occurred()) SWIG_fail;
21144 }
21145 {
21146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21147 }
21148 return resultobj;
21149 fail:
21150 return NULL;
21151 }
21152
21153
21154 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21155 PyObject *obj;
21156 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21157 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
21158 return SWIG_Py_Void();
21159 }
21160
21161 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21162 PyObject *resultobj = 0;
21163 wxEvtHandler *result = 0 ;
21164
21165 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
21166 {
21167 PyThreadState* __tstate = wxPyBeginAllowThreads();
21168 result = (wxEvtHandler *)new wxEvtHandler();
21169 wxPyEndAllowThreads(__tstate);
21170 if (PyErr_Occurred()) SWIG_fail;
21171 }
21172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
21173 return resultobj;
21174 fail:
21175 return NULL;
21176 }
21177
21178
21179 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21180 PyObject *resultobj = 0;
21181 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21182 wxEvtHandler *result = 0 ;
21183 void *argp1 = 0 ;
21184 int res1 = 0 ;
21185 PyObject *swig_obj[1] ;
21186
21187 if (!args) SWIG_fail;
21188 swig_obj[0] = args;
21189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21190 if (!SWIG_IsOK(res1)) {
21191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21192 }
21193 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21194 {
21195 PyThreadState* __tstate = wxPyBeginAllowThreads();
21196 result = (wxEvtHandler *)(arg1)->GetNextHandler();
21197 wxPyEndAllowThreads(__tstate);
21198 if (PyErr_Occurred()) SWIG_fail;
21199 }
21200 {
21201 resultobj = wxPyMake_wxObject(result, 0);
21202 }
21203 return resultobj;
21204 fail:
21205 return NULL;
21206 }
21207
21208
21209 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21210 PyObject *resultobj = 0;
21211 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21212 wxEvtHandler *result = 0 ;
21213 void *argp1 = 0 ;
21214 int res1 = 0 ;
21215 PyObject *swig_obj[1] ;
21216
21217 if (!args) SWIG_fail;
21218 swig_obj[0] = args;
21219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21220 if (!SWIG_IsOK(res1)) {
21221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21222 }
21223 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21224 {
21225 PyThreadState* __tstate = wxPyBeginAllowThreads();
21226 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
21227 wxPyEndAllowThreads(__tstate);
21228 if (PyErr_Occurred()) SWIG_fail;
21229 }
21230 {
21231 resultobj = wxPyMake_wxObject(result, 0);
21232 }
21233 return resultobj;
21234 fail:
21235 return NULL;
21236 }
21237
21238
21239 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21240 PyObject *resultobj = 0;
21241 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21242 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
21243 void *argp1 = 0 ;
21244 int res1 = 0 ;
21245 void *argp2 = 0 ;
21246 int res2 = 0 ;
21247 PyObject * obj0 = 0 ;
21248 PyObject * obj1 = 0 ;
21249 char * kwnames[] = {
21250 (char *) "self",(char *) "handler", NULL
21251 };
21252
21253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
21254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21255 if (!SWIG_IsOK(res1)) {
21256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21257 }
21258 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21259 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21260 if (!SWIG_IsOK(res2)) {
21261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
21262 }
21263 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
21264 {
21265 PyThreadState* __tstate = wxPyBeginAllowThreads();
21266 (arg1)->SetNextHandler(arg2);
21267 wxPyEndAllowThreads(__tstate);
21268 if (PyErr_Occurred()) SWIG_fail;
21269 }
21270 resultobj = SWIG_Py_Void();
21271 return resultobj;
21272 fail:
21273 return NULL;
21274 }
21275
21276
21277 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21278 PyObject *resultobj = 0;
21279 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21280 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
21281 void *argp1 = 0 ;
21282 int res1 = 0 ;
21283 void *argp2 = 0 ;
21284 int res2 = 0 ;
21285 PyObject * obj0 = 0 ;
21286 PyObject * obj1 = 0 ;
21287 char * kwnames[] = {
21288 (char *) "self",(char *) "handler", NULL
21289 };
21290
21291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
21292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21293 if (!SWIG_IsOK(res1)) {
21294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21295 }
21296 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21297 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21298 if (!SWIG_IsOK(res2)) {
21299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
21300 }
21301 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
21302 {
21303 PyThreadState* __tstate = wxPyBeginAllowThreads();
21304 (arg1)->SetPreviousHandler(arg2);
21305 wxPyEndAllowThreads(__tstate);
21306 if (PyErr_Occurred()) SWIG_fail;
21307 }
21308 resultobj = SWIG_Py_Void();
21309 return resultobj;
21310 fail:
21311 return NULL;
21312 }
21313
21314
21315 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21316 PyObject *resultobj = 0;
21317 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21318 bool result;
21319 void *argp1 = 0 ;
21320 int res1 = 0 ;
21321 PyObject *swig_obj[1] ;
21322
21323 if (!args) SWIG_fail;
21324 swig_obj[0] = args;
21325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21326 if (!SWIG_IsOK(res1)) {
21327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21328 }
21329 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21330 {
21331 PyThreadState* __tstate = wxPyBeginAllowThreads();
21332 result = (bool)(arg1)->GetEvtHandlerEnabled();
21333 wxPyEndAllowThreads(__tstate);
21334 if (PyErr_Occurred()) SWIG_fail;
21335 }
21336 {
21337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21338 }
21339 return resultobj;
21340 fail:
21341 return NULL;
21342 }
21343
21344
21345 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21346 PyObject *resultobj = 0;
21347 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21348 bool arg2 ;
21349 void *argp1 = 0 ;
21350 int res1 = 0 ;
21351 bool val2 ;
21352 int ecode2 = 0 ;
21353 PyObject * obj0 = 0 ;
21354 PyObject * obj1 = 0 ;
21355 char * kwnames[] = {
21356 (char *) "self",(char *) "enabled", NULL
21357 };
21358
21359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
21360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21361 if (!SWIG_IsOK(res1)) {
21362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21363 }
21364 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21365 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21366 if (!SWIG_IsOK(ecode2)) {
21367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
21368 }
21369 arg2 = static_cast< bool >(val2);
21370 {
21371 PyThreadState* __tstate = wxPyBeginAllowThreads();
21372 (arg1)->SetEvtHandlerEnabled(arg2);
21373 wxPyEndAllowThreads(__tstate);
21374 if (PyErr_Occurred()) SWIG_fail;
21375 }
21376 resultobj = SWIG_Py_Void();
21377 return resultobj;
21378 fail:
21379 return NULL;
21380 }
21381
21382
21383 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21384 PyObject *resultobj = 0;
21385 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21386 wxEvent *arg2 = 0 ;
21387 bool result;
21388 void *argp1 = 0 ;
21389 int res1 = 0 ;
21390 void *argp2 = 0 ;
21391 int res2 = 0 ;
21392 PyObject * obj0 = 0 ;
21393 PyObject * obj1 = 0 ;
21394 char * kwnames[] = {
21395 (char *) "self",(char *) "event", NULL
21396 };
21397
21398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21400 if (!SWIG_IsOK(res1)) {
21401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21402 }
21403 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21404 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
21405 if (!SWIG_IsOK(res2)) {
21406 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21407 }
21408 if (!argp2) {
21409 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21410 }
21411 arg2 = reinterpret_cast< wxEvent * >(argp2);
21412 {
21413 PyThreadState* __tstate = wxPyBeginAllowThreads();
21414 result = (bool)(arg1)->ProcessEvent(*arg2);
21415 wxPyEndAllowThreads(__tstate);
21416 if (PyErr_Occurred()) SWIG_fail;
21417 }
21418 {
21419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21420 }
21421 return resultobj;
21422 fail:
21423 return NULL;
21424 }
21425
21426
21427 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21428 PyObject *resultobj = 0;
21429 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21430 wxEvent *arg2 = 0 ;
21431 void *argp1 = 0 ;
21432 int res1 = 0 ;
21433 void *argp2 = 0 ;
21434 int res2 = 0 ;
21435 PyObject * obj0 = 0 ;
21436 PyObject * obj1 = 0 ;
21437 char * kwnames[] = {
21438 (char *) "self",(char *) "event", NULL
21439 };
21440
21441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21443 if (!SWIG_IsOK(res1)) {
21444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21445 }
21446 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21447 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
21448 if (!SWIG_IsOK(res2)) {
21449 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21450 }
21451 if (!argp2) {
21452 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21453 }
21454 arg2 = reinterpret_cast< wxEvent * >(argp2);
21455 {
21456 PyThreadState* __tstate = wxPyBeginAllowThreads();
21457 (arg1)->AddPendingEvent(*arg2);
21458 wxPyEndAllowThreads(__tstate);
21459 if (PyErr_Occurred()) SWIG_fail;
21460 }
21461 resultobj = SWIG_Py_Void();
21462 return resultobj;
21463 fail:
21464 return NULL;
21465 }
21466
21467
21468 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21469 PyObject *resultobj = 0;
21470 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21471 void *argp1 = 0 ;
21472 int res1 = 0 ;
21473 PyObject *swig_obj[1] ;
21474
21475 if (!args) SWIG_fail;
21476 swig_obj[0] = args;
21477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21478 if (!SWIG_IsOK(res1)) {
21479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21480 }
21481 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21482 {
21483 PyThreadState* __tstate = wxPyBeginAllowThreads();
21484 (arg1)->ProcessPendingEvents();
21485 wxPyEndAllowThreads(__tstate);
21486 if (PyErr_Occurred()) SWIG_fail;
21487 }
21488 resultobj = SWIG_Py_Void();
21489 return resultobj;
21490 fail:
21491 return NULL;
21492 }
21493
21494
21495 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21496 PyObject *resultobj = 0;
21497 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21498 int arg2 ;
21499 int arg3 ;
21500 int arg4 ;
21501 PyObject *arg5 = (PyObject *) 0 ;
21502 void *argp1 = 0 ;
21503 int res1 = 0 ;
21504 int val2 ;
21505 int ecode2 = 0 ;
21506 int val3 ;
21507 int ecode3 = 0 ;
21508 int val4 ;
21509 int ecode4 = 0 ;
21510 PyObject * obj0 = 0 ;
21511 PyObject * obj1 = 0 ;
21512 PyObject * obj2 = 0 ;
21513 PyObject * obj3 = 0 ;
21514 PyObject * obj4 = 0 ;
21515 char * kwnames[] = {
21516 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
21517 };
21518
21519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21521 if (!SWIG_IsOK(res1)) {
21522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21523 }
21524 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21525 ecode2 = SWIG_AsVal_int(obj1, &val2);
21526 if (!SWIG_IsOK(ecode2)) {
21527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
21528 }
21529 arg2 = static_cast< int >(val2);
21530 ecode3 = SWIG_AsVal_int(obj2, &val3);
21531 if (!SWIG_IsOK(ecode3)) {
21532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
21533 }
21534 arg3 = static_cast< int >(val3);
21535 ecode4 = SWIG_AsVal_int(obj3, &val4);
21536 if (!SWIG_IsOK(ecode4)) {
21537 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
21538 }
21539 arg4 = static_cast< int >(val4);
21540 arg5 = obj4;
21541 {
21542 PyThreadState* __tstate = wxPyBeginAllowThreads();
21543 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
21544 wxPyEndAllowThreads(__tstate);
21545 if (PyErr_Occurred()) SWIG_fail;
21546 }
21547 resultobj = SWIG_Py_Void();
21548 return resultobj;
21549 fail:
21550 return NULL;
21551 }
21552
21553
21554 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21555 PyObject *resultobj = 0;
21556 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21557 int arg2 ;
21558 int arg3 = (int) -1 ;
21559 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
21560 bool result;
21561 void *argp1 = 0 ;
21562 int res1 = 0 ;
21563 int val2 ;
21564 int ecode2 = 0 ;
21565 int val3 ;
21566 int ecode3 = 0 ;
21567 int val4 ;
21568 int ecode4 = 0 ;
21569 PyObject * obj0 = 0 ;
21570 PyObject * obj1 = 0 ;
21571 PyObject * obj2 = 0 ;
21572 PyObject * obj3 = 0 ;
21573 char * kwnames[] = {
21574 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
21575 };
21576
21577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21579 if (!SWIG_IsOK(res1)) {
21580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21581 }
21582 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21583 ecode2 = SWIG_AsVal_int(obj1, &val2);
21584 if (!SWIG_IsOK(ecode2)) {
21585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
21586 }
21587 arg2 = static_cast< int >(val2);
21588 if (obj2) {
21589 ecode3 = SWIG_AsVal_int(obj2, &val3);
21590 if (!SWIG_IsOK(ecode3)) {
21591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
21592 }
21593 arg3 = static_cast< int >(val3);
21594 }
21595 if (obj3) {
21596 ecode4 = SWIG_AsVal_int(obj3, &val4);
21597 if (!SWIG_IsOK(ecode4)) {
21598 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
21599 }
21600 arg4 = static_cast< wxEventType >(val4);
21601 }
21602 {
21603 PyThreadState* __tstate = wxPyBeginAllowThreads();
21604 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
21605 wxPyEndAllowThreads(__tstate);
21606 if (PyErr_Occurred()) SWIG_fail;
21607 }
21608 {
21609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21610 }
21611 return resultobj;
21612 fail:
21613 return NULL;
21614 }
21615
21616
21617 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21618 PyObject *resultobj = 0;
21619 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21620 PyObject *arg2 = (PyObject *) 0 ;
21621 bool arg3 = (bool) true ;
21622 void *argp1 = 0 ;
21623 int res1 = 0 ;
21624 bool val3 ;
21625 int ecode3 = 0 ;
21626 PyObject * obj0 = 0 ;
21627 PyObject * obj1 = 0 ;
21628 PyObject * obj2 = 0 ;
21629 char * kwnames[] = {
21630 (char *) "self",(char *) "_self",(char *) "incref", NULL
21631 };
21632
21633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21635 if (!SWIG_IsOK(res1)) {
21636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21637 }
21638 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21639 arg2 = obj1;
21640 if (obj2) {
21641 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21642 if (!SWIG_IsOK(ecode3)) {
21643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21644 }
21645 arg3 = static_cast< bool >(val3);
21646 }
21647 {
21648 PyThreadState* __tstate = wxPyBeginAllowThreads();
21649 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21650 wxPyEndAllowThreads(__tstate);
21651 if (PyErr_Occurred()) SWIG_fail;
21652 }
21653 resultobj = SWIG_Py_Void();
21654 return resultobj;
21655 fail:
21656 return NULL;
21657 }
21658
21659
21660 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21661 PyObject *obj;
21662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21663 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21664 return SWIG_Py_Void();
21665 }
21666
21667 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21668 return SWIG_Python_InitShadowInstance(args);
21669 }
21670
21671 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21672 PyObject *resultobj = 0;
21673 wxEventType result;
21674
21675 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21676 {
21677 PyThreadState* __tstate = wxPyBeginAllowThreads();
21678 result = (wxEventType)wxNewEventType();
21679 wxPyEndAllowThreads(__tstate);
21680 if (PyErr_Occurred()) SWIG_fail;
21681 }
21682 resultobj = SWIG_From_int(static_cast< int >(result));
21683 return resultobj;
21684 fail:
21685 return NULL;
21686 }
21687
21688
21689 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21690 PyObject *resultobj = 0;
21691 wxEvent *arg1 = (wxEvent *) 0 ;
21692 void *argp1 = 0 ;
21693 int res1 = 0 ;
21694 PyObject *swig_obj[1] ;
21695
21696 if (!args) SWIG_fail;
21697 swig_obj[0] = args;
21698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21699 if (!SWIG_IsOK(res1)) {
21700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21701 }
21702 arg1 = reinterpret_cast< wxEvent * >(argp1);
21703 {
21704 PyThreadState* __tstate = wxPyBeginAllowThreads();
21705 delete arg1;
21706
21707 wxPyEndAllowThreads(__tstate);
21708 if (PyErr_Occurred()) SWIG_fail;
21709 }
21710 resultobj = SWIG_Py_Void();
21711 return resultobj;
21712 fail:
21713 return NULL;
21714 }
21715
21716
21717 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21718 PyObject *resultobj = 0;
21719 wxEvent *arg1 = (wxEvent *) 0 ;
21720 wxEventType arg2 ;
21721 void *argp1 = 0 ;
21722 int res1 = 0 ;
21723 int val2 ;
21724 int ecode2 = 0 ;
21725 PyObject * obj0 = 0 ;
21726 PyObject * obj1 = 0 ;
21727 char * kwnames[] = {
21728 (char *) "self",(char *) "typ", NULL
21729 };
21730
21731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21733 if (!SWIG_IsOK(res1)) {
21734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21735 }
21736 arg1 = reinterpret_cast< wxEvent * >(argp1);
21737 ecode2 = SWIG_AsVal_int(obj1, &val2);
21738 if (!SWIG_IsOK(ecode2)) {
21739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21740 }
21741 arg2 = static_cast< wxEventType >(val2);
21742 {
21743 PyThreadState* __tstate = wxPyBeginAllowThreads();
21744 (arg1)->SetEventType(arg2);
21745 wxPyEndAllowThreads(__tstate);
21746 if (PyErr_Occurred()) SWIG_fail;
21747 }
21748 resultobj = SWIG_Py_Void();
21749 return resultobj;
21750 fail:
21751 return NULL;
21752 }
21753
21754
21755 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21756 PyObject *resultobj = 0;
21757 wxEvent *arg1 = (wxEvent *) 0 ;
21758 wxEventType result;
21759 void *argp1 = 0 ;
21760 int res1 = 0 ;
21761 PyObject *swig_obj[1] ;
21762
21763 if (!args) SWIG_fail;
21764 swig_obj[0] = args;
21765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21766 if (!SWIG_IsOK(res1)) {
21767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21768 }
21769 arg1 = reinterpret_cast< wxEvent * >(argp1);
21770 {
21771 PyThreadState* __tstate = wxPyBeginAllowThreads();
21772 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21773 wxPyEndAllowThreads(__tstate);
21774 if (PyErr_Occurred()) SWIG_fail;
21775 }
21776 resultobj = SWIG_From_int(static_cast< int >(result));
21777 return resultobj;
21778 fail:
21779 return NULL;
21780 }
21781
21782
21783 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21784 PyObject *resultobj = 0;
21785 wxEvent *arg1 = (wxEvent *) 0 ;
21786 wxObject *result = 0 ;
21787 void *argp1 = 0 ;
21788 int res1 = 0 ;
21789 PyObject *swig_obj[1] ;
21790
21791 if (!args) SWIG_fail;
21792 swig_obj[0] = args;
21793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21794 if (!SWIG_IsOK(res1)) {
21795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21796 }
21797 arg1 = reinterpret_cast< wxEvent * >(argp1);
21798 {
21799 PyThreadState* __tstate = wxPyBeginAllowThreads();
21800 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21801 wxPyEndAllowThreads(__tstate);
21802 if (PyErr_Occurred()) SWIG_fail;
21803 }
21804 {
21805 resultobj = wxPyMake_wxObject(result, (bool)0);
21806 }
21807 return resultobj;
21808 fail:
21809 return NULL;
21810 }
21811
21812
21813 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21814 PyObject *resultobj = 0;
21815 wxEvent *arg1 = (wxEvent *) 0 ;
21816 wxObject *arg2 = (wxObject *) 0 ;
21817 void *argp1 = 0 ;
21818 int res1 = 0 ;
21819 void *argp2 = 0 ;
21820 int res2 = 0 ;
21821 PyObject * obj0 = 0 ;
21822 PyObject * obj1 = 0 ;
21823 char * kwnames[] = {
21824 (char *) "self",(char *) "obj", NULL
21825 };
21826
21827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21829 if (!SWIG_IsOK(res1)) {
21830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21831 }
21832 arg1 = reinterpret_cast< wxEvent * >(argp1);
21833 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21834 if (!SWIG_IsOK(res2)) {
21835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21836 }
21837 arg2 = reinterpret_cast< wxObject * >(argp2);
21838 {
21839 PyThreadState* __tstate = wxPyBeginAllowThreads();
21840 (arg1)->SetEventObject(arg2);
21841 wxPyEndAllowThreads(__tstate);
21842 if (PyErr_Occurred()) SWIG_fail;
21843 }
21844 resultobj = SWIG_Py_Void();
21845 return resultobj;
21846 fail:
21847 return NULL;
21848 }
21849
21850
21851 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21852 PyObject *resultobj = 0;
21853 wxEvent *arg1 = (wxEvent *) 0 ;
21854 long result;
21855 void *argp1 = 0 ;
21856 int res1 = 0 ;
21857 PyObject *swig_obj[1] ;
21858
21859 if (!args) SWIG_fail;
21860 swig_obj[0] = args;
21861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21862 if (!SWIG_IsOK(res1)) {
21863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21864 }
21865 arg1 = reinterpret_cast< wxEvent * >(argp1);
21866 {
21867 PyThreadState* __tstate = wxPyBeginAllowThreads();
21868 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21869 wxPyEndAllowThreads(__tstate);
21870 if (PyErr_Occurred()) SWIG_fail;
21871 }
21872 resultobj = SWIG_From_long(static_cast< long >(result));
21873 return resultobj;
21874 fail:
21875 return NULL;
21876 }
21877
21878
21879 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21880 PyObject *resultobj = 0;
21881 wxEvent *arg1 = (wxEvent *) 0 ;
21882 long arg2 = (long) 0 ;
21883 void *argp1 = 0 ;
21884 int res1 = 0 ;
21885 long val2 ;
21886 int ecode2 = 0 ;
21887 PyObject * obj0 = 0 ;
21888 PyObject * obj1 = 0 ;
21889 char * kwnames[] = {
21890 (char *) "self",(char *) "ts", NULL
21891 };
21892
21893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21895 if (!SWIG_IsOK(res1)) {
21896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21897 }
21898 arg1 = reinterpret_cast< wxEvent * >(argp1);
21899 if (obj1) {
21900 ecode2 = SWIG_AsVal_long(obj1, &val2);
21901 if (!SWIG_IsOK(ecode2)) {
21902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21903 }
21904 arg2 = static_cast< long >(val2);
21905 }
21906 {
21907 PyThreadState* __tstate = wxPyBeginAllowThreads();
21908 (arg1)->SetTimestamp(arg2);
21909 wxPyEndAllowThreads(__tstate);
21910 if (PyErr_Occurred()) SWIG_fail;
21911 }
21912 resultobj = SWIG_Py_Void();
21913 return resultobj;
21914 fail:
21915 return NULL;
21916 }
21917
21918
21919 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21920 PyObject *resultobj = 0;
21921 wxEvent *arg1 = (wxEvent *) 0 ;
21922 int result;
21923 void *argp1 = 0 ;
21924 int res1 = 0 ;
21925 PyObject *swig_obj[1] ;
21926
21927 if (!args) SWIG_fail;
21928 swig_obj[0] = args;
21929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21930 if (!SWIG_IsOK(res1)) {
21931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21932 }
21933 arg1 = reinterpret_cast< wxEvent * >(argp1);
21934 {
21935 PyThreadState* __tstate = wxPyBeginAllowThreads();
21936 result = (int)((wxEvent const *)arg1)->GetId();
21937 wxPyEndAllowThreads(__tstate);
21938 if (PyErr_Occurred()) SWIG_fail;
21939 }
21940 resultobj = SWIG_From_int(static_cast< int >(result));
21941 return resultobj;
21942 fail:
21943 return NULL;
21944 }
21945
21946
21947 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21948 PyObject *resultobj = 0;
21949 wxEvent *arg1 = (wxEvent *) 0 ;
21950 int arg2 ;
21951 void *argp1 = 0 ;
21952 int res1 = 0 ;
21953 int val2 ;
21954 int ecode2 = 0 ;
21955 PyObject * obj0 = 0 ;
21956 PyObject * obj1 = 0 ;
21957 char * kwnames[] = {
21958 (char *) "self",(char *) "Id", NULL
21959 };
21960
21961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21963 if (!SWIG_IsOK(res1)) {
21964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21965 }
21966 arg1 = reinterpret_cast< wxEvent * >(argp1);
21967 ecode2 = SWIG_AsVal_int(obj1, &val2);
21968 if (!SWIG_IsOK(ecode2)) {
21969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21970 }
21971 arg2 = static_cast< int >(val2);
21972 {
21973 PyThreadState* __tstate = wxPyBeginAllowThreads();
21974 (arg1)->SetId(arg2);
21975 wxPyEndAllowThreads(__tstate);
21976 if (PyErr_Occurred()) SWIG_fail;
21977 }
21978 resultobj = SWIG_Py_Void();
21979 return resultobj;
21980 fail:
21981 return NULL;
21982 }
21983
21984
21985 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21986 PyObject *resultobj = 0;
21987 wxEvent *arg1 = (wxEvent *) 0 ;
21988 bool result;
21989 void *argp1 = 0 ;
21990 int res1 = 0 ;
21991 PyObject *swig_obj[1] ;
21992
21993 if (!args) SWIG_fail;
21994 swig_obj[0] = args;
21995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21996 if (!SWIG_IsOK(res1)) {
21997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21998 }
21999 arg1 = reinterpret_cast< wxEvent * >(argp1);
22000 {
22001 PyThreadState* __tstate = wxPyBeginAllowThreads();
22002 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
22003 wxPyEndAllowThreads(__tstate);
22004 if (PyErr_Occurred()) SWIG_fail;
22005 }
22006 {
22007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22008 }
22009 return resultobj;
22010 fail:
22011 return NULL;
22012 }
22013
22014
22015 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22016 PyObject *resultobj = 0;
22017 wxEvent *arg1 = (wxEvent *) 0 ;
22018 bool arg2 = (bool) true ;
22019 void *argp1 = 0 ;
22020 int res1 = 0 ;
22021 bool val2 ;
22022 int ecode2 = 0 ;
22023 PyObject * obj0 = 0 ;
22024 PyObject * obj1 = 0 ;
22025 char * kwnames[] = {
22026 (char *) "self",(char *) "skip", NULL
22027 };
22028
22029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
22030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22031 if (!SWIG_IsOK(res1)) {
22032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
22033 }
22034 arg1 = reinterpret_cast< wxEvent * >(argp1);
22035 if (obj1) {
22036 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22037 if (!SWIG_IsOK(ecode2)) {
22038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
22039 }
22040 arg2 = static_cast< bool >(val2);
22041 }
22042 {
22043 PyThreadState* __tstate = wxPyBeginAllowThreads();
22044 (arg1)->Skip(arg2);
22045 wxPyEndAllowThreads(__tstate);
22046 if (PyErr_Occurred()) SWIG_fail;
22047 }
22048 resultobj = SWIG_Py_Void();
22049 return resultobj;
22050 fail:
22051 return NULL;
22052 }
22053
22054
22055 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22056 PyObject *resultobj = 0;
22057 wxEvent *arg1 = (wxEvent *) 0 ;
22058 bool result;
22059 void *argp1 = 0 ;
22060 int res1 = 0 ;
22061 PyObject *swig_obj[1] ;
22062
22063 if (!args) SWIG_fail;
22064 swig_obj[0] = args;
22065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22066 if (!SWIG_IsOK(res1)) {
22067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
22068 }
22069 arg1 = reinterpret_cast< wxEvent * >(argp1);
22070 {
22071 PyThreadState* __tstate = wxPyBeginAllowThreads();
22072 result = (bool)((wxEvent const *)arg1)->GetSkipped();
22073 wxPyEndAllowThreads(__tstate);
22074 if (PyErr_Occurred()) SWIG_fail;
22075 }
22076 {
22077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22078 }
22079 return resultobj;
22080 fail:
22081 return NULL;
22082 }
22083
22084
22085 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22086 PyObject *resultobj = 0;
22087 wxEvent *arg1 = (wxEvent *) 0 ;
22088 bool result;
22089 void *argp1 = 0 ;
22090 int res1 = 0 ;
22091 PyObject *swig_obj[1] ;
22092
22093 if (!args) SWIG_fail;
22094 swig_obj[0] = args;
22095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22096 if (!SWIG_IsOK(res1)) {
22097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
22098 }
22099 arg1 = reinterpret_cast< wxEvent * >(argp1);
22100 {
22101 PyThreadState* __tstate = wxPyBeginAllowThreads();
22102 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
22103 wxPyEndAllowThreads(__tstate);
22104 if (PyErr_Occurred()) SWIG_fail;
22105 }
22106 {
22107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22108 }
22109 return resultobj;
22110 fail:
22111 return NULL;
22112 }
22113
22114
22115 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22116 PyObject *resultobj = 0;
22117 wxEvent *arg1 = (wxEvent *) 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_wxEvent, 0 | 0 );
22126 if (!SWIG_IsOK(res1)) {
22127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
22128 }
22129 arg1 = reinterpret_cast< wxEvent * >(argp1);
22130 {
22131 PyThreadState* __tstate = wxPyBeginAllowThreads();
22132 result = (int)(arg1)->StopPropagation();
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_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22144 PyObject *resultobj = 0;
22145 wxEvent *arg1 = (wxEvent *) 0 ;
22146 int arg2 ;
22147 void *argp1 = 0 ;
22148 int res1 = 0 ;
22149 int val2 ;
22150 int ecode2 = 0 ;
22151 PyObject * obj0 = 0 ;
22152 PyObject * obj1 = 0 ;
22153 char * kwnames[] = {
22154 (char *) "self",(char *) "propagationLevel", NULL
22155 };
22156
22157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
22158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22159 if (!SWIG_IsOK(res1)) {
22160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
22161 }
22162 arg1 = reinterpret_cast< wxEvent * >(argp1);
22163 ecode2 = SWIG_AsVal_int(obj1, &val2);
22164 if (!SWIG_IsOK(ecode2)) {
22165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
22166 }
22167 arg2 = static_cast< int >(val2);
22168 {
22169 PyThreadState* __tstate = wxPyBeginAllowThreads();
22170 (arg1)->ResumePropagation(arg2);
22171 wxPyEndAllowThreads(__tstate);
22172 if (PyErr_Occurred()) SWIG_fail;
22173 }
22174 resultobj = SWIG_Py_Void();
22175 return resultobj;
22176 fail:
22177 return NULL;
22178 }
22179
22180
22181 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22182 PyObject *resultobj = 0;
22183 wxEvent *arg1 = (wxEvent *) 0 ;
22184 wxEvent *result = 0 ;
22185 void *argp1 = 0 ;
22186 int res1 = 0 ;
22187 PyObject *swig_obj[1] ;
22188
22189 if (!args) SWIG_fail;
22190 swig_obj[0] = args;
22191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22192 if (!SWIG_IsOK(res1)) {
22193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
22194 }
22195 arg1 = reinterpret_cast< wxEvent * >(argp1);
22196 {
22197 PyThreadState* __tstate = wxPyBeginAllowThreads();
22198 result = (wxEvent *)(arg1)->Clone();
22199 wxPyEndAllowThreads(__tstate);
22200 if (PyErr_Occurred()) SWIG_fail;
22201 }
22202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22203 return resultobj;
22204 fail:
22205 return NULL;
22206 }
22207
22208
22209 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22210 PyObject *obj;
22211 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22212 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
22213 return SWIG_Py_Void();
22214 }
22215
22216 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22217 PyObject *resultobj = 0;
22218 wxEvent *arg1 = 0 ;
22219 wxPropagationDisabler *result = 0 ;
22220 void *argp1 = 0 ;
22221 int res1 = 0 ;
22222 PyObject * obj0 = 0 ;
22223 char * kwnames[] = {
22224 (char *) "event", NULL
22225 };
22226
22227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
22228 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
22229 if (!SWIG_IsOK(res1)) {
22230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
22231 }
22232 if (!argp1) {
22233 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
22234 }
22235 arg1 = reinterpret_cast< wxEvent * >(argp1);
22236 {
22237 PyThreadState* __tstate = wxPyBeginAllowThreads();
22238 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
22239 wxPyEndAllowThreads(__tstate);
22240 if (PyErr_Occurred()) SWIG_fail;
22241 }
22242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
22243 return resultobj;
22244 fail:
22245 return NULL;
22246 }
22247
22248
22249 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22250 PyObject *resultobj = 0;
22251 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
22252 void *argp1 = 0 ;
22253 int res1 = 0 ;
22254 PyObject *swig_obj[1] ;
22255
22256 if (!args) SWIG_fail;
22257 swig_obj[0] = args;
22258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
22259 if (!SWIG_IsOK(res1)) {
22260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
22261 }
22262 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
22263 {
22264 PyThreadState* __tstate = wxPyBeginAllowThreads();
22265 delete arg1;
22266
22267 wxPyEndAllowThreads(__tstate);
22268 if (PyErr_Occurred()) SWIG_fail;
22269 }
22270 resultobj = SWIG_Py_Void();
22271 return resultobj;
22272 fail:
22273 return NULL;
22274 }
22275
22276
22277 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22278 PyObject *obj;
22279 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22280 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
22281 return SWIG_Py_Void();
22282 }
22283
22284 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22285 return SWIG_Python_InitShadowInstance(args);
22286 }
22287
22288 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22289 PyObject *resultobj = 0;
22290 wxEvent *arg1 = 0 ;
22291 wxPropagateOnce *result = 0 ;
22292 void *argp1 = 0 ;
22293 int res1 = 0 ;
22294 PyObject * obj0 = 0 ;
22295 char * kwnames[] = {
22296 (char *) "event", NULL
22297 };
22298
22299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
22300 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
22301 if (!SWIG_IsOK(res1)) {
22302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
22303 }
22304 if (!argp1) {
22305 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
22306 }
22307 arg1 = reinterpret_cast< wxEvent * >(argp1);
22308 {
22309 PyThreadState* __tstate = wxPyBeginAllowThreads();
22310 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
22311 wxPyEndAllowThreads(__tstate);
22312 if (PyErr_Occurred()) SWIG_fail;
22313 }
22314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
22315 return resultobj;
22316 fail:
22317 return NULL;
22318 }
22319
22320
22321 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22322 PyObject *resultobj = 0;
22323 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
22324 void *argp1 = 0 ;
22325 int res1 = 0 ;
22326 PyObject *swig_obj[1] ;
22327
22328 if (!args) SWIG_fail;
22329 swig_obj[0] = args;
22330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
22331 if (!SWIG_IsOK(res1)) {
22332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
22333 }
22334 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
22335 {
22336 PyThreadState* __tstate = wxPyBeginAllowThreads();
22337 delete arg1;
22338
22339 wxPyEndAllowThreads(__tstate);
22340 if (PyErr_Occurred()) SWIG_fail;
22341 }
22342 resultobj = SWIG_Py_Void();
22343 return resultobj;
22344 fail:
22345 return NULL;
22346 }
22347
22348
22349 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22350 PyObject *obj;
22351 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22352 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
22353 return SWIG_Py_Void();
22354 }
22355
22356 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22357 return SWIG_Python_InitShadowInstance(args);
22358 }
22359
22360 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22361 PyObject *resultobj = 0;
22362 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22363 int arg2 = (int) 0 ;
22364 wxCommandEvent *result = 0 ;
22365 int val1 ;
22366 int ecode1 = 0 ;
22367 int val2 ;
22368 int ecode2 = 0 ;
22369 PyObject * obj0 = 0 ;
22370 PyObject * obj1 = 0 ;
22371 char * kwnames[] = {
22372 (char *) "commandType",(char *) "winid", NULL
22373 };
22374
22375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22376 if (obj0) {
22377 ecode1 = SWIG_AsVal_int(obj0, &val1);
22378 if (!SWIG_IsOK(ecode1)) {
22379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22380 }
22381 arg1 = static_cast< wxEventType >(val1);
22382 }
22383 if (obj1) {
22384 ecode2 = SWIG_AsVal_int(obj1, &val2);
22385 if (!SWIG_IsOK(ecode2)) {
22386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
22387 }
22388 arg2 = static_cast< int >(val2);
22389 }
22390 {
22391 PyThreadState* __tstate = wxPyBeginAllowThreads();
22392 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
22393 wxPyEndAllowThreads(__tstate);
22394 if (PyErr_Occurred()) SWIG_fail;
22395 }
22396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
22397 return resultobj;
22398 fail:
22399 return NULL;
22400 }
22401
22402
22403 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22404 PyObject *resultobj = 0;
22405 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22406 int result;
22407 void *argp1 = 0 ;
22408 int res1 = 0 ;
22409 PyObject *swig_obj[1] ;
22410
22411 if (!args) SWIG_fail;
22412 swig_obj[0] = args;
22413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22414 if (!SWIG_IsOK(res1)) {
22415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22416 }
22417 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22418 {
22419 PyThreadState* __tstate = wxPyBeginAllowThreads();
22420 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
22421 wxPyEndAllowThreads(__tstate);
22422 if (PyErr_Occurred()) SWIG_fail;
22423 }
22424 resultobj = SWIG_From_int(static_cast< int >(result));
22425 return resultobj;
22426 fail:
22427 return NULL;
22428 }
22429
22430
22431 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22432 PyObject *resultobj = 0;
22433 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22434 wxString *arg2 = 0 ;
22435 void *argp1 = 0 ;
22436 int res1 = 0 ;
22437 bool temp2 = false ;
22438 PyObject * obj0 = 0 ;
22439 PyObject * obj1 = 0 ;
22440 char * kwnames[] = {
22441 (char *) "self",(char *) "s", NULL
22442 };
22443
22444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
22445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22446 if (!SWIG_IsOK(res1)) {
22447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22448 }
22449 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22450 {
22451 arg2 = wxString_in_helper(obj1);
22452 if (arg2 == NULL) SWIG_fail;
22453 temp2 = true;
22454 }
22455 {
22456 PyThreadState* __tstate = wxPyBeginAllowThreads();
22457 (arg1)->SetString((wxString const &)*arg2);
22458 wxPyEndAllowThreads(__tstate);
22459 if (PyErr_Occurred()) SWIG_fail;
22460 }
22461 resultobj = SWIG_Py_Void();
22462 {
22463 if (temp2)
22464 delete arg2;
22465 }
22466 return resultobj;
22467 fail:
22468 {
22469 if (temp2)
22470 delete arg2;
22471 }
22472 return NULL;
22473 }
22474
22475
22476 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22477 PyObject *resultobj = 0;
22478 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22479 wxString result;
22480 void *argp1 = 0 ;
22481 int res1 = 0 ;
22482 PyObject *swig_obj[1] ;
22483
22484 if (!args) SWIG_fail;
22485 swig_obj[0] = args;
22486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22487 if (!SWIG_IsOK(res1)) {
22488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22489 }
22490 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22491 {
22492 PyThreadState* __tstate = wxPyBeginAllowThreads();
22493 result = ((wxCommandEvent const *)arg1)->GetString();
22494 wxPyEndAllowThreads(__tstate);
22495 if (PyErr_Occurred()) SWIG_fail;
22496 }
22497 {
22498 #if wxUSE_UNICODE
22499 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22500 #else
22501 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22502 #endif
22503 }
22504 return resultobj;
22505 fail:
22506 return NULL;
22507 }
22508
22509
22510 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22511 PyObject *resultobj = 0;
22512 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22513 bool result;
22514 void *argp1 = 0 ;
22515 int res1 = 0 ;
22516 PyObject *swig_obj[1] ;
22517
22518 if (!args) SWIG_fail;
22519 swig_obj[0] = args;
22520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22521 if (!SWIG_IsOK(res1)) {
22522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22523 }
22524 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22525 {
22526 PyThreadState* __tstate = wxPyBeginAllowThreads();
22527 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
22528 wxPyEndAllowThreads(__tstate);
22529 if (PyErr_Occurred()) SWIG_fail;
22530 }
22531 {
22532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22533 }
22534 return resultobj;
22535 fail:
22536 return NULL;
22537 }
22538
22539
22540 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22541 PyObject *resultobj = 0;
22542 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22543 bool result;
22544 void *argp1 = 0 ;
22545 int res1 = 0 ;
22546 PyObject *swig_obj[1] ;
22547
22548 if (!args) SWIG_fail;
22549 swig_obj[0] = args;
22550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22551 if (!SWIG_IsOK(res1)) {
22552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22553 }
22554 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22555 {
22556 PyThreadState* __tstate = wxPyBeginAllowThreads();
22557 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
22558 wxPyEndAllowThreads(__tstate);
22559 if (PyErr_Occurred()) SWIG_fail;
22560 }
22561 {
22562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22563 }
22564 return resultobj;
22565 fail:
22566 return NULL;
22567 }
22568
22569
22570 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22571 PyObject *resultobj = 0;
22572 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22573 long arg2 ;
22574 void *argp1 = 0 ;
22575 int res1 = 0 ;
22576 long val2 ;
22577 int ecode2 = 0 ;
22578 PyObject * obj0 = 0 ;
22579 PyObject * obj1 = 0 ;
22580 char * kwnames[] = {
22581 (char *) "self",(char *) "extraLong", NULL
22582 };
22583
22584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
22585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22586 if (!SWIG_IsOK(res1)) {
22587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22588 }
22589 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22590 ecode2 = SWIG_AsVal_long(obj1, &val2);
22591 if (!SWIG_IsOK(ecode2)) {
22592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
22593 }
22594 arg2 = static_cast< long >(val2);
22595 {
22596 PyThreadState* __tstate = wxPyBeginAllowThreads();
22597 (arg1)->SetExtraLong(arg2);
22598 wxPyEndAllowThreads(__tstate);
22599 if (PyErr_Occurred()) SWIG_fail;
22600 }
22601 resultobj = SWIG_Py_Void();
22602 return resultobj;
22603 fail:
22604 return NULL;
22605 }
22606
22607
22608 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22609 PyObject *resultobj = 0;
22610 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22611 long result;
22612 void *argp1 = 0 ;
22613 int res1 = 0 ;
22614 PyObject *swig_obj[1] ;
22615
22616 if (!args) SWIG_fail;
22617 swig_obj[0] = args;
22618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22619 if (!SWIG_IsOK(res1)) {
22620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22621 }
22622 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22623 {
22624 PyThreadState* __tstate = wxPyBeginAllowThreads();
22625 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22626 wxPyEndAllowThreads(__tstate);
22627 if (PyErr_Occurred()) SWIG_fail;
22628 }
22629 resultobj = SWIG_From_long(static_cast< long >(result));
22630 return resultobj;
22631 fail:
22632 return NULL;
22633 }
22634
22635
22636 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22637 PyObject *resultobj = 0;
22638 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22639 int arg2 ;
22640 void *argp1 = 0 ;
22641 int res1 = 0 ;
22642 int val2 ;
22643 int ecode2 = 0 ;
22644 PyObject * obj0 = 0 ;
22645 PyObject * obj1 = 0 ;
22646 char * kwnames[] = {
22647 (char *) "self",(char *) "i", NULL
22648 };
22649
22650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22652 if (!SWIG_IsOK(res1)) {
22653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22654 }
22655 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22656 ecode2 = SWIG_AsVal_int(obj1, &val2);
22657 if (!SWIG_IsOK(ecode2)) {
22658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22659 }
22660 arg2 = static_cast< int >(val2);
22661 {
22662 PyThreadState* __tstate = wxPyBeginAllowThreads();
22663 (arg1)->SetInt(arg2);
22664 wxPyEndAllowThreads(__tstate);
22665 if (PyErr_Occurred()) SWIG_fail;
22666 }
22667 resultobj = SWIG_Py_Void();
22668 return resultobj;
22669 fail:
22670 return NULL;
22671 }
22672
22673
22674 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22675 PyObject *resultobj = 0;
22676 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22677 int result;
22678 void *argp1 = 0 ;
22679 int res1 = 0 ;
22680 PyObject *swig_obj[1] ;
22681
22682 if (!args) SWIG_fail;
22683 swig_obj[0] = args;
22684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22685 if (!SWIG_IsOK(res1)) {
22686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22687 }
22688 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22689 {
22690 PyThreadState* __tstate = wxPyBeginAllowThreads();
22691 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22692 wxPyEndAllowThreads(__tstate);
22693 if (PyErr_Occurred()) SWIG_fail;
22694 }
22695 resultobj = SWIG_From_int(static_cast< int >(result));
22696 return resultobj;
22697 fail:
22698 return NULL;
22699 }
22700
22701
22702 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22703 PyObject *resultobj = 0;
22704 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22705 PyObject *result = 0 ;
22706 void *argp1 = 0 ;
22707 int res1 = 0 ;
22708 PyObject *swig_obj[1] ;
22709
22710 if (!args) SWIG_fail;
22711 swig_obj[0] = args;
22712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22713 if (!SWIG_IsOK(res1)) {
22714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22715 }
22716 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22717 {
22718 PyThreadState* __tstate = wxPyBeginAllowThreads();
22719 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22720 wxPyEndAllowThreads(__tstate);
22721 if (PyErr_Occurred()) SWIG_fail;
22722 }
22723 resultobj = result;
22724 return resultobj;
22725 fail:
22726 return NULL;
22727 }
22728
22729
22730 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22731 PyObject *resultobj = 0;
22732 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22733 PyObject *arg2 = (PyObject *) 0 ;
22734 void *argp1 = 0 ;
22735 int res1 = 0 ;
22736 PyObject * obj0 = 0 ;
22737 PyObject * obj1 = 0 ;
22738 char * kwnames[] = {
22739 (char *) "self",(char *) "clientData", NULL
22740 };
22741
22742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22744 if (!SWIG_IsOK(res1)) {
22745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22746 }
22747 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22748 arg2 = obj1;
22749 {
22750 PyThreadState* __tstate = wxPyBeginAllowThreads();
22751 wxCommandEvent_SetClientData(arg1,arg2);
22752 wxPyEndAllowThreads(__tstate);
22753 if (PyErr_Occurred()) SWIG_fail;
22754 }
22755 resultobj = SWIG_Py_Void();
22756 return resultobj;
22757 fail:
22758 return NULL;
22759 }
22760
22761
22762 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22763 PyObject *resultobj = 0;
22764 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22765 wxEvent *result = 0 ;
22766 void *argp1 = 0 ;
22767 int res1 = 0 ;
22768 PyObject *swig_obj[1] ;
22769
22770 if (!args) SWIG_fail;
22771 swig_obj[0] = args;
22772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22773 if (!SWIG_IsOK(res1)) {
22774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22775 }
22776 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22777 {
22778 PyThreadState* __tstate = wxPyBeginAllowThreads();
22779 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22780 wxPyEndAllowThreads(__tstate);
22781 if (PyErr_Occurred()) SWIG_fail;
22782 }
22783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22784 return resultobj;
22785 fail:
22786 return NULL;
22787 }
22788
22789
22790 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22791 PyObject *obj;
22792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22793 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22794 return SWIG_Py_Void();
22795 }
22796
22797 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22798 return SWIG_Python_InitShadowInstance(args);
22799 }
22800
22801 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22802 PyObject *resultobj = 0;
22803 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22804 int arg2 = (int) 0 ;
22805 wxNotifyEvent *result = 0 ;
22806 int val1 ;
22807 int ecode1 = 0 ;
22808 int val2 ;
22809 int ecode2 = 0 ;
22810 PyObject * obj0 = 0 ;
22811 PyObject * obj1 = 0 ;
22812 char * kwnames[] = {
22813 (char *) "commandType",(char *) "winid", NULL
22814 };
22815
22816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22817 if (obj0) {
22818 ecode1 = SWIG_AsVal_int(obj0, &val1);
22819 if (!SWIG_IsOK(ecode1)) {
22820 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22821 }
22822 arg1 = static_cast< wxEventType >(val1);
22823 }
22824 if (obj1) {
22825 ecode2 = SWIG_AsVal_int(obj1, &val2);
22826 if (!SWIG_IsOK(ecode2)) {
22827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22828 }
22829 arg2 = static_cast< int >(val2);
22830 }
22831 {
22832 PyThreadState* __tstate = wxPyBeginAllowThreads();
22833 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22834 wxPyEndAllowThreads(__tstate);
22835 if (PyErr_Occurred()) SWIG_fail;
22836 }
22837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22838 return resultobj;
22839 fail:
22840 return NULL;
22841 }
22842
22843
22844 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22845 PyObject *resultobj = 0;
22846 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22847 void *argp1 = 0 ;
22848 int res1 = 0 ;
22849 PyObject *swig_obj[1] ;
22850
22851 if (!args) SWIG_fail;
22852 swig_obj[0] = args;
22853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22854 if (!SWIG_IsOK(res1)) {
22855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22856 }
22857 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22858 {
22859 PyThreadState* __tstate = wxPyBeginAllowThreads();
22860 (arg1)->Veto();
22861 wxPyEndAllowThreads(__tstate);
22862 if (PyErr_Occurred()) SWIG_fail;
22863 }
22864 resultobj = SWIG_Py_Void();
22865 return resultobj;
22866 fail:
22867 return NULL;
22868 }
22869
22870
22871 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22872 PyObject *resultobj = 0;
22873 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22874 void *argp1 = 0 ;
22875 int res1 = 0 ;
22876 PyObject *swig_obj[1] ;
22877
22878 if (!args) SWIG_fail;
22879 swig_obj[0] = args;
22880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22881 if (!SWIG_IsOK(res1)) {
22882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22883 }
22884 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22885 {
22886 PyThreadState* __tstate = wxPyBeginAllowThreads();
22887 (arg1)->Allow();
22888 wxPyEndAllowThreads(__tstate);
22889 if (PyErr_Occurred()) SWIG_fail;
22890 }
22891 resultobj = SWIG_Py_Void();
22892 return resultobj;
22893 fail:
22894 return NULL;
22895 }
22896
22897
22898 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22899 PyObject *resultobj = 0;
22900 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22901 bool result;
22902 void *argp1 = 0 ;
22903 int res1 = 0 ;
22904 PyObject *swig_obj[1] ;
22905
22906 if (!args) SWIG_fail;
22907 swig_obj[0] = args;
22908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22909 if (!SWIG_IsOK(res1)) {
22910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22911 }
22912 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22913 {
22914 PyThreadState* __tstate = wxPyBeginAllowThreads();
22915 result = (bool)(arg1)->IsAllowed();
22916 wxPyEndAllowThreads(__tstate);
22917 if (PyErr_Occurred()) SWIG_fail;
22918 }
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 *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22929 PyObject *obj;
22930 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22931 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22932 return SWIG_Py_Void();
22933 }
22934
22935 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22936 return SWIG_Python_InitShadowInstance(args);
22937 }
22938
22939 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22940 PyObject *resultobj = 0;
22941 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22942 int arg2 = (int) 0 ;
22943 int arg3 = (int) 0 ;
22944 int arg4 = (int) 0 ;
22945 wxScrollEvent *result = 0 ;
22946 int val1 ;
22947 int ecode1 = 0 ;
22948 int val2 ;
22949 int ecode2 = 0 ;
22950 int val3 ;
22951 int ecode3 = 0 ;
22952 int val4 ;
22953 int ecode4 = 0 ;
22954 PyObject * obj0 = 0 ;
22955 PyObject * obj1 = 0 ;
22956 PyObject * obj2 = 0 ;
22957 PyObject * obj3 = 0 ;
22958 char * kwnames[] = {
22959 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22960 };
22961
22962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22963 if (obj0) {
22964 ecode1 = SWIG_AsVal_int(obj0, &val1);
22965 if (!SWIG_IsOK(ecode1)) {
22966 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22967 }
22968 arg1 = static_cast< wxEventType >(val1);
22969 }
22970 if (obj1) {
22971 ecode2 = SWIG_AsVal_int(obj1, &val2);
22972 if (!SWIG_IsOK(ecode2)) {
22973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22974 }
22975 arg2 = static_cast< int >(val2);
22976 }
22977 if (obj2) {
22978 ecode3 = SWIG_AsVal_int(obj2, &val3);
22979 if (!SWIG_IsOK(ecode3)) {
22980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22981 }
22982 arg3 = static_cast< int >(val3);
22983 }
22984 if (obj3) {
22985 ecode4 = SWIG_AsVal_int(obj3, &val4);
22986 if (!SWIG_IsOK(ecode4)) {
22987 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22988 }
22989 arg4 = static_cast< int >(val4);
22990 }
22991 {
22992 PyThreadState* __tstate = wxPyBeginAllowThreads();
22993 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22994 wxPyEndAllowThreads(__tstate);
22995 if (PyErr_Occurred()) SWIG_fail;
22996 }
22997 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22998 return resultobj;
22999 fail:
23000 return NULL;
23001 }
23002
23003
23004 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23005 PyObject *resultobj = 0;
23006 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
23007 int result;
23008 void *argp1 = 0 ;
23009 int res1 = 0 ;
23010 PyObject *swig_obj[1] ;
23011
23012 if (!args) SWIG_fail;
23013 swig_obj[0] = args;
23014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
23015 if (!SWIG_IsOK(res1)) {
23016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
23017 }
23018 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23019 {
23020 PyThreadState* __tstate = wxPyBeginAllowThreads();
23021 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
23022 wxPyEndAllowThreads(__tstate);
23023 if (PyErr_Occurred()) SWIG_fail;
23024 }
23025 resultobj = SWIG_From_int(static_cast< int >(result));
23026 return resultobj;
23027 fail:
23028 return NULL;
23029 }
23030
23031
23032 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23033 PyObject *resultobj = 0;
23034 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
23035 int result;
23036 void *argp1 = 0 ;
23037 int res1 = 0 ;
23038 PyObject *swig_obj[1] ;
23039
23040 if (!args) SWIG_fail;
23041 swig_obj[0] = args;
23042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
23043 if (!SWIG_IsOK(res1)) {
23044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
23045 }
23046 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23047 {
23048 PyThreadState* __tstate = wxPyBeginAllowThreads();
23049 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
23050 wxPyEndAllowThreads(__tstate);
23051 if (PyErr_Occurred()) SWIG_fail;
23052 }
23053 resultobj = SWIG_From_int(static_cast< int >(result));
23054 return resultobj;
23055 fail:
23056 return NULL;
23057 }
23058
23059
23060 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23061 PyObject *resultobj = 0;
23062 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
23063 int arg2 ;
23064 void *argp1 = 0 ;
23065 int res1 = 0 ;
23066 int val2 ;
23067 int ecode2 = 0 ;
23068 PyObject * obj0 = 0 ;
23069 PyObject * obj1 = 0 ;
23070 char * kwnames[] = {
23071 (char *) "self",(char *) "orient", NULL
23072 };
23073
23074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
23075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
23076 if (!SWIG_IsOK(res1)) {
23077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
23078 }
23079 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23080 ecode2 = SWIG_AsVal_int(obj1, &val2);
23081 if (!SWIG_IsOK(ecode2)) {
23082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
23083 }
23084 arg2 = static_cast< int >(val2);
23085 {
23086 PyThreadState* __tstate = wxPyBeginAllowThreads();
23087 (arg1)->SetOrientation(arg2);
23088 wxPyEndAllowThreads(__tstate);
23089 if (PyErr_Occurred()) SWIG_fail;
23090 }
23091 resultobj = SWIG_Py_Void();
23092 return resultobj;
23093 fail:
23094 return NULL;
23095 }
23096
23097
23098 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23099 PyObject *resultobj = 0;
23100 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
23101 int arg2 ;
23102 void *argp1 = 0 ;
23103 int res1 = 0 ;
23104 int val2 ;
23105 int ecode2 = 0 ;
23106 PyObject * obj0 = 0 ;
23107 PyObject * obj1 = 0 ;
23108 char * kwnames[] = {
23109 (char *) "self",(char *) "pos", NULL
23110 };
23111
23112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
23114 if (!SWIG_IsOK(res1)) {
23115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
23116 }
23117 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23118 ecode2 = SWIG_AsVal_int(obj1, &val2);
23119 if (!SWIG_IsOK(ecode2)) {
23120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
23121 }
23122 arg2 = static_cast< int >(val2);
23123 {
23124 PyThreadState* __tstate = wxPyBeginAllowThreads();
23125 (arg1)->SetPosition(arg2);
23126 wxPyEndAllowThreads(__tstate);
23127 if (PyErr_Occurred()) SWIG_fail;
23128 }
23129 resultobj = SWIG_Py_Void();
23130 return resultobj;
23131 fail:
23132 return NULL;
23133 }
23134
23135
23136 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23137 PyObject *obj;
23138 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23139 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
23140 return SWIG_Py_Void();
23141 }
23142
23143 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23144 return SWIG_Python_InitShadowInstance(args);
23145 }
23146
23147 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23148 PyObject *resultobj = 0;
23149 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23150 int arg2 = (int) 0 ;
23151 int arg3 = (int) 0 ;
23152 wxScrollWinEvent *result = 0 ;
23153 int val1 ;
23154 int ecode1 = 0 ;
23155 int val2 ;
23156 int ecode2 = 0 ;
23157 int val3 ;
23158 int ecode3 = 0 ;
23159 PyObject * obj0 = 0 ;
23160 PyObject * obj1 = 0 ;
23161 PyObject * obj2 = 0 ;
23162 char * kwnames[] = {
23163 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
23164 };
23165
23166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23167 if (obj0) {
23168 ecode1 = SWIG_AsVal_int(obj0, &val1);
23169 if (!SWIG_IsOK(ecode1)) {
23170 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23171 }
23172 arg1 = static_cast< wxEventType >(val1);
23173 }
23174 if (obj1) {
23175 ecode2 = SWIG_AsVal_int(obj1, &val2);
23176 if (!SWIG_IsOK(ecode2)) {
23177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
23178 }
23179 arg2 = static_cast< int >(val2);
23180 }
23181 if (obj2) {
23182 ecode3 = SWIG_AsVal_int(obj2, &val3);
23183 if (!SWIG_IsOK(ecode3)) {
23184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
23185 }
23186 arg3 = static_cast< int >(val3);
23187 }
23188 {
23189 PyThreadState* __tstate = wxPyBeginAllowThreads();
23190 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
23191 wxPyEndAllowThreads(__tstate);
23192 if (PyErr_Occurred()) SWIG_fail;
23193 }
23194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
23195 return resultobj;
23196 fail:
23197 return NULL;
23198 }
23199
23200
23201 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23202 PyObject *resultobj = 0;
23203 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23204 int result;
23205 void *argp1 = 0 ;
23206 int res1 = 0 ;
23207 PyObject *swig_obj[1] ;
23208
23209 if (!args) SWIG_fail;
23210 swig_obj[0] = args;
23211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23212 if (!SWIG_IsOK(res1)) {
23213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
23214 }
23215 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23216 {
23217 PyThreadState* __tstate = wxPyBeginAllowThreads();
23218 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
23219 wxPyEndAllowThreads(__tstate);
23220 if (PyErr_Occurred()) SWIG_fail;
23221 }
23222 resultobj = SWIG_From_int(static_cast< int >(result));
23223 return resultobj;
23224 fail:
23225 return NULL;
23226 }
23227
23228
23229 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23230 PyObject *resultobj = 0;
23231 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23232 int result;
23233 void *argp1 = 0 ;
23234 int res1 = 0 ;
23235 PyObject *swig_obj[1] ;
23236
23237 if (!args) SWIG_fail;
23238 swig_obj[0] = args;
23239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23240 if (!SWIG_IsOK(res1)) {
23241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
23242 }
23243 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23244 {
23245 PyThreadState* __tstate = wxPyBeginAllowThreads();
23246 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
23247 wxPyEndAllowThreads(__tstate);
23248 if (PyErr_Occurred()) SWIG_fail;
23249 }
23250 resultobj = SWIG_From_int(static_cast< int >(result));
23251 return resultobj;
23252 fail:
23253 return NULL;
23254 }
23255
23256
23257 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23258 PyObject *resultobj = 0;
23259 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23260 int arg2 ;
23261 void *argp1 = 0 ;
23262 int res1 = 0 ;
23263 int val2 ;
23264 int ecode2 = 0 ;
23265 PyObject * obj0 = 0 ;
23266 PyObject * obj1 = 0 ;
23267 char * kwnames[] = {
23268 (char *) "self",(char *) "orient", NULL
23269 };
23270
23271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
23272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23273 if (!SWIG_IsOK(res1)) {
23274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
23275 }
23276 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23277 ecode2 = SWIG_AsVal_int(obj1, &val2);
23278 if (!SWIG_IsOK(ecode2)) {
23279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
23280 }
23281 arg2 = static_cast< int >(val2);
23282 {
23283 PyThreadState* __tstate = wxPyBeginAllowThreads();
23284 (arg1)->SetOrientation(arg2);
23285 wxPyEndAllowThreads(__tstate);
23286 if (PyErr_Occurred()) SWIG_fail;
23287 }
23288 resultobj = SWIG_Py_Void();
23289 return resultobj;
23290 fail:
23291 return NULL;
23292 }
23293
23294
23295 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23296 PyObject *resultobj = 0;
23297 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23298 int arg2 ;
23299 void *argp1 = 0 ;
23300 int res1 = 0 ;
23301 int val2 ;
23302 int ecode2 = 0 ;
23303 PyObject * obj0 = 0 ;
23304 PyObject * obj1 = 0 ;
23305 char * kwnames[] = {
23306 (char *) "self",(char *) "pos", NULL
23307 };
23308
23309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23311 if (!SWIG_IsOK(res1)) {
23312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
23313 }
23314 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23315 ecode2 = SWIG_AsVal_int(obj1, &val2);
23316 if (!SWIG_IsOK(ecode2)) {
23317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
23318 }
23319 arg2 = static_cast< int >(val2);
23320 {
23321 PyThreadState* __tstate = wxPyBeginAllowThreads();
23322 (arg1)->SetPosition(arg2);
23323 wxPyEndAllowThreads(__tstate);
23324 if (PyErr_Occurred()) SWIG_fail;
23325 }
23326 resultobj = SWIG_Py_Void();
23327 return resultobj;
23328 fail:
23329 return NULL;
23330 }
23331
23332
23333 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23334 PyObject *obj;
23335 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23336 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
23337 return SWIG_Py_Void();
23338 }
23339
23340 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23341 return SWIG_Python_InitShadowInstance(args);
23342 }
23343
23344 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23345 PyObject *resultobj = 0;
23346 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23347 wxMouseEvent *result = 0 ;
23348 int val1 ;
23349 int ecode1 = 0 ;
23350 PyObject * obj0 = 0 ;
23351 char * kwnames[] = {
23352 (char *) "mouseType", NULL
23353 };
23354
23355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
23356 if (obj0) {
23357 ecode1 = SWIG_AsVal_int(obj0, &val1);
23358 if (!SWIG_IsOK(ecode1)) {
23359 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23360 }
23361 arg1 = static_cast< wxEventType >(val1);
23362 }
23363 {
23364 PyThreadState* __tstate = wxPyBeginAllowThreads();
23365 result = (wxMouseEvent *)new wxMouseEvent(arg1);
23366 wxPyEndAllowThreads(__tstate);
23367 if (PyErr_Occurred()) SWIG_fail;
23368 }
23369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
23370 return resultobj;
23371 fail:
23372 return NULL;
23373 }
23374
23375
23376 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23377 PyObject *resultobj = 0;
23378 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23379 bool result;
23380 void *argp1 = 0 ;
23381 int res1 = 0 ;
23382 PyObject *swig_obj[1] ;
23383
23384 if (!args) SWIG_fail;
23385 swig_obj[0] = args;
23386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23387 if (!SWIG_IsOK(res1)) {
23388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23389 }
23390 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23391 {
23392 PyThreadState* __tstate = wxPyBeginAllowThreads();
23393 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
23394 wxPyEndAllowThreads(__tstate);
23395 if (PyErr_Occurred()) SWIG_fail;
23396 }
23397 {
23398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23399 }
23400 return resultobj;
23401 fail:
23402 return NULL;
23403 }
23404
23405
23406 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23407 PyObject *resultobj = 0;
23408 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23409 int arg2 = (int) wxMOUSE_BTN_ANY ;
23410 bool result;
23411 void *argp1 = 0 ;
23412 int res1 = 0 ;
23413 int val2 ;
23414 int ecode2 = 0 ;
23415 PyObject * obj0 = 0 ;
23416 PyObject * obj1 = 0 ;
23417 char * kwnames[] = {
23418 (char *) "self",(char *) "but", NULL
23419 };
23420
23421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
23422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23423 if (!SWIG_IsOK(res1)) {
23424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23425 }
23426 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23427 if (obj1) {
23428 ecode2 = SWIG_AsVal_int(obj1, &val2);
23429 if (!SWIG_IsOK(ecode2)) {
23430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
23431 }
23432 arg2 = static_cast< int >(val2);
23433 }
23434 {
23435 PyThreadState* __tstate = wxPyBeginAllowThreads();
23436 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
23437 wxPyEndAllowThreads(__tstate);
23438 if (PyErr_Occurred()) SWIG_fail;
23439 }
23440 {
23441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23442 }
23443 return resultobj;
23444 fail:
23445 return NULL;
23446 }
23447
23448
23449 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23450 PyObject *resultobj = 0;
23451 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23452 int arg2 = (int) wxMOUSE_BTN_ANY ;
23453 bool result;
23454 void *argp1 = 0 ;
23455 int res1 = 0 ;
23456 int val2 ;
23457 int ecode2 = 0 ;
23458 PyObject * obj0 = 0 ;
23459 PyObject * obj1 = 0 ;
23460 char * kwnames[] = {
23461 (char *) "self",(char *) "but", NULL
23462 };
23463
23464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
23465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23466 if (!SWIG_IsOK(res1)) {
23467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23468 }
23469 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23470 if (obj1) {
23471 ecode2 = SWIG_AsVal_int(obj1, &val2);
23472 if (!SWIG_IsOK(ecode2)) {
23473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
23474 }
23475 arg2 = static_cast< int >(val2);
23476 }
23477 {
23478 PyThreadState* __tstate = wxPyBeginAllowThreads();
23479 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
23480 wxPyEndAllowThreads(__tstate);
23481 if (PyErr_Occurred()) SWIG_fail;
23482 }
23483 {
23484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23485 }
23486 return resultobj;
23487 fail:
23488 return NULL;
23489 }
23490
23491
23492 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23493 PyObject *resultobj = 0;
23494 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23495 int arg2 = (int) wxMOUSE_BTN_ANY ;
23496 bool result;
23497 void *argp1 = 0 ;
23498 int res1 = 0 ;
23499 int val2 ;
23500 int ecode2 = 0 ;
23501 PyObject * obj0 = 0 ;
23502 PyObject * obj1 = 0 ;
23503 char * kwnames[] = {
23504 (char *) "self",(char *) "but", NULL
23505 };
23506
23507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
23508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23509 if (!SWIG_IsOK(res1)) {
23510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23511 }
23512 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23513 if (obj1) {
23514 ecode2 = SWIG_AsVal_int(obj1, &val2);
23515 if (!SWIG_IsOK(ecode2)) {
23516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
23517 }
23518 arg2 = static_cast< int >(val2);
23519 }
23520 {
23521 PyThreadState* __tstate = wxPyBeginAllowThreads();
23522 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
23523 wxPyEndAllowThreads(__tstate);
23524 if (PyErr_Occurred()) SWIG_fail;
23525 }
23526 {
23527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23528 }
23529 return resultobj;
23530 fail:
23531 return NULL;
23532 }
23533
23534
23535 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23536 PyObject *resultobj = 0;
23537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23538 int arg2 ;
23539 bool result;
23540 void *argp1 = 0 ;
23541 int res1 = 0 ;
23542 int val2 ;
23543 int ecode2 = 0 ;
23544 PyObject * obj0 = 0 ;
23545 PyObject * obj1 = 0 ;
23546 char * kwnames[] = {
23547 (char *) "self",(char *) "button", NULL
23548 };
23549
23550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
23551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23552 if (!SWIG_IsOK(res1)) {
23553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23554 }
23555 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23556 ecode2 = SWIG_AsVal_int(obj1, &val2);
23557 if (!SWIG_IsOK(ecode2)) {
23558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
23559 }
23560 arg2 = static_cast< int >(val2);
23561 {
23562 PyThreadState* __tstate = wxPyBeginAllowThreads();
23563 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
23564 wxPyEndAllowThreads(__tstate);
23565 if (PyErr_Occurred()) SWIG_fail;
23566 }
23567 {
23568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23569 }
23570 return resultobj;
23571 fail:
23572 return NULL;
23573 }
23574
23575
23576 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23577 PyObject *resultobj = 0;
23578 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23579 int arg2 ;
23580 bool result;
23581 void *argp1 = 0 ;
23582 int res1 = 0 ;
23583 int val2 ;
23584 int ecode2 = 0 ;
23585 PyObject * obj0 = 0 ;
23586 PyObject * obj1 = 0 ;
23587 char * kwnames[] = {
23588 (char *) "self",(char *) "but", NULL
23589 };
23590
23591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
23592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23593 if (!SWIG_IsOK(res1)) {
23594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23595 }
23596 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23597 ecode2 = SWIG_AsVal_int(obj1, &val2);
23598 if (!SWIG_IsOK(ecode2)) {
23599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
23600 }
23601 arg2 = static_cast< int >(val2);
23602 {
23603 PyThreadState* __tstate = wxPyBeginAllowThreads();
23604 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23605 wxPyEndAllowThreads(__tstate);
23606 if (PyErr_Occurred()) SWIG_fail;
23607 }
23608 {
23609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23610 }
23611 return resultobj;
23612 fail:
23613 return NULL;
23614 }
23615
23616
23617 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23618 PyObject *resultobj = 0;
23619 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23620 int result;
23621 void *argp1 = 0 ;
23622 int res1 = 0 ;
23623 PyObject *swig_obj[1] ;
23624
23625 if (!args) SWIG_fail;
23626 swig_obj[0] = args;
23627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23628 if (!SWIG_IsOK(res1)) {
23629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23630 }
23631 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23632 {
23633 PyThreadState* __tstate = wxPyBeginAllowThreads();
23634 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23635 wxPyEndAllowThreads(__tstate);
23636 if (PyErr_Occurred()) SWIG_fail;
23637 }
23638 resultobj = SWIG_From_int(static_cast< int >(result));
23639 return resultobj;
23640 fail:
23641 return NULL;
23642 }
23643
23644
23645 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23646 PyObject *resultobj = 0;
23647 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23648 bool result;
23649 void *argp1 = 0 ;
23650 int res1 = 0 ;
23651 PyObject *swig_obj[1] ;
23652
23653 if (!args) SWIG_fail;
23654 swig_obj[0] = args;
23655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23656 if (!SWIG_IsOK(res1)) {
23657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23658 }
23659 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23660 {
23661 PyThreadState* __tstate = wxPyBeginAllowThreads();
23662 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23663 wxPyEndAllowThreads(__tstate);
23664 if (PyErr_Occurred()) SWIG_fail;
23665 }
23666 {
23667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23668 }
23669 return resultobj;
23670 fail:
23671 return NULL;
23672 }
23673
23674
23675 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23676 PyObject *resultobj = 0;
23677 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23678 bool result;
23679 void *argp1 = 0 ;
23680 int res1 = 0 ;
23681 PyObject *swig_obj[1] ;
23682
23683 if (!args) SWIG_fail;
23684 swig_obj[0] = args;
23685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23686 if (!SWIG_IsOK(res1)) {
23687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23688 }
23689 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23690 {
23691 PyThreadState* __tstate = wxPyBeginAllowThreads();
23692 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23693 wxPyEndAllowThreads(__tstate);
23694 if (PyErr_Occurred()) SWIG_fail;
23695 }
23696 {
23697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23698 }
23699 return resultobj;
23700 fail:
23701 return NULL;
23702 }
23703
23704
23705 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23706 PyObject *resultobj = 0;
23707 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23708 bool result;
23709 void *argp1 = 0 ;
23710 int res1 = 0 ;
23711 PyObject *swig_obj[1] ;
23712
23713 if (!args) SWIG_fail;
23714 swig_obj[0] = args;
23715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23716 if (!SWIG_IsOK(res1)) {
23717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23718 }
23719 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23720 {
23721 PyThreadState* __tstate = wxPyBeginAllowThreads();
23722 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23723 wxPyEndAllowThreads(__tstate);
23724 if (PyErr_Occurred()) SWIG_fail;
23725 }
23726 {
23727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23728 }
23729 return resultobj;
23730 fail:
23731 return NULL;
23732 }
23733
23734
23735 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23736 PyObject *resultobj = 0;
23737 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23738 bool result;
23739 void *argp1 = 0 ;
23740 int res1 = 0 ;
23741 PyObject *swig_obj[1] ;
23742
23743 if (!args) SWIG_fail;
23744 swig_obj[0] = args;
23745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23746 if (!SWIG_IsOK(res1)) {
23747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23748 }
23749 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23750 {
23751 PyThreadState* __tstate = wxPyBeginAllowThreads();
23752 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23753 wxPyEndAllowThreads(__tstate);
23754 if (PyErr_Occurred()) SWIG_fail;
23755 }
23756 {
23757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23758 }
23759 return resultobj;
23760 fail:
23761 return NULL;
23762 }
23763
23764
23765 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23766 PyObject *resultobj = 0;
23767 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23768 bool result;
23769 void *argp1 = 0 ;
23770 int res1 = 0 ;
23771 PyObject *swig_obj[1] ;
23772
23773 if (!args) SWIG_fail;
23774 swig_obj[0] = args;
23775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23776 if (!SWIG_IsOK(res1)) {
23777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23778 }
23779 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23780 {
23781 PyThreadState* __tstate = wxPyBeginAllowThreads();
23782 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23783 wxPyEndAllowThreads(__tstate);
23784 if (PyErr_Occurred()) SWIG_fail;
23785 }
23786 {
23787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23788 }
23789 return resultobj;
23790 fail:
23791 return NULL;
23792 }
23793
23794
23795 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23796 PyObject *resultobj = 0;
23797 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23798 bool result;
23799 void *argp1 = 0 ;
23800 int res1 = 0 ;
23801 PyObject *swig_obj[1] ;
23802
23803 if (!args) SWIG_fail;
23804 swig_obj[0] = args;
23805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23806 if (!SWIG_IsOK(res1)) {
23807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23808 }
23809 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23810 {
23811 PyThreadState* __tstate = wxPyBeginAllowThreads();
23812 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23813 wxPyEndAllowThreads(__tstate);
23814 if (PyErr_Occurred()) SWIG_fail;
23815 }
23816 {
23817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23818 }
23819 return resultobj;
23820 fail:
23821 return NULL;
23822 }
23823
23824
23825 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23826 PyObject *resultobj = 0;
23827 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23828 bool result;
23829 void *argp1 = 0 ;
23830 int res1 = 0 ;
23831 PyObject *swig_obj[1] ;
23832
23833 if (!args) SWIG_fail;
23834 swig_obj[0] = args;
23835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23836 if (!SWIG_IsOK(res1)) {
23837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23838 }
23839 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23840 {
23841 PyThreadState* __tstate = wxPyBeginAllowThreads();
23842 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23843 wxPyEndAllowThreads(__tstate);
23844 if (PyErr_Occurred()) SWIG_fail;
23845 }
23846 {
23847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23848 }
23849 return resultobj;
23850 fail:
23851 return NULL;
23852 }
23853
23854
23855 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23856 PyObject *resultobj = 0;
23857 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23858 bool result;
23859 void *argp1 = 0 ;
23860 int res1 = 0 ;
23861 PyObject *swig_obj[1] ;
23862
23863 if (!args) SWIG_fail;
23864 swig_obj[0] = args;
23865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23866 if (!SWIG_IsOK(res1)) {
23867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23868 }
23869 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23870 {
23871 PyThreadState* __tstate = wxPyBeginAllowThreads();
23872 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23873 wxPyEndAllowThreads(__tstate);
23874 if (PyErr_Occurred()) SWIG_fail;
23875 }
23876 {
23877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23878 }
23879 return resultobj;
23880 fail:
23881 return NULL;
23882 }
23883
23884
23885 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23886 PyObject *resultobj = 0;
23887 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23888 bool result;
23889 void *argp1 = 0 ;
23890 int res1 = 0 ;
23891 PyObject *swig_obj[1] ;
23892
23893 if (!args) SWIG_fail;
23894 swig_obj[0] = args;
23895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23896 if (!SWIG_IsOK(res1)) {
23897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23898 }
23899 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23900 {
23901 PyThreadState* __tstate = wxPyBeginAllowThreads();
23902 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23903 wxPyEndAllowThreads(__tstate);
23904 if (PyErr_Occurred()) SWIG_fail;
23905 }
23906 {
23907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23908 }
23909 return resultobj;
23910 fail:
23911 return NULL;
23912 }
23913
23914
23915 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23916 PyObject *resultobj = 0;
23917 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23918 bool result;
23919 void *argp1 = 0 ;
23920 int res1 = 0 ;
23921 PyObject *swig_obj[1] ;
23922
23923 if (!args) SWIG_fail;
23924 swig_obj[0] = args;
23925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23926 if (!SWIG_IsOK(res1)) {
23927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23928 }
23929 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23930 {
23931 PyThreadState* __tstate = wxPyBeginAllowThreads();
23932 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23933 wxPyEndAllowThreads(__tstate);
23934 if (PyErr_Occurred()) SWIG_fail;
23935 }
23936 {
23937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23938 }
23939 return resultobj;
23940 fail:
23941 return NULL;
23942 }
23943
23944
23945 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23946 PyObject *resultobj = 0;
23947 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23948 bool result;
23949 void *argp1 = 0 ;
23950 int res1 = 0 ;
23951 PyObject *swig_obj[1] ;
23952
23953 if (!args) SWIG_fail;
23954 swig_obj[0] = args;
23955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23956 if (!SWIG_IsOK(res1)) {
23957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23958 }
23959 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23960 {
23961 PyThreadState* __tstate = wxPyBeginAllowThreads();
23962 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23963 wxPyEndAllowThreads(__tstate);
23964 if (PyErr_Occurred()) SWIG_fail;
23965 }
23966 {
23967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23968 }
23969 return resultobj;
23970 fail:
23971 return NULL;
23972 }
23973
23974
23975 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23976 PyObject *resultobj = 0;
23977 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23978 bool result;
23979 void *argp1 = 0 ;
23980 int res1 = 0 ;
23981 PyObject *swig_obj[1] ;
23982
23983 if (!args) SWIG_fail;
23984 swig_obj[0] = args;
23985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23986 if (!SWIG_IsOK(res1)) {
23987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23988 }
23989 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23990 {
23991 PyThreadState* __tstate = wxPyBeginAllowThreads();
23992 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23993 wxPyEndAllowThreads(__tstate);
23994 if (PyErr_Occurred()) SWIG_fail;
23995 }
23996 {
23997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23998 }
23999 return resultobj;
24000 fail:
24001 return NULL;
24002 }
24003
24004
24005 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24006 PyObject *resultobj = 0;
24007 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24008 bool result;
24009 void *argp1 = 0 ;
24010 int res1 = 0 ;
24011 PyObject *swig_obj[1] ;
24012
24013 if (!args) SWIG_fail;
24014 swig_obj[0] = args;
24015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24016 if (!SWIG_IsOK(res1)) {
24017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24018 }
24019 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24020 {
24021 PyThreadState* __tstate = wxPyBeginAllowThreads();
24022 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
24023 wxPyEndAllowThreads(__tstate);
24024 if (PyErr_Occurred()) SWIG_fail;
24025 }
24026 {
24027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24028 }
24029 return resultobj;
24030 fail:
24031 return NULL;
24032 }
24033
24034
24035 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24036 PyObject *resultobj = 0;
24037 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24038 bool result;
24039 void *argp1 = 0 ;
24040 int res1 = 0 ;
24041 PyObject *swig_obj[1] ;
24042
24043 if (!args) SWIG_fail;
24044 swig_obj[0] = args;
24045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24046 if (!SWIG_IsOK(res1)) {
24047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24048 }
24049 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24050 {
24051 PyThreadState* __tstate = wxPyBeginAllowThreads();
24052 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
24053 wxPyEndAllowThreads(__tstate);
24054 if (PyErr_Occurred()) SWIG_fail;
24055 }
24056 {
24057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24058 }
24059 return resultobj;
24060 fail:
24061 return NULL;
24062 }
24063
24064
24065 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24066 PyObject *resultobj = 0;
24067 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24068 bool result;
24069 void *argp1 = 0 ;
24070 int res1 = 0 ;
24071 PyObject *swig_obj[1] ;
24072
24073 if (!args) SWIG_fail;
24074 swig_obj[0] = args;
24075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24076 if (!SWIG_IsOK(res1)) {
24077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24078 }
24079 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24080 {
24081 PyThreadState* __tstate = wxPyBeginAllowThreads();
24082 result = (bool)(arg1)->LeftIsDown();
24083 wxPyEndAllowThreads(__tstate);
24084 if (PyErr_Occurred()) SWIG_fail;
24085 }
24086 {
24087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24088 }
24089 return resultobj;
24090 fail:
24091 return NULL;
24092 }
24093
24094
24095 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24096 PyObject *resultobj = 0;
24097 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24098 bool result;
24099 void *argp1 = 0 ;
24100 int res1 = 0 ;
24101 PyObject *swig_obj[1] ;
24102
24103 if (!args) SWIG_fail;
24104 swig_obj[0] = args;
24105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24106 if (!SWIG_IsOK(res1)) {
24107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24108 }
24109 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24110 {
24111 PyThreadState* __tstate = wxPyBeginAllowThreads();
24112 result = (bool)(arg1)->MiddleIsDown();
24113 wxPyEndAllowThreads(__tstate);
24114 if (PyErr_Occurred()) SWIG_fail;
24115 }
24116 {
24117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24118 }
24119 return resultobj;
24120 fail:
24121 return NULL;
24122 }
24123
24124
24125 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24126 PyObject *resultobj = 0;
24127 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24128 bool result;
24129 void *argp1 = 0 ;
24130 int res1 = 0 ;
24131 PyObject *swig_obj[1] ;
24132
24133 if (!args) SWIG_fail;
24134 swig_obj[0] = args;
24135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24136 if (!SWIG_IsOK(res1)) {
24137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24138 }
24139 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24140 {
24141 PyThreadState* __tstate = wxPyBeginAllowThreads();
24142 result = (bool)(arg1)->RightIsDown();
24143 wxPyEndAllowThreads(__tstate);
24144 if (PyErr_Occurred()) SWIG_fail;
24145 }
24146 {
24147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24148 }
24149 return resultobj;
24150 fail:
24151 return NULL;
24152 }
24153
24154
24155 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24156 PyObject *resultobj = 0;
24157 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24158 bool result;
24159 void *argp1 = 0 ;
24160 int res1 = 0 ;
24161 PyObject *swig_obj[1] ;
24162
24163 if (!args) SWIG_fail;
24164 swig_obj[0] = args;
24165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24166 if (!SWIG_IsOK(res1)) {
24167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24168 }
24169 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24170 {
24171 PyThreadState* __tstate = wxPyBeginAllowThreads();
24172 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
24173 wxPyEndAllowThreads(__tstate);
24174 if (PyErr_Occurred()) SWIG_fail;
24175 }
24176 {
24177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24178 }
24179 return resultobj;
24180 fail:
24181 return NULL;
24182 }
24183
24184
24185 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24186 PyObject *resultobj = 0;
24187 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24188 bool result;
24189 void *argp1 = 0 ;
24190 int res1 = 0 ;
24191 PyObject *swig_obj[1] ;
24192
24193 if (!args) SWIG_fail;
24194 swig_obj[0] = args;
24195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24196 if (!SWIG_IsOK(res1)) {
24197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24198 }
24199 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24200 {
24201 PyThreadState* __tstate = wxPyBeginAllowThreads();
24202 result = (bool)((wxMouseEvent const *)arg1)->Moving();
24203 wxPyEndAllowThreads(__tstate);
24204 if (PyErr_Occurred()) SWIG_fail;
24205 }
24206 {
24207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24208 }
24209 return resultobj;
24210 fail:
24211 return NULL;
24212 }
24213
24214
24215 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24216 PyObject *resultobj = 0;
24217 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24218 bool result;
24219 void *argp1 = 0 ;
24220 int res1 = 0 ;
24221 PyObject *swig_obj[1] ;
24222
24223 if (!args) SWIG_fail;
24224 swig_obj[0] = args;
24225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24226 if (!SWIG_IsOK(res1)) {
24227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24228 }
24229 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24230 {
24231 PyThreadState* __tstate = wxPyBeginAllowThreads();
24232 result = (bool)((wxMouseEvent const *)arg1)->Entering();
24233 wxPyEndAllowThreads(__tstate);
24234 if (PyErr_Occurred()) SWIG_fail;
24235 }
24236 {
24237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24238 }
24239 return resultobj;
24240 fail:
24241 return NULL;
24242 }
24243
24244
24245 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24246 PyObject *resultobj = 0;
24247 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24248 bool result;
24249 void *argp1 = 0 ;
24250 int res1 = 0 ;
24251 PyObject *swig_obj[1] ;
24252
24253 if (!args) SWIG_fail;
24254 swig_obj[0] = args;
24255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24256 if (!SWIG_IsOK(res1)) {
24257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24258 }
24259 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24260 {
24261 PyThreadState* __tstate = wxPyBeginAllowThreads();
24262 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
24263 wxPyEndAllowThreads(__tstate);
24264 if (PyErr_Occurred()) SWIG_fail;
24265 }
24266 {
24267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24268 }
24269 return resultobj;
24270 fail:
24271 return NULL;
24272 }
24273
24274
24275 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24276 PyObject *resultobj = 0;
24277 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24278 wxPoint result;
24279 void *argp1 = 0 ;
24280 int res1 = 0 ;
24281 PyObject *swig_obj[1] ;
24282
24283 if (!args) SWIG_fail;
24284 swig_obj[0] = args;
24285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24286 if (!SWIG_IsOK(res1)) {
24287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24288 }
24289 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24290 {
24291 PyThreadState* __tstate = wxPyBeginAllowThreads();
24292 result = (arg1)->GetPosition();
24293 wxPyEndAllowThreads(__tstate);
24294 if (PyErr_Occurred()) SWIG_fail;
24295 }
24296 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24297 return resultobj;
24298 fail:
24299 return NULL;
24300 }
24301
24302
24303 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24304 PyObject *resultobj = 0;
24305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24306 long *arg2 = (long *) 0 ;
24307 long *arg3 = (long *) 0 ;
24308 void *argp1 = 0 ;
24309 int res1 = 0 ;
24310 long temp2 ;
24311 int res2 = SWIG_TMPOBJ ;
24312 long temp3 ;
24313 int res3 = SWIG_TMPOBJ ;
24314 PyObject *swig_obj[1] ;
24315
24316 arg2 = &temp2;
24317 arg3 = &temp3;
24318 if (!args) SWIG_fail;
24319 swig_obj[0] = args;
24320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24321 if (!SWIG_IsOK(res1)) {
24322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24323 }
24324 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24325 {
24326 PyThreadState* __tstate = wxPyBeginAllowThreads();
24327 (arg1)->GetPosition(arg2,arg3);
24328 wxPyEndAllowThreads(__tstate);
24329 if (PyErr_Occurred()) SWIG_fail;
24330 }
24331 resultobj = SWIG_Py_Void();
24332 if (SWIG_IsTmpObj(res2)) {
24333 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
24334 } else {
24335 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
24336 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
24337 }
24338 if (SWIG_IsTmpObj(res3)) {
24339 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
24340 } else {
24341 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
24342 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
24343 }
24344 return resultobj;
24345 fail:
24346 return NULL;
24347 }
24348
24349
24350 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24351 PyObject *resultobj = 0;
24352 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24353 wxDC *arg2 = 0 ;
24354 wxPoint result;
24355 void *argp1 = 0 ;
24356 int res1 = 0 ;
24357 void *argp2 = 0 ;
24358 int res2 = 0 ;
24359 PyObject * obj0 = 0 ;
24360 PyObject * obj1 = 0 ;
24361 char * kwnames[] = {
24362 (char *) "self",(char *) "dc", NULL
24363 };
24364
24365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
24366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24367 if (!SWIG_IsOK(res1)) {
24368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24369 }
24370 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24371 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
24372 if (!SWIG_IsOK(res2)) {
24373 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
24374 }
24375 if (!argp2) {
24376 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
24377 }
24378 arg2 = reinterpret_cast< wxDC * >(argp2);
24379 {
24380 PyThreadState* __tstate = wxPyBeginAllowThreads();
24381 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
24382 wxPyEndAllowThreads(__tstate);
24383 if (PyErr_Occurred()) SWIG_fail;
24384 }
24385 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24386 return resultobj;
24387 fail:
24388 return NULL;
24389 }
24390
24391
24392 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24393 PyObject *resultobj = 0;
24394 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24395 int result;
24396 void *argp1 = 0 ;
24397 int res1 = 0 ;
24398 PyObject *swig_obj[1] ;
24399
24400 if (!args) SWIG_fail;
24401 swig_obj[0] = args;
24402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24403 if (!SWIG_IsOK(res1)) {
24404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24405 }
24406 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24407 {
24408 PyThreadState* __tstate = wxPyBeginAllowThreads();
24409 result = (int)((wxMouseEvent const *)arg1)->GetX();
24410 wxPyEndAllowThreads(__tstate);
24411 if (PyErr_Occurred()) SWIG_fail;
24412 }
24413 resultobj = SWIG_From_int(static_cast< int >(result));
24414 return resultobj;
24415 fail:
24416 return NULL;
24417 }
24418
24419
24420 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24421 PyObject *resultobj = 0;
24422 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24423 int result;
24424 void *argp1 = 0 ;
24425 int res1 = 0 ;
24426 PyObject *swig_obj[1] ;
24427
24428 if (!args) SWIG_fail;
24429 swig_obj[0] = args;
24430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24431 if (!SWIG_IsOK(res1)) {
24432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24433 }
24434 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24435 {
24436 PyThreadState* __tstate = wxPyBeginAllowThreads();
24437 result = (int)((wxMouseEvent const *)arg1)->GetY();
24438 wxPyEndAllowThreads(__tstate);
24439 if (PyErr_Occurred()) SWIG_fail;
24440 }
24441 resultobj = SWIG_From_int(static_cast< int >(result));
24442 return resultobj;
24443 fail:
24444 return NULL;
24445 }
24446
24447
24448 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24449 PyObject *resultobj = 0;
24450 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24451 int result;
24452 void *argp1 = 0 ;
24453 int res1 = 0 ;
24454 PyObject *swig_obj[1] ;
24455
24456 if (!args) SWIG_fail;
24457 swig_obj[0] = args;
24458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24459 if (!SWIG_IsOK(res1)) {
24460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24461 }
24462 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24463 {
24464 PyThreadState* __tstate = wxPyBeginAllowThreads();
24465 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
24466 wxPyEndAllowThreads(__tstate);
24467 if (PyErr_Occurred()) SWIG_fail;
24468 }
24469 resultobj = SWIG_From_int(static_cast< int >(result));
24470 return resultobj;
24471 fail:
24472 return NULL;
24473 }
24474
24475
24476 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24477 PyObject *resultobj = 0;
24478 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24479 int result;
24480 void *argp1 = 0 ;
24481 int res1 = 0 ;
24482 PyObject *swig_obj[1] ;
24483
24484 if (!args) SWIG_fail;
24485 swig_obj[0] = args;
24486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24487 if (!SWIG_IsOK(res1)) {
24488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24489 }
24490 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24491 {
24492 PyThreadState* __tstate = wxPyBeginAllowThreads();
24493 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
24494 wxPyEndAllowThreads(__tstate);
24495 if (PyErr_Occurred()) SWIG_fail;
24496 }
24497 resultobj = SWIG_From_int(static_cast< int >(result));
24498 return resultobj;
24499 fail:
24500 return NULL;
24501 }
24502
24503
24504 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelAxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24505 PyObject *resultobj = 0;
24506 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24507 int result;
24508 void *argp1 = 0 ;
24509 int res1 = 0 ;
24510 PyObject *swig_obj[1] ;
24511
24512 if (!args) SWIG_fail;
24513 swig_obj[0] = args;
24514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24515 if (!SWIG_IsOK(res1)) {
24516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelAxis" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24517 }
24518 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24519 {
24520 PyThreadState* __tstate = wxPyBeginAllowThreads();
24521 result = (int)((wxMouseEvent const *)arg1)->GetWheelAxis();
24522 wxPyEndAllowThreads(__tstate);
24523 if (PyErr_Occurred()) SWIG_fail;
24524 }
24525 resultobj = SWIG_From_int(static_cast< int >(result));
24526 return resultobj;
24527 fail:
24528 return NULL;
24529 }
24530
24531
24532 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24533 PyObject *resultobj = 0;
24534 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24535 int result;
24536 void *argp1 = 0 ;
24537 int res1 = 0 ;
24538 PyObject *swig_obj[1] ;
24539
24540 if (!args) SWIG_fail;
24541 swig_obj[0] = args;
24542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24543 if (!SWIG_IsOK(res1)) {
24544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24545 }
24546 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24547 {
24548 PyThreadState* __tstate = wxPyBeginAllowThreads();
24549 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
24550 wxPyEndAllowThreads(__tstate);
24551 if (PyErr_Occurred()) SWIG_fail;
24552 }
24553 resultobj = SWIG_From_int(static_cast< int >(result));
24554 return resultobj;
24555 fail:
24556 return NULL;
24557 }
24558
24559
24560 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24561 PyObject *resultobj = 0;
24562 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24563 bool result;
24564 void *argp1 = 0 ;
24565 int res1 = 0 ;
24566 PyObject *swig_obj[1] ;
24567
24568 if (!args) SWIG_fail;
24569 swig_obj[0] = args;
24570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24571 if (!SWIG_IsOK(res1)) {
24572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24573 }
24574 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24575 {
24576 PyThreadState* __tstate = wxPyBeginAllowThreads();
24577 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
24578 wxPyEndAllowThreads(__tstate);
24579 if (PyErr_Occurred()) SWIG_fail;
24580 }
24581 {
24582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24583 }
24584 return resultobj;
24585 fail:
24586 return NULL;
24587 }
24588
24589
24590 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24591 PyObject *resultobj = 0;
24592 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24593 int arg2 ;
24594 void *argp1 = 0 ;
24595 int res1 = 0 ;
24596 int val2 ;
24597 int ecode2 = 0 ;
24598 PyObject *swig_obj[2] ;
24599
24600 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
24601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24602 if (!SWIG_IsOK(res1)) {
24603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24604 }
24605 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24606 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24607 if (!SWIG_IsOK(ecode2)) {
24608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
24609 }
24610 arg2 = static_cast< int >(val2);
24611 if (arg1) (arg1)->m_x = arg2;
24612
24613 resultobj = SWIG_Py_Void();
24614 return resultobj;
24615 fail:
24616 return NULL;
24617 }
24618
24619
24620 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24621 PyObject *resultobj = 0;
24622 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24623 int result;
24624 void *argp1 = 0 ;
24625 int res1 = 0 ;
24626 PyObject *swig_obj[1] ;
24627
24628 if (!args) SWIG_fail;
24629 swig_obj[0] = args;
24630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24631 if (!SWIG_IsOK(res1)) {
24632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24633 }
24634 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24635 result = (int) ((arg1)->m_x);
24636 resultobj = SWIG_From_int(static_cast< int >(result));
24637 return resultobj;
24638 fail:
24639 return NULL;
24640 }
24641
24642
24643 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24644 PyObject *resultobj = 0;
24645 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24646 int arg2 ;
24647 void *argp1 = 0 ;
24648 int res1 = 0 ;
24649 int val2 ;
24650 int ecode2 = 0 ;
24651 PyObject *swig_obj[2] ;
24652
24653 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24655 if (!SWIG_IsOK(res1)) {
24656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24657 }
24658 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24659 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24660 if (!SWIG_IsOK(ecode2)) {
24661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24662 }
24663 arg2 = static_cast< int >(val2);
24664 if (arg1) (arg1)->m_y = arg2;
24665
24666 resultobj = SWIG_Py_Void();
24667 return resultobj;
24668 fail:
24669 return NULL;
24670 }
24671
24672
24673 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24674 PyObject *resultobj = 0;
24675 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24676 int result;
24677 void *argp1 = 0 ;
24678 int res1 = 0 ;
24679 PyObject *swig_obj[1] ;
24680
24681 if (!args) SWIG_fail;
24682 swig_obj[0] = args;
24683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24684 if (!SWIG_IsOK(res1)) {
24685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24686 }
24687 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24688 result = (int) ((arg1)->m_y);
24689 resultobj = SWIG_From_int(static_cast< int >(result));
24690 return resultobj;
24691 fail:
24692 return NULL;
24693 }
24694
24695
24696 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24697 PyObject *resultobj = 0;
24698 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24699 bool arg2 ;
24700 void *argp1 = 0 ;
24701 int res1 = 0 ;
24702 bool val2 ;
24703 int ecode2 = 0 ;
24704 PyObject *swig_obj[2] ;
24705
24706 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24708 if (!SWIG_IsOK(res1)) {
24709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24710 }
24711 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24712 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24713 if (!SWIG_IsOK(ecode2)) {
24714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24715 }
24716 arg2 = static_cast< bool >(val2);
24717 if (arg1) (arg1)->m_leftDown = arg2;
24718
24719 resultobj = SWIG_Py_Void();
24720 return resultobj;
24721 fail:
24722 return NULL;
24723 }
24724
24725
24726 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24727 PyObject *resultobj = 0;
24728 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24729 bool result;
24730 void *argp1 = 0 ;
24731 int res1 = 0 ;
24732 PyObject *swig_obj[1] ;
24733
24734 if (!args) SWIG_fail;
24735 swig_obj[0] = args;
24736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24737 if (!SWIG_IsOK(res1)) {
24738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24739 }
24740 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24741 result = (bool) ((arg1)->m_leftDown);
24742 {
24743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24744 }
24745 return resultobj;
24746 fail:
24747 return NULL;
24748 }
24749
24750
24751 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24752 PyObject *resultobj = 0;
24753 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24754 bool arg2 ;
24755 void *argp1 = 0 ;
24756 int res1 = 0 ;
24757 bool val2 ;
24758 int ecode2 = 0 ;
24759 PyObject *swig_obj[2] ;
24760
24761 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24763 if (!SWIG_IsOK(res1)) {
24764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24765 }
24766 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24767 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24768 if (!SWIG_IsOK(ecode2)) {
24769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24770 }
24771 arg2 = static_cast< bool >(val2);
24772 if (arg1) (arg1)->m_middleDown = arg2;
24773
24774 resultobj = SWIG_Py_Void();
24775 return resultobj;
24776 fail:
24777 return NULL;
24778 }
24779
24780
24781 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24782 PyObject *resultobj = 0;
24783 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24784 bool result;
24785 void *argp1 = 0 ;
24786 int res1 = 0 ;
24787 PyObject *swig_obj[1] ;
24788
24789 if (!args) SWIG_fail;
24790 swig_obj[0] = args;
24791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24792 if (!SWIG_IsOK(res1)) {
24793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24794 }
24795 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24796 result = (bool) ((arg1)->m_middleDown);
24797 {
24798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24799 }
24800 return resultobj;
24801 fail:
24802 return NULL;
24803 }
24804
24805
24806 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24807 PyObject *resultobj = 0;
24808 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24809 bool arg2 ;
24810 void *argp1 = 0 ;
24811 int res1 = 0 ;
24812 bool val2 ;
24813 int ecode2 = 0 ;
24814 PyObject *swig_obj[2] ;
24815
24816 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24818 if (!SWIG_IsOK(res1)) {
24819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24820 }
24821 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24822 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24823 if (!SWIG_IsOK(ecode2)) {
24824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24825 }
24826 arg2 = static_cast< bool >(val2);
24827 if (arg1) (arg1)->m_rightDown = arg2;
24828
24829 resultobj = SWIG_Py_Void();
24830 return resultobj;
24831 fail:
24832 return NULL;
24833 }
24834
24835
24836 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24837 PyObject *resultobj = 0;
24838 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24839 bool 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_wxMouseEvent, 0 | 0 );
24847 if (!SWIG_IsOK(res1)) {
24848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24849 }
24850 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24851 result = (bool) ((arg1)->m_rightDown);
24852 {
24853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24854 }
24855 return resultobj;
24856 fail:
24857 return NULL;
24858 }
24859
24860
24861 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24862 PyObject *resultobj = 0;
24863 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24864 bool arg2 ;
24865 void *argp1 = 0 ;
24866 int res1 = 0 ;
24867 bool val2 ;
24868 int ecode2 = 0 ;
24869 PyObject *swig_obj[2] ;
24870
24871 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24873 if (!SWIG_IsOK(res1)) {
24874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24875 }
24876 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24877 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24878 if (!SWIG_IsOK(ecode2)) {
24879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24880 }
24881 arg2 = static_cast< bool >(val2);
24882 if (arg1) (arg1)->m_controlDown = arg2;
24883
24884 resultobj = SWIG_Py_Void();
24885 return resultobj;
24886 fail:
24887 return NULL;
24888 }
24889
24890
24891 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24892 PyObject *resultobj = 0;
24893 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24894 bool result;
24895 void *argp1 = 0 ;
24896 int res1 = 0 ;
24897 PyObject *swig_obj[1] ;
24898
24899 if (!args) SWIG_fail;
24900 swig_obj[0] = args;
24901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24902 if (!SWIG_IsOK(res1)) {
24903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24904 }
24905 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24906 result = (bool) ((arg1)->m_controlDown);
24907 {
24908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24909 }
24910 return resultobj;
24911 fail:
24912 return NULL;
24913 }
24914
24915
24916 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24917 PyObject *resultobj = 0;
24918 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24919 bool arg2 ;
24920 void *argp1 = 0 ;
24921 int res1 = 0 ;
24922 bool val2 ;
24923 int ecode2 = 0 ;
24924 PyObject *swig_obj[2] ;
24925
24926 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24928 if (!SWIG_IsOK(res1)) {
24929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24930 }
24931 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24932 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24933 if (!SWIG_IsOK(ecode2)) {
24934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24935 }
24936 arg2 = static_cast< bool >(val2);
24937 if (arg1) (arg1)->m_shiftDown = arg2;
24938
24939 resultobj = SWIG_Py_Void();
24940 return resultobj;
24941 fail:
24942 return NULL;
24943 }
24944
24945
24946 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24947 PyObject *resultobj = 0;
24948 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24949 bool result;
24950 void *argp1 = 0 ;
24951 int res1 = 0 ;
24952 PyObject *swig_obj[1] ;
24953
24954 if (!args) SWIG_fail;
24955 swig_obj[0] = args;
24956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24957 if (!SWIG_IsOK(res1)) {
24958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24959 }
24960 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24961 result = (bool) ((arg1)->m_shiftDown);
24962 {
24963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24964 }
24965 return resultobj;
24966 fail:
24967 return NULL;
24968 }
24969
24970
24971 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24972 PyObject *resultobj = 0;
24973 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24974 bool arg2 ;
24975 void *argp1 = 0 ;
24976 int res1 = 0 ;
24977 bool val2 ;
24978 int ecode2 = 0 ;
24979 PyObject *swig_obj[2] ;
24980
24981 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24983 if (!SWIG_IsOK(res1)) {
24984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24985 }
24986 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24987 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24988 if (!SWIG_IsOK(ecode2)) {
24989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24990 }
24991 arg2 = static_cast< bool >(val2);
24992 if (arg1) (arg1)->m_altDown = arg2;
24993
24994 resultobj = SWIG_Py_Void();
24995 return resultobj;
24996 fail:
24997 return NULL;
24998 }
24999
25000
25001 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25002 PyObject *resultobj = 0;
25003 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25004 bool result;
25005 void *argp1 = 0 ;
25006 int res1 = 0 ;
25007 PyObject *swig_obj[1] ;
25008
25009 if (!args) SWIG_fail;
25010 swig_obj[0] = args;
25011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25012 if (!SWIG_IsOK(res1)) {
25013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25014 }
25015 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25016 result = (bool) ((arg1)->m_altDown);
25017 {
25018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25019 }
25020 return resultobj;
25021 fail:
25022 return NULL;
25023 }
25024
25025
25026 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25027 PyObject *resultobj = 0;
25028 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25029 bool arg2 ;
25030 void *argp1 = 0 ;
25031 int res1 = 0 ;
25032 bool val2 ;
25033 int ecode2 = 0 ;
25034 PyObject *swig_obj[2] ;
25035
25036 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25038 if (!SWIG_IsOK(res1)) {
25039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25040 }
25041 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25042 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25043 if (!SWIG_IsOK(ecode2)) {
25044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25045 }
25046 arg2 = static_cast< bool >(val2);
25047 if (arg1) (arg1)->m_metaDown = arg2;
25048
25049 resultobj = SWIG_Py_Void();
25050 return resultobj;
25051 fail:
25052 return NULL;
25053 }
25054
25055
25056 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25057 PyObject *resultobj = 0;
25058 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25059 bool result;
25060 void *argp1 = 0 ;
25061 int res1 = 0 ;
25062 PyObject *swig_obj[1] ;
25063
25064 if (!args) SWIG_fail;
25065 swig_obj[0] = args;
25066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25067 if (!SWIG_IsOK(res1)) {
25068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25069 }
25070 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25071 result = (bool) ((arg1)->m_metaDown);
25072 {
25073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25074 }
25075 return resultobj;
25076 fail:
25077 return NULL;
25078 }
25079
25080
25081 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25082 PyObject *resultobj = 0;
25083 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25084 int arg2 ;
25085 void *argp1 = 0 ;
25086 int res1 = 0 ;
25087 int val2 ;
25088 int ecode2 = 0 ;
25089 PyObject *swig_obj[2] ;
25090
25091 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
25092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25093 if (!SWIG_IsOK(res1)) {
25094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25095 }
25096 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25097 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25098 if (!SWIG_IsOK(ecode2)) {
25099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
25100 }
25101 arg2 = static_cast< int >(val2);
25102 if (arg1) (arg1)->m_wheelRotation = arg2;
25103
25104 resultobj = SWIG_Py_Void();
25105 return resultobj;
25106 fail:
25107 return NULL;
25108 }
25109
25110
25111 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25112 PyObject *resultobj = 0;
25113 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25114 int result;
25115 void *argp1 = 0 ;
25116 int res1 = 0 ;
25117 PyObject *swig_obj[1] ;
25118
25119 if (!args) SWIG_fail;
25120 swig_obj[0] = args;
25121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25122 if (!SWIG_IsOK(res1)) {
25123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25124 }
25125 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25126 result = (int) ((arg1)->m_wheelRotation);
25127 resultobj = SWIG_From_int(static_cast< int >(result));
25128 return resultobj;
25129 fail:
25130 return NULL;
25131 }
25132
25133
25134 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25135 PyObject *resultobj = 0;
25136 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25137 int arg2 ;
25138 void *argp1 = 0 ;
25139 int res1 = 0 ;
25140 int val2 ;
25141 int ecode2 = 0 ;
25142 PyObject *swig_obj[2] ;
25143
25144 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
25145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25146 if (!SWIG_IsOK(res1)) {
25147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25148 }
25149 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25150 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25151 if (!SWIG_IsOK(ecode2)) {
25152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
25153 }
25154 arg2 = static_cast< int >(val2);
25155 if (arg1) (arg1)->m_wheelDelta = arg2;
25156
25157 resultobj = SWIG_Py_Void();
25158 return resultobj;
25159 fail:
25160 return NULL;
25161 }
25162
25163
25164 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25165 PyObject *resultobj = 0;
25166 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25167 int result;
25168 void *argp1 = 0 ;
25169 int res1 = 0 ;
25170 PyObject *swig_obj[1] ;
25171
25172 if (!args) SWIG_fail;
25173 swig_obj[0] = args;
25174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25175 if (!SWIG_IsOK(res1)) {
25176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25177 }
25178 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25179 result = (int) ((arg1)->m_wheelDelta);
25180 resultobj = SWIG_From_int(static_cast< int >(result));
25181 return resultobj;
25182 fail:
25183 return NULL;
25184 }
25185
25186
25187 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25188 PyObject *resultobj = 0;
25189 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25190 int arg2 ;
25191 void *argp1 = 0 ;
25192 int res1 = 0 ;
25193 int val2 ;
25194 int ecode2 = 0 ;
25195 PyObject *swig_obj[2] ;
25196
25197 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
25198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25199 if (!SWIG_IsOK(res1)) {
25200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25201 }
25202 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25203 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25204 if (!SWIG_IsOK(ecode2)) {
25205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
25206 }
25207 arg2 = static_cast< int >(val2);
25208 if (arg1) (arg1)->m_linesPerAction = arg2;
25209
25210 resultobj = SWIG_Py_Void();
25211 return resultobj;
25212 fail:
25213 return NULL;
25214 }
25215
25216
25217 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25218 PyObject *resultobj = 0;
25219 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25220 int result;
25221 void *argp1 = 0 ;
25222 int res1 = 0 ;
25223 PyObject *swig_obj[1] ;
25224
25225 if (!args) SWIG_fail;
25226 swig_obj[0] = args;
25227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25228 if (!SWIG_IsOK(res1)) {
25229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25230 }
25231 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25232 result = (int) ((arg1)->m_linesPerAction);
25233 resultobj = SWIG_From_int(static_cast< int >(result));
25234 return resultobj;
25235 fail:
25236 return NULL;
25237 }
25238
25239
25240 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25241 PyObject *obj;
25242 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25243 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
25244 return SWIG_Py_Void();
25245 }
25246
25247 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25248 return SWIG_Python_InitShadowInstance(args);
25249 }
25250
25251 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25252 PyObject *resultobj = 0;
25253 int arg1 = (int) 0 ;
25254 int arg2 = (int) 0 ;
25255 wxSetCursorEvent *result = 0 ;
25256 int val1 ;
25257 int ecode1 = 0 ;
25258 int val2 ;
25259 int ecode2 = 0 ;
25260 PyObject * obj0 = 0 ;
25261 PyObject * obj1 = 0 ;
25262 char * kwnames[] = {
25263 (char *) "x",(char *) "y", NULL
25264 };
25265
25266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25267 if (obj0) {
25268 ecode1 = SWIG_AsVal_int(obj0, &val1);
25269 if (!SWIG_IsOK(ecode1)) {
25270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
25271 }
25272 arg1 = static_cast< int >(val1);
25273 }
25274 if (obj1) {
25275 ecode2 = SWIG_AsVal_int(obj1, &val2);
25276 if (!SWIG_IsOK(ecode2)) {
25277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
25278 }
25279 arg2 = static_cast< int >(val2);
25280 }
25281 {
25282 PyThreadState* __tstate = wxPyBeginAllowThreads();
25283 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
25284 wxPyEndAllowThreads(__tstate);
25285 if (PyErr_Occurred()) SWIG_fail;
25286 }
25287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
25288 return resultobj;
25289 fail:
25290 return NULL;
25291 }
25292
25293
25294 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25295 PyObject *resultobj = 0;
25296 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25297 int result;
25298 void *argp1 = 0 ;
25299 int res1 = 0 ;
25300 PyObject *swig_obj[1] ;
25301
25302 if (!args) SWIG_fail;
25303 swig_obj[0] = args;
25304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25305 if (!SWIG_IsOK(res1)) {
25306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25307 }
25308 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25309 {
25310 PyThreadState* __tstate = wxPyBeginAllowThreads();
25311 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
25312 wxPyEndAllowThreads(__tstate);
25313 if (PyErr_Occurred()) SWIG_fail;
25314 }
25315 resultobj = SWIG_From_int(static_cast< int >(result));
25316 return resultobj;
25317 fail:
25318 return NULL;
25319 }
25320
25321
25322 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25323 PyObject *resultobj = 0;
25324 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25325 int result;
25326 void *argp1 = 0 ;
25327 int res1 = 0 ;
25328 PyObject *swig_obj[1] ;
25329
25330 if (!args) SWIG_fail;
25331 swig_obj[0] = args;
25332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25333 if (!SWIG_IsOK(res1)) {
25334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25335 }
25336 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25337 {
25338 PyThreadState* __tstate = wxPyBeginAllowThreads();
25339 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
25340 wxPyEndAllowThreads(__tstate);
25341 if (PyErr_Occurred()) SWIG_fail;
25342 }
25343 resultobj = SWIG_From_int(static_cast< int >(result));
25344 return resultobj;
25345 fail:
25346 return NULL;
25347 }
25348
25349
25350 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25351 PyObject *resultobj = 0;
25352 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25353 wxCursor *arg2 = 0 ;
25354 void *argp1 = 0 ;
25355 int res1 = 0 ;
25356 void *argp2 = 0 ;
25357 int res2 = 0 ;
25358 PyObject * obj0 = 0 ;
25359 PyObject * obj1 = 0 ;
25360 char * kwnames[] = {
25361 (char *) "self",(char *) "cursor", NULL
25362 };
25363
25364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
25365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25366 if (!SWIG_IsOK(res1)) {
25367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
25368 }
25369 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25370 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
25371 if (!SWIG_IsOK(res2)) {
25372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
25373 }
25374 if (!argp2) {
25375 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
25376 }
25377 arg2 = reinterpret_cast< wxCursor * >(argp2);
25378 {
25379 PyThreadState* __tstate = wxPyBeginAllowThreads();
25380 (arg1)->SetCursor((wxCursor const &)*arg2);
25381 wxPyEndAllowThreads(__tstate);
25382 if (PyErr_Occurred()) SWIG_fail;
25383 }
25384 resultobj = SWIG_Py_Void();
25385 return resultobj;
25386 fail:
25387 return NULL;
25388 }
25389
25390
25391 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25392 PyObject *resultobj = 0;
25393 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25394 wxCursor *result = 0 ;
25395 void *argp1 = 0 ;
25396 int res1 = 0 ;
25397 PyObject *swig_obj[1] ;
25398
25399 if (!args) SWIG_fail;
25400 swig_obj[0] = args;
25401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25402 if (!SWIG_IsOK(res1)) {
25403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25404 }
25405 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25406 {
25407 PyThreadState* __tstate = wxPyBeginAllowThreads();
25408 {
25409 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
25410 result = (wxCursor *) &_result_ref;
25411 }
25412 wxPyEndAllowThreads(__tstate);
25413 if (PyErr_Occurred()) SWIG_fail;
25414 }
25415 {
25416 wxCursor* resultptr = new wxCursor(*result);
25417 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
25418 }
25419 return resultobj;
25420 fail:
25421 return NULL;
25422 }
25423
25424
25425 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25426 PyObject *resultobj = 0;
25427 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25428 bool result;
25429 void *argp1 = 0 ;
25430 int res1 = 0 ;
25431 PyObject *swig_obj[1] ;
25432
25433 if (!args) SWIG_fail;
25434 swig_obj[0] = args;
25435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25436 if (!SWIG_IsOK(res1)) {
25437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25438 }
25439 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25440 {
25441 PyThreadState* __tstate = wxPyBeginAllowThreads();
25442 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
25443 wxPyEndAllowThreads(__tstate);
25444 if (PyErr_Occurred()) SWIG_fail;
25445 }
25446 {
25447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25448 }
25449 return resultobj;
25450 fail:
25451 return NULL;
25452 }
25453
25454
25455 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25456 PyObject *obj;
25457 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25458 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
25459 return SWIG_Py_Void();
25460 }
25461
25462 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25463 return SWIG_Python_InitShadowInstance(args);
25464 }
25465
25466 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25467 PyObject *resultobj = 0;
25468 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
25469 wxKeyEvent *result = 0 ;
25470 int val1 ;
25471 int ecode1 = 0 ;
25472 PyObject * obj0 = 0 ;
25473 char * kwnames[] = {
25474 (char *) "eventType", NULL
25475 };
25476
25477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
25478 if (obj0) {
25479 ecode1 = SWIG_AsVal_int(obj0, &val1);
25480 if (!SWIG_IsOK(ecode1)) {
25481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
25482 }
25483 arg1 = static_cast< wxEventType >(val1);
25484 }
25485 {
25486 PyThreadState* __tstate = wxPyBeginAllowThreads();
25487 result = (wxKeyEvent *)new wxKeyEvent(arg1);
25488 wxPyEndAllowThreads(__tstate);
25489 if (PyErr_Occurred()) SWIG_fail;
25490 }
25491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
25492 return resultobj;
25493 fail:
25494 return NULL;
25495 }
25496
25497
25498 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25499 PyObject *resultobj = 0;
25500 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25501 int result;
25502 void *argp1 = 0 ;
25503 int res1 = 0 ;
25504 PyObject *swig_obj[1] ;
25505
25506 if (!args) SWIG_fail;
25507 swig_obj[0] = args;
25508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25509 if (!SWIG_IsOK(res1)) {
25510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25511 }
25512 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25513 {
25514 PyThreadState* __tstate = wxPyBeginAllowThreads();
25515 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
25516 wxPyEndAllowThreads(__tstate);
25517 if (PyErr_Occurred()) SWIG_fail;
25518 }
25519 resultobj = SWIG_From_int(static_cast< int >(result));
25520 return resultobj;
25521 fail:
25522 return NULL;
25523 }
25524
25525
25526 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25527 PyObject *resultobj = 0;
25528 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25529 bool result;
25530 void *argp1 = 0 ;
25531 int res1 = 0 ;
25532 PyObject *swig_obj[1] ;
25533
25534 if (!args) SWIG_fail;
25535 swig_obj[0] = args;
25536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25537 if (!SWIG_IsOK(res1)) {
25538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25539 }
25540 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25541 {
25542 PyThreadState* __tstate = wxPyBeginAllowThreads();
25543 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
25544 wxPyEndAllowThreads(__tstate);
25545 if (PyErr_Occurred()) SWIG_fail;
25546 }
25547 {
25548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25549 }
25550 return resultobj;
25551 fail:
25552 return NULL;
25553 }
25554
25555
25556 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25557 PyObject *resultobj = 0;
25558 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25559 bool result;
25560 void *argp1 = 0 ;
25561 int res1 = 0 ;
25562 PyObject *swig_obj[1] ;
25563
25564 if (!args) SWIG_fail;
25565 swig_obj[0] = args;
25566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25567 if (!SWIG_IsOK(res1)) {
25568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25569 }
25570 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25571 {
25572 PyThreadState* __tstate = wxPyBeginAllowThreads();
25573 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
25574 wxPyEndAllowThreads(__tstate);
25575 if (PyErr_Occurred()) SWIG_fail;
25576 }
25577 {
25578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25579 }
25580 return resultobj;
25581 fail:
25582 return NULL;
25583 }
25584
25585
25586 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25587 PyObject *resultobj = 0;
25588 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25589 bool result;
25590 void *argp1 = 0 ;
25591 int res1 = 0 ;
25592 PyObject *swig_obj[1] ;
25593
25594 if (!args) SWIG_fail;
25595 swig_obj[0] = args;
25596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25597 if (!SWIG_IsOK(res1)) {
25598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25599 }
25600 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25601 {
25602 PyThreadState* __tstate = wxPyBeginAllowThreads();
25603 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
25604 wxPyEndAllowThreads(__tstate);
25605 if (PyErr_Occurred()) SWIG_fail;
25606 }
25607 {
25608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25609 }
25610 return resultobj;
25611 fail:
25612 return NULL;
25613 }
25614
25615
25616 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25617 PyObject *resultobj = 0;
25618 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25619 bool result;
25620 void *argp1 = 0 ;
25621 int res1 = 0 ;
25622 PyObject *swig_obj[1] ;
25623
25624 if (!args) SWIG_fail;
25625 swig_obj[0] = args;
25626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25627 if (!SWIG_IsOK(res1)) {
25628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25629 }
25630 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25631 {
25632 PyThreadState* __tstate = wxPyBeginAllowThreads();
25633 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25634 wxPyEndAllowThreads(__tstate);
25635 if (PyErr_Occurred()) SWIG_fail;
25636 }
25637 {
25638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25639 }
25640 return resultobj;
25641 fail:
25642 return NULL;
25643 }
25644
25645
25646 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25647 PyObject *resultobj = 0;
25648 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25649 bool result;
25650 void *argp1 = 0 ;
25651 int res1 = 0 ;
25652 PyObject *swig_obj[1] ;
25653
25654 if (!args) SWIG_fail;
25655 swig_obj[0] = args;
25656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25657 if (!SWIG_IsOK(res1)) {
25658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25659 }
25660 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25661 {
25662 PyThreadState* __tstate = wxPyBeginAllowThreads();
25663 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25664 wxPyEndAllowThreads(__tstate);
25665 if (PyErr_Occurred()) SWIG_fail;
25666 }
25667 {
25668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25669 }
25670 return resultobj;
25671 fail:
25672 return NULL;
25673 }
25674
25675
25676 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25677 PyObject *resultobj = 0;
25678 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25679 bool result;
25680 void *argp1 = 0 ;
25681 int res1 = 0 ;
25682 PyObject *swig_obj[1] ;
25683
25684 if (!args) SWIG_fail;
25685 swig_obj[0] = args;
25686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25687 if (!SWIG_IsOK(res1)) {
25688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25689 }
25690 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25691 {
25692 PyThreadState* __tstate = wxPyBeginAllowThreads();
25693 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25694 wxPyEndAllowThreads(__tstate);
25695 if (PyErr_Occurred()) SWIG_fail;
25696 }
25697 {
25698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25699 }
25700 return resultobj;
25701 fail:
25702 return NULL;
25703 }
25704
25705
25706 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25707 PyObject *resultobj = 0;
25708 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25709 int result;
25710 void *argp1 = 0 ;
25711 int res1 = 0 ;
25712 PyObject *swig_obj[1] ;
25713
25714 if (!args) SWIG_fail;
25715 swig_obj[0] = args;
25716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25717 if (!SWIG_IsOK(res1)) {
25718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25719 }
25720 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25721 {
25722 PyThreadState* __tstate = wxPyBeginAllowThreads();
25723 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25724 wxPyEndAllowThreads(__tstate);
25725 if (PyErr_Occurred()) SWIG_fail;
25726 }
25727 resultobj = SWIG_From_int(static_cast< int >(result));
25728 return resultobj;
25729 fail:
25730 return NULL;
25731 }
25732
25733
25734 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25735 PyObject *resultobj = 0;
25736 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25737 int result;
25738 void *argp1 = 0 ;
25739 int res1 = 0 ;
25740 PyObject *swig_obj[1] ;
25741
25742 if (!args) SWIG_fail;
25743 swig_obj[0] = args;
25744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25745 if (!SWIG_IsOK(res1)) {
25746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25747 }
25748 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25749 {
25750 PyThreadState* __tstate = wxPyBeginAllowThreads();
25751 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25752 wxPyEndAllowThreads(__tstate);
25753 if (PyErr_Occurred()) SWIG_fail;
25754 }
25755 resultobj = SWIG_From_int(static_cast< int >(result));
25756 return resultobj;
25757 fail:
25758 return NULL;
25759 }
25760
25761
25762 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25763 PyObject *resultobj = 0;
25764 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25765 int arg2 ;
25766 void *argp1 = 0 ;
25767 int res1 = 0 ;
25768 int val2 ;
25769 int ecode2 = 0 ;
25770 PyObject * obj0 = 0 ;
25771 PyObject * obj1 = 0 ;
25772 char * kwnames[] = {
25773 (char *) "self",(char *) "uniChar", NULL
25774 };
25775
25776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25778 if (!SWIG_IsOK(res1)) {
25779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25780 }
25781 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25782 ecode2 = SWIG_AsVal_int(obj1, &val2);
25783 if (!SWIG_IsOK(ecode2)) {
25784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25785 }
25786 arg2 = static_cast< int >(val2);
25787 {
25788 PyThreadState* __tstate = wxPyBeginAllowThreads();
25789 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25790 wxPyEndAllowThreads(__tstate);
25791 if (PyErr_Occurred()) SWIG_fail;
25792 }
25793 resultobj = SWIG_Py_Void();
25794 return resultobj;
25795 fail:
25796 return NULL;
25797 }
25798
25799
25800 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25801 PyObject *resultobj = 0;
25802 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25803 unsigned int result;
25804 void *argp1 = 0 ;
25805 int res1 = 0 ;
25806 PyObject *swig_obj[1] ;
25807
25808 if (!args) SWIG_fail;
25809 swig_obj[0] = args;
25810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25811 if (!SWIG_IsOK(res1)) {
25812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25813 }
25814 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25815 {
25816 PyThreadState* __tstate = wxPyBeginAllowThreads();
25817 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25818 wxPyEndAllowThreads(__tstate);
25819 if (PyErr_Occurred()) SWIG_fail;
25820 }
25821 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25822 return resultobj;
25823 fail:
25824 return NULL;
25825 }
25826
25827
25828 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25829 PyObject *resultobj = 0;
25830 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25831 unsigned int result;
25832 void *argp1 = 0 ;
25833 int res1 = 0 ;
25834 PyObject *swig_obj[1] ;
25835
25836 if (!args) SWIG_fail;
25837 swig_obj[0] = args;
25838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25839 if (!SWIG_IsOK(res1)) {
25840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25841 }
25842 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25843 {
25844 PyThreadState* __tstate = wxPyBeginAllowThreads();
25845 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25846 wxPyEndAllowThreads(__tstate);
25847 if (PyErr_Occurred()) SWIG_fail;
25848 }
25849 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25850 return resultobj;
25851 fail:
25852 return NULL;
25853 }
25854
25855
25856 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25857 PyObject *resultobj = 0;
25858 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25859 wxPoint result;
25860 void *argp1 = 0 ;
25861 int res1 = 0 ;
25862 PyObject *swig_obj[1] ;
25863
25864 if (!args) SWIG_fail;
25865 swig_obj[0] = args;
25866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25867 if (!SWIG_IsOK(res1)) {
25868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25869 }
25870 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25871 {
25872 PyThreadState* __tstate = wxPyBeginAllowThreads();
25873 result = (arg1)->GetPosition();
25874 wxPyEndAllowThreads(__tstate);
25875 if (PyErr_Occurred()) SWIG_fail;
25876 }
25877 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25878 return resultobj;
25879 fail:
25880 return NULL;
25881 }
25882
25883
25884 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25885 PyObject *resultobj = 0;
25886 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25887 long *arg2 = (long *) 0 ;
25888 long *arg3 = (long *) 0 ;
25889 void *argp1 = 0 ;
25890 int res1 = 0 ;
25891 long temp2 ;
25892 int res2 = SWIG_TMPOBJ ;
25893 long temp3 ;
25894 int res3 = SWIG_TMPOBJ ;
25895 PyObject *swig_obj[1] ;
25896
25897 arg2 = &temp2;
25898 arg3 = &temp3;
25899 if (!args) SWIG_fail;
25900 swig_obj[0] = args;
25901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25902 if (!SWIG_IsOK(res1)) {
25903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25904 }
25905 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25906 {
25907 PyThreadState* __tstate = wxPyBeginAllowThreads();
25908 (arg1)->GetPosition(arg2,arg3);
25909 wxPyEndAllowThreads(__tstate);
25910 if (PyErr_Occurred()) SWIG_fail;
25911 }
25912 resultobj = SWIG_Py_Void();
25913 if (SWIG_IsTmpObj(res2)) {
25914 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25915 } else {
25916 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25917 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25918 }
25919 if (SWIG_IsTmpObj(res3)) {
25920 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25921 } else {
25922 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25923 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25924 }
25925 return resultobj;
25926 fail:
25927 return NULL;
25928 }
25929
25930
25931 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25932 PyObject *resultobj = 0;
25933 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25934 int result;
25935 void *argp1 = 0 ;
25936 int res1 = 0 ;
25937 PyObject *swig_obj[1] ;
25938
25939 if (!args) SWIG_fail;
25940 swig_obj[0] = args;
25941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25942 if (!SWIG_IsOK(res1)) {
25943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25944 }
25945 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25946 {
25947 PyThreadState* __tstate = wxPyBeginAllowThreads();
25948 result = (int)((wxKeyEvent const *)arg1)->GetX();
25949 wxPyEndAllowThreads(__tstate);
25950 if (PyErr_Occurred()) SWIG_fail;
25951 }
25952 resultobj = SWIG_From_int(static_cast< int >(result));
25953 return resultobj;
25954 fail:
25955 return NULL;
25956 }
25957
25958
25959 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25960 PyObject *resultobj = 0;
25961 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25962 int result;
25963 void *argp1 = 0 ;
25964 int res1 = 0 ;
25965 PyObject *swig_obj[1] ;
25966
25967 if (!args) SWIG_fail;
25968 swig_obj[0] = args;
25969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25970 if (!SWIG_IsOK(res1)) {
25971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25972 }
25973 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25974 {
25975 PyThreadState* __tstate = wxPyBeginAllowThreads();
25976 result = (int)((wxKeyEvent const *)arg1)->GetY();
25977 wxPyEndAllowThreads(__tstate);
25978 if (PyErr_Occurred()) SWIG_fail;
25979 }
25980 resultobj = SWIG_From_int(static_cast< int >(result));
25981 return resultobj;
25982 fail:
25983 return NULL;
25984 }
25985
25986
25987 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25988 PyObject *resultobj = 0;
25989 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25990 int arg2 ;
25991 void *argp1 = 0 ;
25992 int res1 = 0 ;
25993 int val2 ;
25994 int ecode2 = 0 ;
25995 PyObject *swig_obj[2] ;
25996
25997 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25999 if (!SWIG_IsOK(res1)) {
26000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26001 }
26002 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26003 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
26004 if (!SWIG_IsOK(ecode2)) {
26005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
26006 }
26007 arg2 = static_cast< int >(val2);
26008 if (arg1) (arg1)->m_x = arg2;
26009
26010 resultobj = SWIG_Py_Void();
26011 return resultobj;
26012 fail:
26013 return NULL;
26014 }
26015
26016
26017 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26018 PyObject *resultobj = 0;
26019 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26020 int result;
26021 void *argp1 = 0 ;
26022 int res1 = 0 ;
26023 PyObject *swig_obj[1] ;
26024
26025 if (!args) SWIG_fail;
26026 swig_obj[0] = args;
26027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26028 if (!SWIG_IsOK(res1)) {
26029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26030 }
26031 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26032 result = (int) ((arg1)->m_x);
26033 resultobj = SWIG_From_int(static_cast< int >(result));
26034 return resultobj;
26035 fail:
26036 return NULL;
26037 }
26038
26039
26040 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26041 PyObject *resultobj = 0;
26042 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26043 int arg2 ;
26044 void *argp1 = 0 ;
26045 int res1 = 0 ;
26046 int val2 ;
26047 int ecode2 = 0 ;
26048 PyObject *swig_obj[2] ;
26049
26050 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
26051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26052 if (!SWIG_IsOK(res1)) {
26053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26054 }
26055 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26056 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
26057 if (!SWIG_IsOK(ecode2)) {
26058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
26059 }
26060 arg2 = static_cast< int >(val2);
26061 if (arg1) (arg1)->m_y = arg2;
26062
26063 resultobj = SWIG_Py_Void();
26064 return resultobj;
26065 fail:
26066 return NULL;
26067 }
26068
26069
26070 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26071 PyObject *resultobj = 0;
26072 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26073 int result;
26074 void *argp1 = 0 ;
26075 int res1 = 0 ;
26076 PyObject *swig_obj[1] ;
26077
26078 if (!args) SWIG_fail;
26079 swig_obj[0] = args;
26080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26081 if (!SWIG_IsOK(res1)) {
26082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26083 }
26084 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26085 result = (int) ((arg1)->m_y);
26086 resultobj = SWIG_From_int(static_cast< int >(result));
26087 return resultobj;
26088 fail:
26089 return NULL;
26090 }
26091
26092
26093 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26094 PyObject *resultobj = 0;
26095 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26096 long arg2 ;
26097 void *argp1 = 0 ;
26098 int res1 = 0 ;
26099 long val2 ;
26100 int ecode2 = 0 ;
26101 PyObject *swig_obj[2] ;
26102
26103 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
26104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26105 if (!SWIG_IsOK(res1)) {
26106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26107 }
26108 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26109 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
26110 if (!SWIG_IsOK(ecode2)) {
26111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
26112 }
26113 arg2 = static_cast< long >(val2);
26114 if (arg1) (arg1)->m_keyCode = arg2;
26115
26116 resultobj = SWIG_Py_Void();
26117 return resultobj;
26118 fail:
26119 return NULL;
26120 }
26121
26122
26123 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26124 PyObject *resultobj = 0;
26125 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26126 long result;
26127 void *argp1 = 0 ;
26128 int res1 = 0 ;
26129 PyObject *swig_obj[1] ;
26130
26131 if (!args) SWIG_fail;
26132 swig_obj[0] = args;
26133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26134 if (!SWIG_IsOK(res1)) {
26135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26136 }
26137 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26138 result = (long) ((arg1)->m_keyCode);
26139 resultobj = SWIG_From_long(static_cast< long >(result));
26140 return resultobj;
26141 fail:
26142 return NULL;
26143 }
26144
26145
26146 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26147 PyObject *resultobj = 0;
26148 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26149 bool arg2 ;
26150 void *argp1 = 0 ;
26151 int res1 = 0 ;
26152 bool val2 ;
26153 int ecode2 = 0 ;
26154 PyObject *swig_obj[2] ;
26155
26156 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
26157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26158 if (!SWIG_IsOK(res1)) {
26159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26160 }
26161 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26162 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26163 if (!SWIG_IsOK(ecode2)) {
26164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
26165 }
26166 arg2 = static_cast< bool >(val2);
26167 if (arg1) (arg1)->m_controlDown = arg2;
26168
26169 resultobj = SWIG_Py_Void();
26170 return resultobj;
26171 fail:
26172 return NULL;
26173 }
26174
26175
26176 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26177 PyObject *resultobj = 0;
26178 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26179 bool result;
26180 void *argp1 = 0 ;
26181 int res1 = 0 ;
26182 PyObject *swig_obj[1] ;
26183
26184 if (!args) SWIG_fail;
26185 swig_obj[0] = args;
26186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26187 if (!SWIG_IsOK(res1)) {
26188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26189 }
26190 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26191 result = (bool) ((arg1)->m_controlDown);
26192 {
26193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26194 }
26195 return resultobj;
26196 fail:
26197 return NULL;
26198 }
26199
26200
26201 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26202 PyObject *resultobj = 0;
26203 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26204 bool arg2 ;
26205 void *argp1 = 0 ;
26206 int res1 = 0 ;
26207 bool val2 ;
26208 int ecode2 = 0 ;
26209 PyObject *swig_obj[2] ;
26210
26211 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
26212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26213 if (!SWIG_IsOK(res1)) {
26214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26215 }
26216 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26217 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26218 if (!SWIG_IsOK(ecode2)) {
26219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
26220 }
26221 arg2 = static_cast< bool >(val2);
26222 if (arg1) (arg1)->m_shiftDown = arg2;
26223
26224 resultobj = SWIG_Py_Void();
26225 return resultobj;
26226 fail:
26227 return NULL;
26228 }
26229
26230
26231 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26232 PyObject *resultobj = 0;
26233 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26234 bool result;
26235 void *argp1 = 0 ;
26236 int res1 = 0 ;
26237 PyObject *swig_obj[1] ;
26238
26239 if (!args) SWIG_fail;
26240 swig_obj[0] = args;
26241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26242 if (!SWIG_IsOK(res1)) {
26243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26244 }
26245 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26246 result = (bool) ((arg1)->m_shiftDown);
26247 {
26248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26249 }
26250 return resultobj;
26251 fail:
26252 return NULL;
26253 }
26254
26255
26256 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26257 PyObject *resultobj = 0;
26258 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26259 bool arg2 ;
26260 void *argp1 = 0 ;
26261 int res1 = 0 ;
26262 bool val2 ;
26263 int ecode2 = 0 ;
26264 PyObject *swig_obj[2] ;
26265
26266 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
26267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26268 if (!SWIG_IsOK(res1)) {
26269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26270 }
26271 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26272 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26273 if (!SWIG_IsOK(ecode2)) {
26274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
26275 }
26276 arg2 = static_cast< bool >(val2);
26277 if (arg1) (arg1)->m_altDown = arg2;
26278
26279 resultobj = SWIG_Py_Void();
26280 return resultobj;
26281 fail:
26282 return NULL;
26283 }
26284
26285
26286 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26287 PyObject *resultobj = 0;
26288 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26289 bool result;
26290 void *argp1 = 0 ;
26291 int res1 = 0 ;
26292 PyObject *swig_obj[1] ;
26293
26294 if (!args) SWIG_fail;
26295 swig_obj[0] = args;
26296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26297 if (!SWIG_IsOK(res1)) {
26298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26299 }
26300 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26301 result = (bool) ((arg1)->m_altDown);
26302 {
26303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26304 }
26305 return resultobj;
26306 fail:
26307 return NULL;
26308 }
26309
26310
26311 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26312 PyObject *resultobj = 0;
26313 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26314 bool arg2 ;
26315 void *argp1 = 0 ;
26316 int res1 = 0 ;
26317 bool val2 ;
26318 int ecode2 = 0 ;
26319 PyObject *swig_obj[2] ;
26320
26321 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
26322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26323 if (!SWIG_IsOK(res1)) {
26324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26325 }
26326 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26327 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26328 if (!SWIG_IsOK(ecode2)) {
26329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
26330 }
26331 arg2 = static_cast< bool >(val2);
26332 if (arg1) (arg1)->m_metaDown = arg2;
26333
26334 resultobj = SWIG_Py_Void();
26335 return resultobj;
26336 fail:
26337 return NULL;
26338 }
26339
26340
26341 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26342 PyObject *resultobj = 0;
26343 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26344 bool result;
26345 void *argp1 = 0 ;
26346 int res1 = 0 ;
26347 PyObject *swig_obj[1] ;
26348
26349 if (!args) SWIG_fail;
26350 swig_obj[0] = args;
26351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26352 if (!SWIG_IsOK(res1)) {
26353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26354 }
26355 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26356 result = (bool) ((arg1)->m_metaDown);
26357 {
26358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26359 }
26360 return resultobj;
26361 fail:
26362 return NULL;
26363 }
26364
26365
26366 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26367 PyObject *resultobj = 0;
26368 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26369 bool arg2 ;
26370 void *argp1 = 0 ;
26371 int res1 = 0 ;
26372 bool val2 ;
26373 int ecode2 = 0 ;
26374 PyObject *swig_obj[2] ;
26375
26376 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
26377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26378 if (!SWIG_IsOK(res1)) {
26379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26380 }
26381 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26382 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26383 if (!SWIG_IsOK(ecode2)) {
26384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
26385 }
26386 arg2 = static_cast< bool >(val2);
26387 if (arg1) (arg1)->m_scanCode = arg2;
26388
26389 resultobj = SWIG_Py_Void();
26390 return resultobj;
26391 fail:
26392 return NULL;
26393 }
26394
26395
26396 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26397 PyObject *resultobj = 0;
26398 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26399 bool result;
26400 void *argp1 = 0 ;
26401 int res1 = 0 ;
26402 PyObject *swig_obj[1] ;
26403
26404 if (!args) SWIG_fail;
26405 swig_obj[0] = args;
26406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26407 if (!SWIG_IsOK(res1)) {
26408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26409 }
26410 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26411 result = (bool) ((arg1)->m_scanCode);
26412 {
26413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26414 }
26415 return resultobj;
26416 fail:
26417 return NULL;
26418 }
26419
26420
26421 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26422 PyObject *resultobj = 0;
26423 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26424 unsigned int arg2 ;
26425 void *argp1 = 0 ;
26426 int res1 = 0 ;
26427 unsigned int val2 ;
26428 int ecode2 = 0 ;
26429 PyObject *swig_obj[2] ;
26430
26431 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
26432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26433 if (!SWIG_IsOK(res1)) {
26434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26435 }
26436 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26437 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
26438 if (!SWIG_IsOK(ecode2)) {
26439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
26440 }
26441 arg2 = static_cast< unsigned int >(val2);
26442 if (arg1) (arg1)->m_rawCode = arg2;
26443
26444 resultobj = SWIG_Py_Void();
26445 return resultobj;
26446 fail:
26447 return NULL;
26448 }
26449
26450
26451 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26452 PyObject *resultobj = 0;
26453 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26454 unsigned int result;
26455 void *argp1 = 0 ;
26456 int res1 = 0 ;
26457 PyObject *swig_obj[1] ;
26458
26459 if (!args) SWIG_fail;
26460 swig_obj[0] = args;
26461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26462 if (!SWIG_IsOK(res1)) {
26463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26464 }
26465 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26466 result = (unsigned int) ((arg1)->m_rawCode);
26467 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26468 return resultobj;
26469 fail:
26470 return NULL;
26471 }
26472
26473
26474 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26475 PyObject *resultobj = 0;
26476 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26477 unsigned int arg2 ;
26478 void *argp1 = 0 ;
26479 int res1 = 0 ;
26480 unsigned int val2 ;
26481 int ecode2 = 0 ;
26482 PyObject *swig_obj[2] ;
26483
26484 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
26485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26486 if (!SWIG_IsOK(res1)) {
26487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26488 }
26489 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26490 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
26491 if (!SWIG_IsOK(ecode2)) {
26492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
26493 }
26494 arg2 = static_cast< unsigned int >(val2);
26495 if (arg1) (arg1)->m_rawFlags = arg2;
26496
26497 resultobj = SWIG_Py_Void();
26498 return resultobj;
26499 fail:
26500 return NULL;
26501 }
26502
26503
26504 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26505 PyObject *resultobj = 0;
26506 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26507 unsigned int result;
26508 void *argp1 = 0 ;
26509 int res1 = 0 ;
26510 PyObject *swig_obj[1] ;
26511
26512 if (!args) SWIG_fail;
26513 swig_obj[0] = args;
26514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26515 if (!SWIG_IsOK(res1)) {
26516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26517 }
26518 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26519 result = (unsigned int) ((arg1)->m_rawFlags);
26520 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26521 return resultobj;
26522 fail:
26523 return NULL;
26524 }
26525
26526
26527 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26528 PyObject *obj;
26529 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26530 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
26531 return SWIG_Py_Void();
26532 }
26533
26534 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26535 return SWIG_Python_InitShadowInstance(args);
26536 }
26537
26538 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26539 PyObject *resultobj = 0;
26540 wxSize const &arg1_defvalue = wxDefaultSize ;
26541 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
26542 int arg2 = (int) 0 ;
26543 wxSizeEvent *result = 0 ;
26544 wxSize temp1 ;
26545 int val2 ;
26546 int ecode2 = 0 ;
26547 PyObject * obj0 = 0 ;
26548 PyObject * obj1 = 0 ;
26549 char * kwnames[] = {
26550 (char *) "sz",(char *) "winid", NULL
26551 };
26552
26553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26554 if (obj0) {
26555 {
26556 arg1 = &temp1;
26557 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
26558 }
26559 }
26560 if (obj1) {
26561 ecode2 = SWIG_AsVal_int(obj1, &val2);
26562 if (!SWIG_IsOK(ecode2)) {
26563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
26564 }
26565 arg2 = static_cast< int >(val2);
26566 }
26567 {
26568 PyThreadState* __tstate = wxPyBeginAllowThreads();
26569 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
26570 wxPyEndAllowThreads(__tstate);
26571 if (PyErr_Occurred()) SWIG_fail;
26572 }
26573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
26574 return resultobj;
26575 fail:
26576 return NULL;
26577 }
26578
26579
26580 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26581 PyObject *resultobj = 0;
26582 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26583 wxSize result;
26584 void *argp1 = 0 ;
26585 int res1 = 0 ;
26586 PyObject *swig_obj[1] ;
26587
26588 if (!args) SWIG_fail;
26589 swig_obj[0] = args;
26590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26591 if (!SWIG_IsOK(res1)) {
26592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26593 }
26594 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26595 {
26596 PyThreadState* __tstate = wxPyBeginAllowThreads();
26597 result = ((wxSizeEvent const *)arg1)->GetSize();
26598 wxPyEndAllowThreads(__tstate);
26599 if (PyErr_Occurred()) SWIG_fail;
26600 }
26601 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
26602 return resultobj;
26603 fail:
26604 return NULL;
26605 }
26606
26607
26608 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26609 PyObject *resultobj = 0;
26610 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26611 wxRect result;
26612 void *argp1 = 0 ;
26613 int res1 = 0 ;
26614 PyObject *swig_obj[1] ;
26615
26616 if (!args) SWIG_fail;
26617 swig_obj[0] = args;
26618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26619 if (!SWIG_IsOK(res1)) {
26620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26621 }
26622 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26623 {
26624 PyThreadState* __tstate = wxPyBeginAllowThreads();
26625 result = ((wxSizeEvent const *)arg1)->GetRect();
26626 wxPyEndAllowThreads(__tstate);
26627 if (PyErr_Occurred()) SWIG_fail;
26628 }
26629 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26630 return resultobj;
26631 fail:
26632 return NULL;
26633 }
26634
26635
26636 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26637 PyObject *resultobj = 0;
26638 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26639 wxRect arg2 ;
26640 void *argp1 = 0 ;
26641 int res1 = 0 ;
26642 void *argp2 ;
26643 int res2 = 0 ;
26644 PyObject * obj0 = 0 ;
26645 PyObject * obj1 = 0 ;
26646 char * kwnames[] = {
26647 (char *) "self",(char *) "rect", NULL
26648 };
26649
26650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26652 if (!SWIG_IsOK(res1)) {
26653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26654 }
26655 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26656 {
26657 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26658 if (!SWIG_IsOK(res2)) {
26659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26660 }
26661 if (!argp2) {
26662 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26663 } else {
26664 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26665 arg2 = *temp;
26666 if (SWIG_IsNewObj(res2)) delete temp;
26667 }
26668 }
26669 {
26670 PyThreadState* __tstate = wxPyBeginAllowThreads();
26671 (arg1)->SetRect(arg2);
26672 wxPyEndAllowThreads(__tstate);
26673 if (PyErr_Occurred()) SWIG_fail;
26674 }
26675 resultobj = SWIG_Py_Void();
26676 return resultobj;
26677 fail:
26678 return NULL;
26679 }
26680
26681
26682 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26683 PyObject *resultobj = 0;
26684 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26685 wxSize arg2 ;
26686 void *argp1 = 0 ;
26687 int res1 = 0 ;
26688 void *argp2 ;
26689 int res2 = 0 ;
26690 PyObject * obj0 = 0 ;
26691 PyObject * obj1 = 0 ;
26692 char * kwnames[] = {
26693 (char *) "self",(char *) "size", NULL
26694 };
26695
26696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26698 if (!SWIG_IsOK(res1)) {
26699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26700 }
26701 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26702 {
26703 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26704 if (!SWIG_IsOK(res2)) {
26705 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26706 }
26707 if (!argp2) {
26708 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26709 } else {
26710 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26711 arg2 = *temp;
26712 if (SWIG_IsNewObj(res2)) delete temp;
26713 }
26714 }
26715 {
26716 PyThreadState* __tstate = wxPyBeginAllowThreads();
26717 wxSizeEvent_SetSize(arg1,arg2);
26718 wxPyEndAllowThreads(__tstate);
26719 if (PyErr_Occurred()) SWIG_fail;
26720 }
26721 resultobj = SWIG_Py_Void();
26722 return resultobj;
26723 fail:
26724 return NULL;
26725 }
26726
26727
26728 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26729 PyObject *resultobj = 0;
26730 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26731 wxSize *arg2 = (wxSize *) 0 ;
26732 void *argp1 = 0 ;
26733 int res1 = 0 ;
26734 void *argp2 = 0 ;
26735 int res2 = 0 ;
26736 PyObject *swig_obj[2] ;
26737
26738 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26740 if (!SWIG_IsOK(res1)) {
26741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26742 }
26743 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26744 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26745 if (!SWIG_IsOK(res2)) {
26746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26747 }
26748 arg2 = reinterpret_cast< wxSize * >(argp2);
26749 if (arg1) (arg1)->m_size = *arg2;
26750
26751 resultobj = SWIG_Py_Void();
26752 return resultobj;
26753 fail:
26754 return NULL;
26755 }
26756
26757
26758 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26759 PyObject *resultobj = 0;
26760 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26761 wxSize *result = 0 ;
26762 void *argp1 = 0 ;
26763 int res1 = 0 ;
26764 PyObject *swig_obj[1] ;
26765
26766 if (!args) SWIG_fail;
26767 swig_obj[0] = args;
26768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26769 if (!SWIG_IsOK(res1)) {
26770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26771 }
26772 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26773 result = (wxSize *)& ((arg1)->m_size);
26774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26775 return resultobj;
26776 fail:
26777 return NULL;
26778 }
26779
26780
26781 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26782 PyObject *resultobj = 0;
26783 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26784 wxRect *arg2 = (wxRect *) 0 ;
26785 void *argp1 = 0 ;
26786 int res1 = 0 ;
26787 void *argp2 = 0 ;
26788 int res2 = 0 ;
26789 PyObject *swig_obj[2] ;
26790
26791 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26793 if (!SWIG_IsOK(res1)) {
26794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26795 }
26796 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26797 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26798 if (!SWIG_IsOK(res2)) {
26799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26800 }
26801 arg2 = reinterpret_cast< wxRect * >(argp2);
26802 if (arg1) (arg1)->m_rect = *arg2;
26803
26804 resultobj = SWIG_Py_Void();
26805 return resultobj;
26806 fail:
26807 return NULL;
26808 }
26809
26810
26811 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26812 PyObject *resultobj = 0;
26813 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26814 wxRect *result = 0 ;
26815 void *argp1 = 0 ;
26816 int res1 = 0 ;
26817 PyObject *swig_obj[1] ;
26818
26819 if (!args) SWIG_fail;
26820 swig_obj[0] = args;
26821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26822 if (!SWIG_IsOK(res1)) {
26823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26824 }
26825 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26826 result = (wxRect *)& ((arg1)->m_rect);
26827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26828 return resultobj;
26829 fail:
26830 return NULL;
26831 }
26832
26833
26834 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26835 PyObject *obj;
26836 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26837 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26838 return SWIG_Py_Void();
26839 }
26840
26841 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26842 return SWIG_Python_InitShadowInstance(args);
26843 }
26844
26845 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26846 PyObject *resultobj = 0;
26847 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26848 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26849 int arg2 = (int) 0 ;
26850 wxMoveEvent *result = 0 ;
26851 wxPoint temp1 ;
26852 int val2 ;
26853 int ecode2 = 0 ;
26854 PyObject * obj0 = 0 ;
26855 PyObject * obj1 = 0 ;
26856 char * kwnames[] = {
26857 (char *) "pos",(char *) "winid", NULL
26858 };
26859
26860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26861 if (obj0) {
26862 {
26863 arg1 = &temp1;
26864 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26865 }
26866 }
26867 if (obj1) {
26868 ecode2 = SWIG_AsVal_int(obj1, &val2);
26869 if (!SWIG_IsOK(ecode2)) {
26870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26871 }
26872 arg2 = static_cast< int >(val2);
26873 }
26874 {
26875 PyThreadState* __tstate = wxPyBeginAllowThreads();
26876 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26877 wxPyEndAllowThreads(__tstate);
26878 if (PyErr_Occurred()) SWIG_fail;
26879 }
26880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26881 return resultobj;
26882 fail:
26883 return NULL;
26884 }
26885
26886
26887 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26888 PyObject *resultobj = 0;
26889 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26890 wxPoint result;
26891 void *argp1 = 0 ;
26892 int res1 = 0 ;
26893 PyObject *swig_obj[1] ;
26894
26895 if (!args) SWIG_fail;
26896 swig_obj[0] = args;
26897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26898 if (!SWIG_IsOK(res1)) {
26899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26900 }
26901 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26902 {
26903 PyThreadState* __tstate = wxPyBeginAllowThreads();
26904 result = ((wxMoveEvent const *)arg1)->GetPosition();
26905 wxPyEndAllowThreads(__tstate);
26906 if (PyErr_Occurred()) SWIG_fail;
26907 }
26908 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26909 return resultobj;
26910 fail:
26911 return NULL;
26912 }
26913
26914
26915 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26916 PyObject *resultobj = 0;
26917 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26918 wxRect result;
26919 void *argp1 = 0 ;
26920 int res1 = 0 ;
26921 PyObject *swig_obj[1] ;
26922
26923 if (!args) SWIG_fail;
26924 swig_obj[0] = args;
26925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26926 if (!SWIG_IsOK(res1)) {
26927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26928 }
26929 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26930 {
26931 PyThreadState* __tstate = wxPyBeginAllowThreads();
26932 result = ((wxMoveEvent const *)arg1)->GetRect();
26933 wxPyEndAllowThreads(__tstate);
26934 if (PyErr_Occurred()) SWIG_fail;
26935 }
26936 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26937 return resultobj;
26938 fail:
26939 return NULL;
26940 }
26941
26942
26943 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26944 PyObject *resultobj = 0;
26945 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26946 wxRect *arg2 = 0 ;
26947 void *argp1 = 0 ;
26948 int res1 = 0 ;
26949 wxRect temp2 ;
26950 PyObject * obj0 = 0 ;
26951 PyObject * obj1 = 0 ;
26952 char * kwnames[] = {
26953 (char *) "self",(char *) "rect", NULL
26954 };
26955
26956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26958 if (!SWIG_IsOK(res1)) {
26959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26960 }
26961 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26962 {
26963 arg2 = &temp2;
26964 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26965 }
26966 {
26967 PyThreadState* __tstate = wxPyBeginAllowThreads();
26968 (arg1)->SetRect((wxRect const &)*arg2);
26969 wxPyEndAllowThreads(__tstate);
26970 if (PyErr_Occurred()) SWIG_fail;
26971 }
26972 resultobj = SWIG_Py_Void();
26973 return resultobj;
26974 fail:
26975 return NULL;
26976 }
26977
26978
26979 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26980 PyObject *resultobj = 0;
26981 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26982 wxPoint *arg2 = 0 ;
26983 void *argp1 = 0 ;
26984 int res1 = 0 ;
26985 wxPoint temp2 ;
26986 PyObject * obj0 = 0 ;
26987 PyObject * obj1 = 0 ;
26988 char * kwnames[] = {
26989 (char *) "self",(char *) "pos", NULL
26990 };
26991
26992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26994 if (!SWIG_IsOK(res1)) {
26995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26996 }
26997 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26998 {
26999 arg2 = &temp2;
27000 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
27001 }
27002 {
27003 PyThreadState* __tstate = wxPyBeginAllowThreads();
27004 (arg1)->SetPosition((wxPoint const &)*arg2);
27005 wxPyEndAllowThreads(__tstate);
27006 if (PyErr_Occurred()) SWIG_fail;
27007 }
27008 resultobj = SWIG_Py_Void();
27009 return resultobj;
27010 fail:
27011 return NULL;
27012 }
27013
27014
27015 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27016 PyObject *obj;
27017 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27018 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
27019 return SWIG_Py_Void();
27020 }
27021
27022 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27023 return SWIG_Python_InitShadowInstance(args);
27024 }
27025
27026 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27027 PyObject *resultobj = 0;
27028 int arg1 = (int) 0 ;
27029 wxPaintEvent *result = 0 ;
27030 int val1 ;
27031 int ecode1 = 0 ;
27032 PyObject * obj0 = 0 ;
27033 char * kwnames[] = {
27034 (char *) "Id", NULL
27035 };
27036
27037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
27038 if (obj0) {
27039 ecode1 = SWIG_AsVal_int(obj0, &val1);
27040 if (!SWIG_IsOK(ecode1)) {
27041 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
27042 }
27043 arg1 = static_cast< int >(val1);
27044 }
27045 {
27046 PyThreadState* __tstate = wxPyBeginAllowThreads();
27047 result = (wxPaintEvent *)new wxPaintEvent(arg1);
27048 wxPyEndAllowThreads(__tstate);
27049 if (PyErr_Occurred()) SWIG_fail;
27050 }
27051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
27052 return resultobj;
27053 fail:
27054 return NULL;
27055 }
27056
27057
27058 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27059 PyObject *obj;
27060 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27061 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
27062 return SWIG_Py_Void();
27063 }
27064
27065 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27066 return SWIG_Python_InitShadowInstance(args);
27067 }
27068
27069 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27070 PyObject *resultobj = 0;
27071 int arg1 = (int) 0 ;
27072 wxNcPaintEvent *result = 0 ;
27073 int val1 ;
27074 int ecode1 = 0 ;
27075 PyObject * obj0 = 0 ;
27076 char * kwnames[] = {
27077 (char *) "winid", NULL
27078 };
27079
27080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
27081 if (obj0) {
27082 ecode1 = SWIG_AsVal_int(obj0, &val1);
27083 if (!SWIG_IsOK(ecode1)) {
27084 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
27085 }
27086 arg1 = static_cast< int >(val1);
27087 }
27088 {
27089 PyThreadState* __tstate = wxPyBeginAllowThreads();
27090 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
27091 wxPyEndAllowThreads(__tstate);
27092 if (PyErr_Occurred()) SWIG_fail;
27093 }
27094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
27095 return resultobj;
27096 fail:
27097 return NULL;
27098 }
27099
27100
27101 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27102 PyObject *obj;
27103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27104 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
27105 return SWIG_Py_Void();
27106 }
27107
27108 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27109 return SWIG_Python_InitShadowInstance(args);
27110 }
27111
27112 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27113 PyObject *resultobj = 0;
27114 int arg1 = (int) 0 ;
27115 wxDC *arg2 = (wxDC *) NULL ;
27116 wxEraseEvent *result = 0 ;
27117 int val1 ;
27118 int ecode1 = 0 ;
27119 void *argp2 = 0 ;
27120 int res2 = 0 ;
27121 PyObject * obj0 = 0 ;
27122 PyObject * obj1 = 0 ;
27123 char * kwnames[] = {
27124 (char *) "Id",(char *) "dc", NULL
27125 };
27126
27127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27128 if (obj0) {
27129 ecode1 = SWIG_AsVal_int(obj0, &val1);
27130 if (!SWIG_IsOK(ecode1)) {
27131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
27132 }
27133 arg1 = static_cast< int >(val1);
27134 }
27135 if (obj1) {
27136 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
27137 if (!SWIG_IsOK(res2)) {
27138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
27139 }
27140 arg2 = reinterpret_cast< wxDC * >(argp2);
27141 }
27142 {
27143 PyThreadState* __tstate = wxPyBeginAllowThreads();
27144 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
27145 wxPyEndAllowThreads(__tstate);
27146 if (PyErr_Occurred()) SWIG_fail;
27147 }
27148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
27149 return resultobj;
27150 fail:
27151 return NULL;
27152 }
27153
27154
27155 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27156 PyObject *resultobj = 0;
27157 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
27158 wxDC *result = 0 ;
27159 void *argp1 = 0 ;
27160 int res1 = 0 ;
27161 PyObject *swig_obj[1] ;
27162
27163 if (!args) SWIG_fail;
27164 swig_obj[0] = args;
27165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
27166 if (!SWIG_IsOK(res1)) {
27167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
27168 }
27169 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
27170 {
27171 PyThreadState* __tstate = wxPyBeginAllowThreads();
27172 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
27173 wxPyEndAllowThreads(__tstate);
27174 if (PyErr_Occurred()) SWIG_fail;
27175 }
27176 {
27177 resultobj = wxPyMake_wxObject(result, (bool)0);
27178 }
27179 return resultobj;
27180 fail:
27181 return NULL;
27182 }
27183
27184
27185 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27186 PyObject *obj;
27187 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27188 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
27189 return SWIG_Py_Void();
27190 }
27191
27192 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27193 return SWIG_Python_InitShadowInstance(args);
27194 }
27195
27196 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27197 PyObject *resultobj = 0;
27198 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27199 int arg2 = (int) 0 ;
27200 wxFocusEvent *result = 0 ;
27201 int val1 ;
27202 int ecode1 = 0 ;
27203 int val2 ;
27204 int ecode2 = 0 ;
27205 PyObject * obj0 = 0 ;
27206 PyObject * obj1 = 0 ;
27207 char * kwnames[] = {
27208 (char *) "type",(char *) "winid", NULL
27209 };
27210
27211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27212 if (obj0) {
27213 ecode1 = SWIG_AsVal_int(obj0, &val1);
27214 if (!SWIG_IsOK(ecode1)) {
27215 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27216 }
27217 arg1 = static_cast< wxEventType >(val1);
27218 }
27219 if (obj1) {
27220 ecode2 = SWIG_AsVal_int(obj1, &val2);
27221 if (!SWIG_IsOK(ecode2)) {
27222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
27223 }
27224 arg2 = static_cast< int >(val2);
27225 }
27226 {
27227 PyThreadState* __tstate = wxPyBeginAllowThreads();
27228 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
27229 wxPyEndAllowThreads(__tstate);
27230 if (PyErr_Occurred()) SWIG_fail;
27231 }
27232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
27233 return resultobj;
27234 fail:
27235 return NULL;
27236 }
27237
27238
27239 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27240 PyObject *resultobj = 0;
27241 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
27242 wxWindow *result = 0 ;
27243 void *argp1 = 0 ;
27244 int res1 = 0 ;
27245 PyObject *swig_obj[1] ;
27246
27247 if (!args) SWIG_fail;
27248 swig_obj[0] = args;
27249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
27250 if (!SWIG_IsOK(res1)) {
27251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
27252 }
27253 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
27254 {
27255 PyThreadState* __tstate = wxPyBeginAllowThreads();
27256 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
27257 wxPyEndAllowThreads(__tstate);
27258 if (PyErr_Occurred()) SWIG_fail;
27259 }
27260 {
27261 resultobj = wxPyMake_wxObject(result, (bool)0);
27262 }
27263 return resultobj;
27264 fail:
27265 return NULL;
27266 }
27267
27268
27269 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27270 PyObject *resultobj = 0;
27271 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
27272 wxWindow *arg2 = (wxWindow *) 0 ;
27273 void *argp1 = 0 ;
27274 int res1 = 0 ;
27275 void *argp2 = 0 ;
27276 int res2 = 0 ;
27277 PyObject * obj0 = 0 ;
27278 PyObject * obj1 = 0 ;
27279 char * kwnames[] = {
27280 (char *) "self",(char *) "win", NULL
27281 };
27282
27283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
27285 if (!SWIG_IsOK(res1)) {
27286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
27287 }
27288 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
27289 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27290 if (!SWIG_IsOK(res2)) {
27291 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27292 }
27293 arg2 = reinterpret_cast< wxWindow * >(argp2);
27294 {
27295 PyThreadState* __tstate = wxPyBeginAllowThreads();
27296 (arg1)->SetWindow(arg2);
27297 wxPyEndAllowThreads(__tstate);
27298 if (PyErr_Occurred()) SWIG_fail;
27299 }
27300 resultobj = SWIG_Py_Void();
27301 return resultobj;
27302 fail:
27303 return NULL;
27304 }
27305
27306
27307 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27308 PyObject *obj;
27309 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27310 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
27311 return SWIG_Py_Void();
27312 }
27313
27314 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27315 return SWIG_Python_InitShadowInstance(args);
27316 }
27317
27318 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27319 PyObject *resultobj = 0;
27320 wxWindow *arg1 = (wxWindow *) NULL ;
27321 wxChildFocusEvent *result = 0 ;
27322 void *argp1 = 0 ;
27323 int res1 = 0 ;
27324 PyObject * obj0 = 0 ;
27325 char * kwnames[] = {
27326 (char *) "win", NULL
27327 };
27328
27329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
27330 if (obj0) {
27331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27332 if (!SWIG_IsOK(res1)) {
27333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27334 }
27335 arg1 = reinterpret_cast< wxWindow * >(argp1);
27336 }
27337 {
27338 PyThreadState* __tstate = wxPyBeginAllowThreads();
27339 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
27340 wxPyEndAllowThreads(__tstate);
27341 if (PyErr_Occurred()) SWIG_fail;
27342 }
27343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
27344 return resultobj;
27345 fail:
27346 return NULL;
27347 }
27348
27349
27350 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27351 PyObject *resultobj = 0;
27352 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
27353 wxWindow *result = 0 ;
27354 void *argp1 = 0 ;
27355 int res1 = 0 ;
27356 PyObject *swig_obj[1] ;
27357
27358 if (!args) SWIG_fail;
27359 swig_obj[0] = args;
27360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
27361 if (!SWIG_IsOK(res1)) {
27362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
27363 }
27364 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
27365 {
27366 PyThreadState* __tstate = wxPyBeginAllowThreads();
27367 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
27368 wxPyEndAllowThreads(__tstate);
27369 if (PyErr_Occurred()) SWIG_fail;
27370 }
27371 {
27372 resultobj = wxPyMake_wxObject(result, (bool)0);
27373 }
27374 return resultobj;
27375 fail:
27376 return NULL;
27377 }
27378
27379
27380 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27381 PyObject *obj;
27382 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27383 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
27384 return SWIG_Py_Void();
27385 }
27386
27387 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27388 return SWIG_Python_InitShadowInstance(args);
27389 }
27390
27391 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27392 PyObject *resultobj = 0;
27393 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27394 bool arg2 = (bool) true ;
27395 int arg3 = (int) 0 ;
27396 wxActivateEvent *result = 0 ;
27397 int val1 ;
27398 int ecode1 = 0 ;
27399 bool val2 ;
27400 int ecode2 = 0 ;
27401 int val3 ;
27402 int ecode3 = 0 ;
27403 PyObject * obj0 = 0 ;
27404 PyObject * obj1 = 0 ;
27405 PyObject * obj2 = 0 ;
27406 char * kwnames[] = {
27407 (char *) "type",(char *) "active",(char *) "Id", NULL
27408 };
27409
27410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27411 if (obj0) {
27412 ecode1 = SWIG_AsVal_int(obj0, &val1);
27413 if (!SWIG_IsOK(ecode1)) {
27414 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27415 }
27416 arg1 = static_cast< wxEventType >(val1);
27417 }
27418 if (obj1) {
27419 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27420 if (!SWIG_IsOK(ecode2)) {
27421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
27422 }
27423 arg2 = static_cast< bool >(val2);
27424 }
27425 if (obj2) {
27426 ecode3 = SWIG_AsVal_int(obj2, &val3);
27427 if (!SWIG_IsOK(ecode3)) {
27428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
27429 }
27430 arg3 = static_cast< int >(val3);
27431 }
27432 {
27433 PyThreadState* __tstate = wxPyBeginAllowThreads();
27434 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
27435 wxPyEndAllowThreads(__tstate);
27436 if (PyErr_Occurred()) SWIG_fail;
27437 }
27438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
27439 return resultobj;
27440 fail:
27441 return NULL;
27442 }
27443
27444
27445 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27446 PyObject *resultobj = 0;
27447 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
27448 bool result;
27449 void *argp1 = 0 ;
27450 int res1 = 0 ;
27451 PyObject *swig_obj[1] ;
27452
27453 if (!args) SWIG_fail;
27454 swig_obj[0] = args;
27455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
27456 if (!SWIG_IsOK(res1)) {
27457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
27458 }
27459 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
27460 {
27461 PyThreadState* __tstate = wxPyBeginAllowThreads();
27462 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
27463 wxPyEndAllowThreads(__tstate);
27464 if (PyErr_Occurred()) SWIG_fail;
27465 }
27466 {
27467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27468 }
27469 return resultobj;
27470 fail:
27471 return NULL;
27472 }
27473
27474
27475 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27476 PyObject *obj;
27477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27478 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
27479 return SWIG_Py_Void();
27480 }
27481
27482 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27483 return SWIG_Python_InitShadowInstance(args);
27484 }
27485
27486 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27487 PyObject *resultobj = 0;
27488 int arg1 = (int) 0 ;
27489 wxInitDialogEvent *result = 0 ;
27490 int val1 ;
27491 int ecode1 = 0 ;
27492 PyObject * obj0 = 0 ;
27493 char * kwnames[] = {
27494 (char *) "Id", NULL
27495 };
27496
27497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
27498 if (obj0) {
27499 ecode1 = SWIG_AsVal_int(obj0, &val1);
27500 if (!SWIG_IsOK(ecode1)) {
27501 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
27502 }
27503 arg1 = static_cast< int >(val1);
27504 }
27505 {
27506 PyThreadState* __tstate = wxPyBeginAllowThreads();
27507 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
27508 wxPyEndAllowThreads(__tstate);
27509 if (PyErr_Occurred()) SWIG_fail;
27510 }
27511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
27512 return resultobj;
27513 fail:
27514 return NULL;
27515 }
27516
27517
27518 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27519 PyObject *obj;
27520 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27521 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
27522 return SWIG_Py_Void();
27523 }
27524
27525 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27526 return SWIG_Python_InitShadowInstance(args);
27527 }
27528
27529 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27530 PyObject *resultobj = 0;
27531 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27532 int arg2 = (int) 0 ;
27533 wxMenu *arg3 = (wxMenu *) NULL ;
27534 wxMenuEvent *result = 0 ;
27535 int val1 ;
27536 int ecode1 = 0 ;
27537 int val2 ;
27538 int ecode2 = 0 ;
27539 void *argp3 = 0 ;
27540 int res3 = 0 ;
27541 PyObject * obj0 = 0 ;
27542 PyObject * obj1 = 0 ;
27543 PyObject * obj2 = 0 ;
27544 char * kwnames[] = {
27545 (char *) "type",(char *) "winid",(char *) "menu", NULL
27546 };
27547
27548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27549 if (obj0) {
27550 ecode1 = SWIG_AsVal_int(obj0, &val1);
27551 if (!SWIG_IsOK(ecode1)) {
27552 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27553 }
27554 arg1 = static_cast< wxEventType >(val1);
27555 }
27556 if (obj1) {
27557 ecode2 = SWIG_AsVal_int(obj1, &val2);
27558 if (!SWIG_IsOK(ecode2)) {
27559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
27560 }
27561 arg2 = static_cast< int >(val2);
27562 }
27563 if (obj2) {
27564 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
27565 if (!SWIG_IsOK(res3)) {
27566 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
27567 }
27568 arg3 = reinterpret_cast< wxMenu * >(argp3);
27569 }
27570 {
27571 PyThreadState* __tstate = wxPyBeginAllowThreads();
27572 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
27573 wxPyEndAllowThreads(__tstate);
27574 if (PyErr_Occurred()) SWIG_fail;
27575 }
27576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
27577 return resultobj;
27578 fail:
27579 return NULL;
27580 }
27581
27582
27583 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27584 PyObject *resultobj = 0;
27585 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27586 int result;
27587 void *argp1 = 0 ;
27588 int res1 = 0 ;
27589 PyObject *swig_obj[1] ;
27590
27591 if (!args) SWIG_fail;
27592 swig_obj[0] = args;
27593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27594 if (!SWIG_IsOK(res1)) {
27595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27596 }
27597 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27598 {
27599 PyThreadState* __tstate = wxPyBeginAllowThreads();
27600 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
27601 wxPyEndAllowThreads(__tstate);
27602 if (PyErr_Occurred()) SWIG_fail;
27603 }
27604 resultobj = SWIG_From_int(static_cast< int >(result));
27605 return resultobj;
27606 fail:
27607 return NULL;
27608 }
27609
27610
27611 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27612 PyObject *resultobj = 0;
27613 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27614 bool result;
27615 void *argp1 = 0 ;
27616 int res1 = 0 ;
27617 PyObject *swig_obj[1] ;
27618
27619 if (!args) SWIG_fail;
27620 swig_obj[0] = args;
27621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27622 if (!SWIG_IsOK(res1)) {
27623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27624 }
27625 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27626 {
27627 PyThreadState* __tstate = wxPyBeginAllowThreads();
27628 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27629 wxPyEndAllowThreads(__tstate);
27630 if (PyErr_Occurred()) SWIG_fail;
27631 }
27632 {
27633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27634 }
27635 return resultobj;
27636 fail:
27637 return NULL;
27638 }
27639
27640
27641 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27642 PyObject *resultobj = 0;
27643 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27644 wxMenu *result = 0 ;
27645 void *argp1 = 0 ;
27646 int res1 = 0 ;
27647 PyObject *swig_obj[1] ;
27648
27649 if (!args) SWIG_fail;
27650 swig_obj[0] = args;
27651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27652 if (!SWIG_IsOK(res1)) {
27653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27654 }
27655 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27656 {
27657 PyThreadState* __tstate = wxPyBeginAllowThreads();
27658 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27659 wxPyEndAllowThreads(__tstate);
27660 if (PyErr_Occurred()) SWIG_fail;
27661 }
27662 {
27663 resultobj = wxPyMake_wxObject(result, (bool)0);
27664 }
27665 return resultobj;
27666 fail:
27667 return NULL;
27668 }
27669
27670
27671 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27672 PyObject *obj;
27673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27674 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27675 return SWIG_Py_Void();
27676 }
27677
27678 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27679 return SWIG_Python_InitShadowInstance(args);
27680 }
27681
27682 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27683 PyObject *resultobj = 0;
27684 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27685 int arg2 = (int) 0 ;
27686 wxCloseEvent *result = 0 ;
27687 int val1 ;
27688 int ecode1 = 0 ;
27689 int val2 ;
27690 int ecode2 = 0 ;
27691 PyObject * obj0 = 0 ;
27692 PyObject * obj1 = 0 ;
27693 char * kwnames[] = {
27694 (char *) "type",(char *) "winid", NULL
27695 };
27696
27697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27698 if (obj0) {
27699 ecode1 = SWIG_AsVal_int(obj0, &val1);
27700 if (!SWIG_IsOK(ecode1)) {
27701 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27702 }
27703 arg1 = static_cast< wxEventType >(val1);
27704 }
27705 if (obj1) {
27706 ecode2 = SWIG_AsVal_int(obj1, &val2);
27707 if (!SWIG_IsOK(ecode2)) {
27708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27709 }
27710 arg2 = static_cast< int >(val2);
27711 }
27712 {
27713 PyThreadState* __tstate = wxPyBeginAllowThreads();
27714 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27715 wxPyEndAllowThreads(__tstate);
27716 if (PyErr_Occurred()) SWIG_fail;
27717 }
27718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27719 return resultobj;
27720 fail:
27721 return NULL;
27722 }
27723
27724
27725 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27726 PyObject *resultobj = 0;
27727 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27728 bool arg2 ;
27729 void *argp1 = 0 ;
27730 int res1 = 0 ;
27731 bool val2 ;
27732 int ecode2 = 0 ;
27733 PyObject * obj0 = 0 ;
27734 PyObject * obj1 = 0 ;
27735 char * kwnames[] = {
27736 (char *) "self",(char *) "logOff", NULL
27737 };
27738
27739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27741 if (!SWIG_IsOK(res1)) {
27742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27743 }
27744 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27745 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27746 if (!SWIG_IsOK(ecode2)) {
27747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27748 }
27749 arg2 = static_cast< bool >(val2);
27750 {
27751 PyThreadState* __tstate = wxPyBeginAllowThreads();
27752 (arg1)->SetLoggingOff(arg2);
27753 wxPyEndAllowThreads(__tstate);
27754 if (PyErr_Occurred()) SWIG_fail;
27755 }
27756 resultobj = SWIG_Py_Void();
27757 return resultobj;
27758 fail:
27759 return NULL;
27760 }
27761
27762
27763 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27764 PyObject *resultobj = 0;
27765 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27766 bool result;
27767 void *argp1 = 0 ;
27768 int res1 = 0 ;
27769 PyObject *swig_obj[1] ;
27770
27771 if (!args) SWIG_fail;
27772 swig_obj[0] = args;
27773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27774 if (!SWIG_IsOK(res1)) {
27775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27776 }
27777 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27778 {
27779 PyThreadState* __tstate = wxPyBeginAllowThreads();
27780 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27781 wxPyEndAllowThreads(__tstate);
27782 if (PyErr_Occurred()) SWIG_fail;
27783 }
27784 {
27785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27786 }
27787 return resultobj;
27788 fail:
27789 return NULL;
27790 }
27791
27792
27793 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27794 PyObject *resultobj = 0;
27795 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27796 bool arg2 = (bool) true ;
27797 void *argp1 = 0 ;
27798 int res1 = 0 ;
27799 bool val2 ;
27800 int ecode2 = 0 ;
27801 PyObject * obj0 = 0 ;
27802 PyObject * obj1 = 0 ;
27803 char * kwnames[] = {
27804 (char *) "self",(char *) "veto", NULL
27805 };
27806
27807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27809 if (!SWIG_IsOK(res1)) {
27810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27811 }
27812 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27813 if (obj1) {
27814 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27815 if (!SWIG_IsOK(ecode2)) {
27816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27817 }
27818 arg2 = static_cast< bool >(val2);
27819 }
27820 {
27821 PyThreadState* __tstate = wxPyBeginAllowThreads();
27822 (arg1)->Veto(arg2);
27823 wxPyEndAllowThreads(__tstate);
27824 if (PyErr_Occurred()) SWIG_fail;
27825 }
27826 resultobj = SWIG_Py_Void();
27827 return resultobj;
27828 fail:
27829 return NULL;
27830 }
27831
27832
27833 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27834 PyObject *resultobj = 0;
27835 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27836 bool result;
27837 void *argp1 = 0 ;
27838 int res1 = 0 ;
27839 PyObject *swig_obj[1] ;
27840
27841 if (!args) SWIG_fail;
27842 swig_obj[0] = args;
27843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27844 if (!SWIG_IsOK(res1)) {
27845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27846 }
27847 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27848 {
27849 PyThreadState* __tstate = wxPyBeginAllowThreads();
27850 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27851 wxPyEndAllowThreads(__tstate);
27852 if (PyErr_Occurred()) SWIG_fail;
27853 }
27854 {
27855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27856 }
27857 return resultobj;
27858 fail:
27859 return NULL;
27860 }
27861
27862
27863 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27864 PyObject *resultobj = 0;
27865 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27866 bool arg2 ;
27867 void *argp1 = 0 ;
27868 int res1 = 0 ;
27869 bool val2 ;
27870 int ecode2 = 0 ;
27871 PyObject * obj0 = 0 ;
27872 PyObject * obj1 = 0 ;
27873 char * kwnames[] = {
27874 (char *) "self",(char *) "canVeto", NULL
27875 };
27876
27877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27879 if (!SWIG_IsOK(res1)) {
27880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27881 }
27882 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27883 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27884 if (!SWIG_IsOK(ecode2)) {
27885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27886 }
27887 arg2 = static_cast< bool >(val2);
27888 {
27889 PyThreadState* __tstate = wxPyBeginAllowThreads();
27890 (arg1)->SetCanVeto(arg2);
27891 wxPyEndAllowThreads(__tstate);
27892 if (PyErr_Occurred()) SWIG_fail;
27893 }
27894 resultobj = SWIG_Py_Void();
27895 return resultobj;
27896 fail:
27897 return NULL;
27898 }
27899
27900
27901 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27902 PyObject *resultobj = 0;
27903 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27904 bool result;
27905 void *argp1 = 0 ;
27906 int res1 = 0 ;
27907 PyObject *swig_obj[1] ;
27908
27909 if (!args) SWIG_fail;
27910 swig_obj[0] = args;
27911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27912 if (!SWIG_IsOK(res1)) {
27913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27914 }
27915 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27916 {
27917 PyThreadState* __tstate = wxPyBeginAllowThreads();
27918 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27919 wxPyEndAllowThreads(__tstate);
27920 if (PyErr_Occurred()) SWIG_fail;
27921 }
27922 {
27923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27924 }
27925 return resultobj;
27926 fail:
27927 return NULL;
27928 }
27929
27930
27931 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27932 PyObject *obj;
27933 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27934 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27935 return SWIG_Py_Void();
27936 }
27937
27938 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27939 return SWIG_Python_InitShadowInstance(args);
27940 }
27941
27942 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27943 PyObject *resultobj = 0;
27944 int arg1 = (int) 0 ;
27945 bool arg2 = (bool) false ;
27946 wxShowEvent *result = 0 ;
27947 int val1 ;
27948 int ecode1 = 0 ;
27949 bool val2 ;
27950 int ecode2 = 0 ;
27951 PyObject * obj0 = 0 ;
27952 PyObject * obj1 = 0 ;
27953 char * kwnames[] = {
27954 (char *) "winid",(char *) "show", NULL
27955 };
27956
27957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27958 if (obj0) {
27959 ecode1 = SWIG_AsVal_int(obj0, &val1);
27960 if (!SWIG_IsOK(ecode1)) {
27961 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27962 }
27963 arg1 = static_cast< int >(val1);
27964 }
27965 if (obj1) {
27966 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27967 if (!SWIG_IsOK(ecode2)) {
27968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27969 }
27970 arg2 = static_cast< bool >(val2);
27971 }
27972 {
27973 PyThreadState* __tstate = wxPyBeginAllowThreads();
27974 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27975 wxPyEndAllowThreads(__tstate);
27976 if (PyErr_Occurred()) SWIG_fail;
27977 }
27978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27979 return resultobj;
27980 fail:
27981 return NULL;
27982 }
27983
27984
27985 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27986 PyObject *resultobj = 0;
27987 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27988 bool arg2 ;
27989 void *argp1 = 0 ;
27990 int res1 = 0 ;
27991 bool val2 ;
27992 int ecode2 = 0 ;
27993 PyObject * obj0 = 0 ;
27994 PyObject * obj1 = 0 ;
27995 char * kwnames[] = {
27996 (char *) "self",(char *) "show", NULL
27997 };
27998
27999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
28000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
28001 if (!SWIG_IsOK(res1)) {
28002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
28003 }
28004 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
28005 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28006 if (!SWIG_IsOK(ecode2)) {
28007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
28008 }
28009 arg2 = static_cast< bool >(val2);
28010 {
28011 PyThreadState* __tstate = wxPyBeginAllowThreads();
28012 (arg1)->SetShow(arg2);
28013 wxPyEndAllowThreads(__tstate);
28014 if (PyErr_Occurred()) SWIG_fail;
28015 }
28016 resultobj = SWIG_Py_Void();
28017 return resultobj;
28018 fail:
28019 return NULL;
28020 }
28021
28022
28023 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28024 PyObject *resultobj = 0;
28025 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
28026 bool result;
28027 void *argp1 = 0 ;
28028 int res1 = 0 ;
28029 PyObject *swig_obj[1] ;
28030
28031 if (!args) SWIG_fail;
28032 swig_obj[0] = args;
28033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
28034 if (!SWIG_IsOK(res1)) {
28035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
28036 }
28037 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
28038 {
28039 PyThreadState* __tstate = wxPyBeginAllowThreads();
28040 result = (bool)((wxShowEvent const *)arg1)->GetShow();
28041 wxPyEndAllowThreads(__tstate);
28042 if (PyErr_Occurred()) SWIG_fail;
28043 }
28044 {
28045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28046 }
28047 return resultobj;
28048 fail:
28049 return NULL;
28050 }
28051
28052
28053 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28054 PyObject *obj;
28055 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28056 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
28057 return SWIG_Py_Void();
28058 }
28059
28060 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28061 return SWIG_Python_InitShadowInstance(args);
28062 }
28063
28064 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28065 PyObject *resultobj = 0;
28066 int arg1 = (int) 0 ;
28067 bool arg2 = (bool) true ;
28068 wxIconizeEvent *result = 0 ;
28069 int val1 ;
28070 int ecode1 = 0 ;
28071 bool val2 ;
28072 int ecode2 = 0 ;
28073 PyObject * obj0 = 0 ;
28074 PyObject * obj1 = 0 ;
28075 char * kwnames[] = {
28076 (char *) "id",(char *) "iconized", NULL
28077 };
28078
28079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28080 if (obj0) {
28081 ecode1 = SWIG_AsVal_int(obj0, &val1);
28082 if (!SWIG_IsOK(ecode1)) {
28083 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
28084 }
28085 arg1 = static_cast< int >(val1);
28086 }
28087 if (obj1) {
28088 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28089 if (!SWIG_IsOK(ecode2)) {
28090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
28091 }
28092 arg2 = static_cast< bool >(val2);
28093 }
28094 {
28095 PyThreadState* __tstate = wxPyBeginAllowThreads();
28096 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
28097 wxPyEndAllowThreads(__tstate);
28098 if (PyErr_Occurred()) SWIG_fail;
28099 }
28100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
28101 return resultobj;
28102 fail:
28103 return NULL;
28104 }
28105
28106
28107 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28108 PyObject *resultobj = 0;
28109 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
28110 bool result;
28111 void *argp1 = 0 ;
28112 int res1 = 0 ;
28113 PyObject *swig_obj[1] ;
28114
28115 if (!args) SWIG_fail;
28116 swig_obj[0] = args;
28117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
28118 if (!SWIG_IsOK(res1)) {
28119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
28120 }
28121 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
28122 {
28123 PyThreadState* __tstate = wxPyBeginAllowThreads();
28124 result = (bool)(arg1)->Iconized();
28125 wxPyEndAllowThreads(__tstate);
28126 if (PyErr_Occurred()) SWIG_fail;
28127 }
28128 {
28129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28130 }
28131 return resultobj;
28132 fail:
28133 return NULL;
28134 }
28135
28136
28137 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28138 PyObject *obj;
28139 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28140 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
28141 return SWIG_Py_Void();
28142 }
28143
28144 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28145 return SWIG_Python_InitShadowInstance(args);
28146 }
28147
28148 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28149 PyObject *resultobj = 0;
28150 int arg1 = (int) 0 ;
28151 wxMaximizeEvent *result = 0 ;
28152 int val1 ;
28153 int ecode1 = 0 ;
28154 PyObject * obj0 = 0 ;
28155 char * kwnames[] = {
28156 (char *) "id", NULL
28157 };
28158
28159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
28160 if (obj0) {
28161 ecode1 = SWIG_AsVal_int(obj0, &val1);
28162 if (!SWIG_IsOK(ecode1)) {
28163 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
28164 }
28165 arg1 = static_cast< int >(val1);
28166 }
28167 {
28168 PyThreadState* __tstate = wxPyBeginAllowThreads();
28169 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
28170 wxPyEndAllowThreads(__tstate);
28171 if (PyErr_Occurred()) SWIG_fail;
28172 }
28173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
28174 return resultobj;
28175 fail:
28176 return NULL;
28177 }
28178
28179
28180 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28181 PyObject *obj;
28182 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28183 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
28184 return SWIG_Py_Void();
28185 }
28186
28187 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28188 return SWIG_Python_InitShadowInstance(args);
28189 }
28190
28191 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28192 PyObject *resultobj = 0;
28193 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
28194 wxPoint result;
28195 void *argp1 = 0 ;
28196 int res1 = 0 ;
28197 PyObject *swig_obj[1] ;
28198
28199 if (!args) SWIG_fail;
28200 swig_obj[0] = args;
28201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
28202 if (!SWIG_IsOK(res1)) {
28203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
28204 }
28205 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
28206 {
28207 PyThreadState* __tstate = wxPyBeginAllowThreads();
28208 result = (arg1)->GetPosition();
28209 wxPyEndAllowThreads(__tstate);
28210 if (PyErr_Occurred()) SWIG_fail;
28211 }
28212 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
28213 return resultobj;
28214 fail:
28215 return NULL;
28216 }
28217
28218
28219 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28220 PyObject *resultobj = 0;
28221 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
28222 int result;
28223 void *argp1 = 0 ;
28224 int res1 = 0 ;
28225 PyObject *swig_obj[1] ;
28226
28227 if (!args) SWIG_fail;
28228 swig_obj[0] = args;
28229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
28230 if (!SWIG_IsOK(res1)) {
28231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
28232 }
28233 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
28234 {
28235 PyThreadState* __tstate = wxPyBeginAllowThreads();
28236 result = (int)(arg1)->GetNumberOfFiles();
28237 wxPyEndAllowThreads(__tstate);
28238 if (PyErr_Occurred()) SWIG_fail;
28239 }
28240 resultobj = SWIG_From_int(static_cast< int >(result));
28241 return resultobj;
28242 fail:
28243 return NULL;
28244 }
28245
28246
28247 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28248 PyObject *resultobj = 0;
28249 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
28250 PyObject *result = 0 ;
28251 void *argp1 = 0 ;
28252 int res1 = 0 ;
28253 PyObject *swig_obj[1] ;
28254
28255 if (!args) SWIG_fail;
28256 swig_obj[0] = args;
28257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
28258 if (!SWIG_IsOK(res1)) {
28259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
28260 }
28261 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
28262 {
28263 PyThreadState* __tstate = wxPyBeginAllowThreads();
28264 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
28265 wxPyEndAllowThreads(__tstate);
28266 if (PyErr_Occurred()) SWIG_fail;
28267 }
28268 resultobj = result;
28269 return resultobj;
28270 fail:
28271 return NULL;
28272 }
28273
28274
28275 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28276 PyObject *obj;
28277 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28278 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
28279 return SWIG_Py_Void();
28280 }
28281
28282 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28283 PyObject *resultobj = 0;
28284 int arg1 = (int) 0 ;
28285 wxUpdateUIEvent *result = 0 ;
28286 int val1 ;
28287 int ecode1 = 0 ;
28288 PyObject * obj0 = 0 ;
28289 char * kwnames[] = {
28290 (char *) "commandId", NULL
28291 };
28292
28293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
28294 if (obj0) {
28295 ecode1 = SWIG_AsVal_int(obj0, &val1);
28296 if (!SWIG_IsOK(ecode1)) {
28297 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
28298 }
28299 arg1 = static_cast< int >(val1);
28300 }
28301 {
28302 PyThreadState* __tstate = wxPyBeginAllowThreads();
28303 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
28304 wxPyEndAllowThreads(__tstate);
28305 if (PyErr_Occurred()) SWIG_fail;
28306 }
28307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
28308 return resultobj;
28309 fail:
28310 return NULL;
28311 }
28312
28313
28314 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28315 PyObject *resultobj = 0;
28316 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28317 bool result;
28318 void *argp1 = 0 ;
28319 int res1 = 0 ;
28320 PyObject *swig_obj[1] ;
28321
28322 if (!args) SWIG_fail;
28323 swig_obj[0] = args;
28324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28325 if (!SWIG_IsOK(res1)) {
28326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28327 }
28328 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28329 {
28330 PyThreadState* __tstate = wxPyBeginAllowThreads();
28331 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
28332 wxPyEndAllowThreads(__tstate);
28333 if (PyErr_Occurred()) SWIG_fail;
28334 }
28335 {
28336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28337 }
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28345 PyObject *resultobj = 0;
28346 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28347 bool result;
28348 void *argp1 = 0 ;
28349 int res1 = 0 ;
28350 PyObject *swig_obj[1] ;
28351
28352 if (!args) SWIG_fail;
28353 swig_obj[0] = args;
28354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28355 if (!SWIG_IsOK(res1)) {
28356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28357 }
28358 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28359 {
28360 PyThreadState* __tstate = wxPyBeginAllowThreads();
28361 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
28362 wxPyEndAllowThreads(__tstate);
28363 if (PyErr_Occurred()) SWIG_fail;
28364 }
28365 {
28366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28367 }
28368 return resultobj;
28369 fail:
28370 return NULL;
28371 }
28372
28373
28374 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28375 PyObject *resultobj = 0;
28376 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28377 bool result;
28378 void *argp1 = 0 ;
28379 int res1 = 0 ;
28380 PyObject *swig_obj[1] ;
28381
28382 if (!args) SWIG_fail;
28383 swig_obj[0] = args;
28384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28385 if (!SWIG_IsOK(res1)) {
28386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28387 }
28388 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28389 {
28390 PyThreadState* __tstate = wxPyBeginAllowThreads();
28391 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
28392 wxPyEndAllowThreads(__tstate);
28393 if (PyErr_Occurred()) SWIG_fail;
28394 }
28395 {
28396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28397 }
28398 return resultobj;
28399 fail:
28400 return NULL;
28401 }
28402
28403
28404 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28405 PyObject *resultobj = 0;
28406 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28407 wxString result;
28408 void *argp1 = 0 ;
28409 int res1 = 0 ;
28410 PyObject *swig_obj[1] ;
28411
28412 if (!args) SWIG_fail;
28413 swig_obj[0] = args;
28414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28415 if (!SWIG_IsOK(res1)) {
28416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28417 }
28418 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28419 {
28420 PyThreadState* __tstate = wxPyBeginAllowThreads();
28421 result = ((wxUpdateUIEvent const *)arg1)->GetText();
28422 wxPyEndAllowThreads(__tstate);
28423 if (PyErr_Occurred()) SWIG_fail;
28424 }
28425 {
28426 #if wxUSE_UNICODE
28427 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28428 #else
28429 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28430 #endif
28431 }
28432 return resultobj;
28433 fail:
28434 return NULL;
28435 }
28436
28437
28438 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28439 PyObject *resultobj = 0;
28440 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28441 bool result;
28442 void *argp1 = 0 ;
28443 int res1 = 0 ;
28444 PyObject *swig_obj[1] ;
28445
28446 if (!args) SWIG_fail;
28447 swig_obj[0] = args;
28448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28449 if (!SWIG_IsOK(res1)) {
28450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28451 }
28452 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28453 {
28454 PyThreadState* __tstate = wxPyBeginAllowThreads();
28455 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
28456 wxPyEndAllowThreads(__tstate);
28457 if (PyErr_Occurred()) SWIG_fail;
28458 }
28459 {
28460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28461 }
28462 return resultobj;
28463 fail:
28464 return NULL;
28465 }
28466
28467
28468 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28469 PyObject *resultobj = 0;
28470 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28471 bool result;
28472 void *argp1 = 0 ;
28473 int res1 = 0 ;
28474 PyObject *swig_obj[1] ;
28475
28476 if (!args) SWIG_fail;
28477 swig_obj[0] = args;
28478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28479 if (!SWIG_IsOK(res1)) {
28480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28481 }
28482 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28483 {
28484 PyThreadState* __tstate = wxPyBeginAllowThreads();
28485 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
28486 wxPyEndAllowThreads(__tstate);
28487 if (PyErr_Occurred()) SWIG_fail;
28488 }
28489 {
28490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28491 }
28492 return resultobj;
28493 fail:
28494 return NULL;
28495 }
28496
28497
28498 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28499 PyObject *resultobj = 0;
28500 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28501 bool result;
28502 void *argp1 = 0 ;
28503 int res1 = 0 ;
28504 PyObject *swig_obj[1] ;
28505
28506 if (!args) SWIG_fail;
28507 swig_obj[0] = args;
28508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28509 if (!SWIG_IsOK(res1)) {
28510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28511 }
28512 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28513 {
28514 PyThreadState* __tstate = wxPyBeginAllowThreads();
28515 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
28516 wxPyEndAllowThreads(__tstate);
28517 if (PyErr_Occurred()) SWIG_fail;
28518 }
28519 {
28520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28521 }
28522 return resultobj;
28523 fail:
28524 return NULL;
28525 }
28526
28527
28528 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28529 PyObject *resultobj = 0;
28530 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28531 bool result;
28532 void *argp1 = 0 ;
28533 int res1 = 0 ;
28534 PyObject *swig_obj[1] ;
28535
28536 if (!args) SWIG_fail;
28537 swig_obj[0] = args;
28538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28539 if (!SWIG_IsOK(res1)) {
28540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28541 }
28542 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28543 {
28544 PyThreadState* __tstate = wxPyBeginAllowThreads();
28545 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
28546 wxPyEndAllowThreads(__tstate);
28547 if (PyErr_Occurred()) SWIG_fail;
28548 }
28549 {
28550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28551 }
28552 return resultobj;
28553 fail:
28554 return NULL;
28555 }
28556
28557
28558 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28559 PyObject *resultobj = 0;
28560 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28561 bool arg2 ;
28562 void *argp1 = 0 ;
28563 int res1 = 0 ;
28564 bool val2 ;
28565 int ecode2 = 0 ;
28566 PyObject * obj0 = 0 ;
28567 PyObject * obj1 = 0 ;
28568 char * kwnames[] = {
28569 (char *) "self",(char *) "check", NULL
28570 };
28571
28572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
28573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28574 if (!SWIG_IsOK(res1)) {
28575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28576 }
28577 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28578 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28579 if (!SWIG_IsOK(ecode2)) {
28580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
28581 }
28582 arg2 = static_cast< bool >(val2);
28583 {
28584 PyThreadState* __tstate = wxPyBeginAllowThreads();
28585 (arg1)->Check(arg2);
28586 wxPyEndAllowThreads(__tstate);
28587 if (PyErr_Occurred()) SWIG_fail;
28588 }
28589 resultobj = SWIG_Py_Void();
28590 return resultobj;
28591 fail:
28592 return NULL;
28593 }
28594
28595
28596 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28597 PyObject *resultobj = 0;
28598 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28599 bool arg2 ;
28600 void *argp1 = 0 ;
28601 int res1 = 0 ;
28602 bool val2 ;
28603 int ecode2 = 0 ;
28604 PyObject * obj0 = 0 ;
28605 PyObject * obj1 = 0 ;
28606 char * kwnames[] = {
28607 (char *) "self",(char *) "enable", NULL
28608 };
28609
28610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28612 if (!SWIG_IsOK(res1)) {
28613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28614 }
28615 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28616 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28617 if (!SWIG_IsOK(ecode2)) {
28618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28619 }
28620 arg2 = static_cast< bool >(val2);
28621 {
28622 PyThreadState* __tstate = wxPyBeginAllowThreads();
28623 (arg1)->Enable(arg2);
28624 wxPyEndAllowThreads(__tstate);
28625 if (PyErr_Occurred()) SWIG_fail;
28626 }
28627 resultobj = SWIG_Py_Void();
28628 return resultobj;
28629 fail:
28630 return NULL;
28631 }
28632
28633
28634 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28635 PyObject *resultobj = 0;
28636 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28637 bool arg2 ;
28638 void *argp1 = 0 ;
28639 int res1 = 0 ;
28640 bool val2 ;
28641 int ecode2 = 0 ;
28642 PyObject * obj0 = 0 ;
28643 PyObject * obj1 = 0 ;
28644 char * kwnames[] = {
28645 (char *) "self",(char *) "show", NULL
28646 };
28647
28648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28650 if (!SWIG_IsOK(res1)) {
28651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28652 }
28653 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28654 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28655 if (!SWIG_IsOK(ecode2)) {
28656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28657 }
28658 arg2 = static_cast< bool >(val2);
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 (arg1)->Show(arg2);
28662 wxPyEndAllowThreads(__tstate);
28663 if (PyErr_Occurred()) SWIG_fail;
28664 }
28665 resultobj = SWIG_Py_Void();
28666 return resultobj;
28667 fail:
28668 return NULL;
28669 }
28670
28671
28672 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28673 PyObject *resultobj = 0;
28674 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28675 wxString *arg2 = 0 ;
28676 void *argp1 = 0 ;
28677 int res1 = 0 ;
28678 bool temp2 = false ;
28679 PyObject * obj0 = 0 ;
28680 PyObject * obj1 = 0 ;
28681 char * kwnames[] = {
28682 (char *) "self",(char *) "text", NULL
28683 };
28684
28685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28687 if (!SWIG_IsOK(res1)) {
28688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28689 }
28690 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28691 {
28692 arg2 = wxString_in_helper(obj1);
28693 if (arg2 == NULL) SWIG_fail;
28694 temp2 = true;
28695 }
28696 {
28697 PyThreadState* __tstate = wxPyBeginAllowThreads();
28698 (arg1)->SetText((wxString const &)*arg2);
28699 wxPyEndAllowThreads(__tstate);
28700 if (PyErr_Occurred()) SWIG_fail;
28701 }
28702 resultobj = SWIG_Py_Void();
28703 {
28704 if (temp2)
28705 delete arg2;
28706 }
28707 return resultobj;
28708 fail:
28709 {
28710 if (temp2)
28711 delete arg2;
28712 }
28713 return NULL;
28714 }
28715
28716
28717 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28718 PyObject *resultobj = 0;
28719 long arg1 ;
28720 long val1 ;
28721 int ecode1 = 0 ;
28722 PyObject * obj0 = 0 ;
28723 char * kwnames[] = {
28724 (char *) "updateInterval", NULL
28725 };
28726
28727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28728 ecode1 = SWIG_AsVal_long(obj0, &val1);
28729 if (!SWIG_IsOK(ecode1)) {
28730 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28731 }
28732 arg1 = static_cast< long >(val1);
28733 {
28734 PyThreadState* __tstate = wxPyBeginAllowThreads();
28735 wxUpdateUIEvent::SetUpdateInterval(arg1);
28736 wxPyEndAllowThreads(__tstate);
28737 if (PyErr_Occurred()) SWIG_fail;
28738 }
28739 resultobj = SWIG_Py_Void();
28740 return resultobj;
28741 fail:
28742 return NULL;
28743 }
28744
28745
28746 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28747 PyObject *resultobj = 0;
28748 long result;
28749
28750 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28751 {
28752 PyThreadState* __tstate = wxPyBeginAllowThreads();
28753 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28754 wxPyEndAllowThreads(__tstate);
28755 if (PyErr_Occurred()) SWIG_fail;
28756 }
28757 resultobj = SWIG_From_long(static_cast< long >(result));
28758 return resultobj;
28759 fail:
28760 return NULL;
28761 }
28762
28763
28764 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28765 PyObject *resultobj = 0;
28766 wxWindow *arg1 = (wxWindow *) 0 ;
28767 bool result;
28768 void *argp1 = 0 ;
28769 int res1 = 0 ;
28770 PyObject * obj0 = 0 ;
28771 char * kwnames[] = {
28772 (char *) "win", NULL
28773 };
28774
28775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28777 if (!SWIG_IsOK(res1)) {
28778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28779 }
28780 arg1 = reinterpret_cast< wxWindow * >(argp1);
28781 {
28782 PyThreadState* __tstate = wxPyBeginAllowThreads();
28783 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28784 wxPyEndAllowThreads(__tstate);
28785 if (PyErr_Occurred()) SWIG_fail;
28786 }
28787 {
28788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28789 }
28790 return resultobj;
28791 fail:
28792 return NULL;
28793 }
28794
28795
28796 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28797 PyObject *resultobj = 0;
28798
28799 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28800 {
28801 PyThreadState* __tstate = wxPyBeginAllowThreads();
28802 wxUpdateUIEvent::ResetUpdateTime();
28803 wxPyEndAllowThreads(__tstate);
28804 if (PyErr_Occurred()) SWIG_fail;
28805 }
28806 resultobj = SWIG_Py_Void();
28807 return resultobj;
28808 fail:
28809 return NULL;
28810 }
28811
28812
28813 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28814 PyObject *resultobj = 0;
28815 wxUpdateUIMode arg1 ;
28816 int val1 ;
28817 int ecode1 = 0 ;
28818 PyObject * obj0 = 0 ;
28819 char * kwnames[] = {
28820 (char *) "mode", NULL
28821 };
28822
28823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28824 ecode1 = SWIG_AsVal_int(obj0, &val1);
28825 if (!SWIG_IsOK(ecode1)) {
28826 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28827 }
28828 arg1 = static_cast< wxUpdateUIMode >(val1);
28829 {
28830 PyThreadState* __tstate = wxPyBeginAllowThreads();
28831 wxUpdateUIEvent::SetMode(arg1);
28832 wxPyEndAllowThreads(__tstate);
28833 if (PyErr_Occurred()) SWIG_fail;
28834 }
28835 resultobj = SWIG_Py_Void();
28836 return resultobj;
28837 fail:
28838 return NULL;
28839 }
28840
28841
28842 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28843 PyObject *resultobj = 0;
28844 wxUpdateUIMode result;
28845
28846 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28847 {
28848 PyThreadState* __tstate = wxPyBeginAllowThreads();
28849 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28850 wxPyEndAllowThreads(__tstate);
28851 if (PyErr_Occurred()) SWIG_fail;
28852 }
28853 resultobj = SWIG_From_int(static_cast< int >(result));
28854 return resultobj;
28855 fail:
28856 return NULL;
28857 }
28858
28859
28860 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28861 PyObject *obj;
28862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28863 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28864 return SWIG_Py_Void();
28865 }
28866
28867 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28868 return SWIG_Python_InitShadowInstance(args);
28869 }
28870
28871 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28872 PyObject *resultobj = 0;
28873 wxSysColourChangedEvent *result = 0 ;
28874
28875 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28876 {
28877 PyThreadState* __tstate = wxPyBeginAllowThreads();
28878 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28879 wxPyEndAllowThreads(__tstate);
28880 if (PyErr_Occurred()) SWIG_fail;
28881 }
28882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28883 return resultobj;
28884 fail:
28885 return NULL;
28886 }
28887
28888
28889 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28890 PyObject *obj;
28891 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28892 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28893 return SWIG_Py_Void();
28894 }
28895
28896 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28897 return SWIG_Python_InitShadowInstance(args);
28898 }
28899
28900 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28901 PyObject *resultobj = 0;
28902 int arg1 = (int) 0 ;
28903 wxWindow *arg2 = (wxWindow *) NULL ;
28904 wxMouseCaptureChangedEvent *result = 0 ;
28905 int val1 ;
28906 int ecode1 = 0 ;
28907 void *argp2 = 0 ;
28908 int res2 = 0 ;
28909 PyObject * obj0 = 0 ;
28910 PyObject * obj1 = 0 ;
28911 char * kwnames[] = {
28912 (char *) "winid",(char *) "gainedCapture", NULL
28913 };
28914
28915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28916 if (obj0) {
28917 ecode1 = SWIG_AsVal_int(obj0, &val1);
28918 if (!SWIG_IsOK(ecode1)) {
28919 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28920 }
28921 arg1 = static_cast< int >(val1);
28922 }
28923 if (obj1) {
28924 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28925 if (!SWIG_IsOK(res2)) {
28926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28927 }
28928 arg2 = reinterpret_cast< wxWindow * >(argp2);
28929 }
28930 {
28931 PyThreadState* __tstate = wxPyBeginAllowThreads();
28932 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28933 wxPyEndAllowThreads(__tstate);
28934 if (PyErr_Occurred()) SWIG_fail;
28935 }
28936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28937 return resultobj;
28938 fail:
28939 return NULL;
28940 }
28941
28942
28943 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28944 PyObject *resultobj = 0;
28945 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28946 wxWindow *result = 0 ;
28947 void *argp1 = 0 ;
28948 int res1 = 0 ;
28949 PyObject *swig_obj[1] ;
28950
28951 if (!args) SWIG_fail;
28952 swig_obj[0] = args;
28953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28954 if (!SWIG_IsOK(res1)) {
28955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28956 }
28957 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28958 {
28959 PyThreadState* __tstate = wxPyBeginAllowThreads();
28960 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28961 wxPyEndAllowThreads(__tstate);
28962 if (PyErr_Occurred()) SWIG_fail;
28963 }
28964 {
28965 resultobj = wxPyMake_wxObject(result, (bool)0);
28966 }
28967 return resultobj;
28968 fail:
28969 return NULL;
28970 }
28971
28972
28973 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28974 PyObject *obj;
28975 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28976 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28977 return SWIG_Py_Void();
28978 }
28979
28980 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28981 return SWIG_Python_InitShadowInstance(args);
28982 }
28983
28984 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28985 PyObject *resultobj = 0;
28986 int arg1 = (int) 0 ;
28987 wxMouseCaptureLostEvent *result = 0 ;
28988 int val1 ;
28989 int ecode1 = 0 ;
28990 PyObject * obj0 = 0 ;
28991 char * kwnames[] = {
28992 (char *) "winid", NULL
28993 };
28994
28995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28996 if (obj0) {
28997 ecode1 = SWIG_AsVal_int(obj0, &val1);
28998 if (!SWIG_IsOK(ecode1)) {
28999 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
29000 }
29001 arg1 = static_cast< int >(val1);
29002 }
29003 {
29004 PyThreadState* __tstate = wxPyBeginAllowThreads();
29005 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
29006 wxPyEndAllowThreads(__tstate);
29007 if (PyErr_Occurred()) SWIG_fail;
29008 }
29009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
29010 return resultobj;
29011 fail:
29012 return NULL;
29013 }
29014
29015
29016 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29017 PyObject *obj;
29018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29019 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
29020 return SWIG_Py_Void();
29021 }
29022
29023 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29024 return SWIG_Python_InitShadowInstance(args);
29025 }
29026
29027 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29028 PyObject *resultobj = 0;
29029 wxDisplayChangedEvent *result = 0 ;
29030
29031 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
29032 {
29033 PyThreadState* __tstate = wxPyBeginAllowThreads();
29034 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
29035 wxPyEndAllowThreads(__tstate);
29036 if (PyErr_Occurred()) SWIG_fail;
29037 }
29038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
29039 return resultobj;
29040 fail:
29041 return NULL;
29042 }
29043
29044
29045 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29046 PyObject *obj;
29047 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29048 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
29049 return SWIG_Py_Void();
29050 }
29051
29052 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29053 return SWIG_Python_InitShadowInstance(args);
29054 }
29055
29056 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29057 PyObject *resultobj = 0;
29058 int arg1 = (int) 0 ;
29059 wxPaletteChangedEvent *result = 0 ;
29060 int val1 ;
29061 int ecode1 = 0 ;
29062 PyObject * obj0 = 0 ;
29063 char * kwnames[] = {
29064 (char *) "id", NULL
29065 };
29066
29067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
29068 if (obj0) {
29069 ecode1 = SWIG_AsVal_int(obj0, &val1);
29070 if (!SWIG_IsOK(ecode1)) {
29071 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
29072 }
29073 arg1 = static_cast< int >(val1);
29074 }
29075 {
29076 PyThreadState* __tstate = wxPyBeginAllowThreads();
29077 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
29078 wxPyEndAllowThreads(__tstate);
29079 if (PyErr_Occurred()) SWIG_fail;
29080 }
29081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
29082 return resultobj;
29083 fail:
29084 return NULL;
29085 }
29086
29087
29088 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29089 PyObject *resultobj = 0;
29090 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
29091 wxWindow *arg2 = (wxWindow *) 0 ;
29092 void *argp1 = 0 ;
29093 int res1 = 0 ;
29094 void *argp2 = 0 ;
29095 int res2 = 0 ;
29096 PyObject * obj0 = 0 ;
29097 PyObject * obj1 = 0 ;
29098 char * kwnames[] = {
29099 (char *) "self",(char *) "win", NULL
29100 };
29101
29102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
29103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
29104 if (!SWIG_IsOK(res1)) {
29105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
29106 }
29107 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
29108 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29109 if (!SWIG_IsOK(res2)) {
29110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
29111 }
29112 arg2 = reinterpret_cast< wxWindow * >(argp2);
29113 {
29114 PyThreadState* __tstate = wxPyBeginAllowThreads();
29115 (arg1)->SetChangedWindow(arg2);
29116 wxPyEndAllowThreads(__tstate);
29117 if (PyErr_Occurred()) SWIG_fail;
29118 }
29119 resultobj = SWIG_Py_Void();
29120 return resultobj;
29121 fail:
29122 return NULL;
29123 }
29124
29125
29126 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29127 PyObject *resultobj = 0;
29128 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
29129 wxWindow *result = 0 ;
29130 void *argp1 = 0 ;
29131 int res1 = 0 ;
29132 PyObject *swig_obj[1] ;
29133
29134 if (!args) SWIG_fail;
29135 swig_obj[0] = args;
29136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
29137 if (!SWIG_IsOK(res1)) {
29138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
29139 }
29140 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
29141 {
29142 PyThreadState* __tstate = wxPyBeginAllowThreads();
29143 result = (wxWindow *)(arg1)->GetChangedWindow();
29144 wxPyEndAllowThreads(__tstate);
29145 if (PyErr_Occurred()) SWIG_fail;
29146 }
29147 {
29148 resultobj = wxPyMake_wxObject(result, (bool)0);
29149 }
29150 return resultobj;
29151 fail:
29152 return NULL;
29153 }
29154
29155
29156 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29157 PyObject *obj;
29158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29159 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
29160 return SWIG_Py_Void();
29161 }
29162
29163 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29164 return SWIG_Python_InitShadowInstance(args);
29165 }
29166
29167 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29168 PyObject *resultobj = 0;
29169 int arg1 = (int) 0 ;
29170 wxQueryNewPaletteEvent *result = 0 ;
29171 int val1 ;
29172 int ecode1 = 0 ;
29173 PyObject * obj0 = 0 ;
29174 char * kwnames[] = {
29175 (char *) "winid", NULL
29176 };
29177
29178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
29179 if (obj0) {
29180 ecode1 = SWIG_AsVal_int(obj0, &val1);
29181 if (!SWIG_IsOK(ecode1)) {
29182 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
29183 }
29184 arg1 = static_cast< int >(val1);
29185 }
29186 {
29187 PyThreadState* __tstate = wxPyBeginAllowThreads();
29188 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
29189 wxPyEndAllowThreads(__tstate);
29190 if (PyErr_Occurred()) SWIG_fail;
29191 }
29192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
29193 return resultobj;
29194 fail:
29195 return NULL;
29196 }
29197
29198
29199 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29200 PyObject *resultobj = 0;
29201 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
29202 bool arg2 ;
29203 void *argp1 = 0 ;
29204 int res1 = 0 ;
29205 bool val2 ;
29206 int ecode2 = 0 ;
29207 PyObject * obj0 = 0 ;
29208 PyObject * obj1 = 0 ;
29209 char * kwnames[] = {
29210 (char *) "self",(char *) "realized", NULL
29211 };
29212
29213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
29214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
29215 if (!SWIG_IsOK(res1)) {
29216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
29217 }
29218 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
29219 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29220 if (!SWIG_IsOK(ecode2)) {
29221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
29222 }
29223 arg2 = static_cast< bool >(val2);
29224 {
29225 PyThreadState* __tstate = wxPyBeginAllowThreads();
29226 (arg1)->SetPaletteRealized(arg2);
29227 wxPyEndAllowThreads(__tstate);
29228 if (PyErr_Occurred()) SWIG_fail;
29229 }
29230 resultobj = SWIG_Py_Void();
29231 return resultobj;
29232 fail:
29233 return NULL;
29234 }
29235
29236
29237 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29238 PyObject *resultobj = 0;
29239 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
29240 bool result;
29241 void *argp1 = 0 ;
29242 int res1 = 0 ;
29243 PyObject *swig_obj[1] ;
29244
29245 if (!args) SWIG_fail;
29246 swig_obj[0] = args;
29247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
29248 if (!SWIG_IsOK(res1)) {
29249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
29250 }
29251 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
29252 {
29253 PyThreadState* __tstate = wxPyBeginAllowThreads();
29254 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
29255 wxPyEndAllowThreads(__tstate);
29256 if (PyErr_Occurred()) SWIG_fail;
29257 }
29258 {
29259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29260 }
29261 return resultobj;
29262 fail:
29263 return NULL;
29264 }
29265
29266
29267 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29268 PyObject *obj;
29269 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29270 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
29271 return SWIG_Py_Void();
29272 }
29273
29274 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29275 return SWIG_Python_InitShadowInstance(args);
29276 }
29277
29278 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29279 PyObject *resultobj = 0;
29280 wxNavigationKeyEvent *result = 0 ;
29281
29282 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
29283 {
29284 PyThreadState* __tstate = wxPyBeginAllowThreads();
29285 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
29286 wxPyEndAllowThreads(__tstate);
29287 if (PyErr_Occurred()) SWIG_fail;
29288 }
29289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
29290 return resultobj;
29291 fail:
29292 return NULL;
29293 }
29294
29295
29296 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29297 PyObject *resultobj = 0;
29298 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29299 bool result;
29300 void *argp1 = 0 ;
29301 int res1 = 0 ;
29302 PyObject *swig_obj[1] ;
29303
29304 if (!args) SWIG_fail;
29305 swig_obj[0] = args;
29306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29307 if (!SWIG_IsOK(res1)) {
29308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29309 }
29310 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29311 {
29312 PyThreadState* __tstate = wxPyBeginAllowThreads();
29313 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
29314 wxPyEndAllowThreads(__tstate);
29315 if (PyErr_Occurred()) SWIG_fail;
29316 }
29317 {
29318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29319 }
29320 return resultobj;
29321 fail:
29322 return NULL;
29323 }
29324
29325
29326 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29327 PyObject *resultobj = 0;
29328 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29329 bool arg2 ;
29330 void *argp1 = 0 ;
29331 int res1 = 0 ;
29332 bool val2 ;
29333 int ecode2 = 0 ;
29334 PyObject * obj0 = 0 ;
29335 PyObject * obj1 = 0 ;
29336 char * kwnames[] = {
29337 (char *) "self",(char *) "forward", NULL
29338 };
29339
29340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
29341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29342 if (!SWIG_IsOK(res1)) {
29343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29344 }
29345 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29346 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29347 if (!SWIG_IsOK(ecode2)) {
29348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
29349 }
29350 arg2 = static_cast< bool >(val2);
29351 {
29352 PyThreadState* __tstate = wxPyBeginAllowThreads();
29353 (arg1)->SetDirection(arg2);
29354 wxPyEndAllowThreads(__tstate);
29355 if (PyErr_Occurred()) SWIG_fail;
29356 }
29357 resultobj = SWIG_Py_Void();
29358 return resultobj;
29359 fail:
29360 return NULL;
29361 }
29362
29363
29364 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29365 PyObject *resultobj = 0;
29366 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29367 bool result;
29368 void *argp1 = 0 ;
29369 int res1 = 0 ;
29370 PyObject *swig_obj[1] ;
29371
29372 if (!args) SWIG_fail;
29373 swig_obj[0] = args;
29374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29375 if (!SWIG_IsOK(res1)) {
29376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29377 }
29378 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29379 {
29380 PyThreadState* __tstate = wxPyBeginAllowThreads();
29381 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
29382 wxPyEndAllowThreads(__tstate);
29383 if (PyErr_Occurred()) SWIG_fail;
29384 }
29385 {
29386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29387 }
29388 return resultobj;
29389 fail:
29390 return NULL;
29391 }
29392
29393
29394 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29395 PyObject *resultobj = 0;
29396 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29397 bool arg2 ;
29398 void *argp1 = 0 ;
29399 int res1 = 0 ;
29400 bool val2 ;
29401 int ecode2 = 0 ;
29402 PyObject * obj0 = 0 ;
29403 PyObject * obj1 = 0 ;
29404 char * kwnames[] = {
29405 (char *) "self",(char *) "ischange", NULL
29406 };
29407
29408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
29409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29410 if (!SWIG_IsOK(res1)) {
29411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29412 }
29413 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29414 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29415 if (!SWIG_IsOK(ecode2)) {
29416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
29417 }
29418 arg2 = static_cast< bool >(val2);
29419 {
29420 PyThreadState* __tstate = wxPyBeginAllowThreads();
29421 (arg1)->SetWindowChange(arg2);
29422 wxPyEndAllowThreads(__tstate);
29423 if (PyErr_Occurred()) SWIG_fail;
29424 }
29425 resultobj = SWIG_Py_Void();
29426 return resultobj;
29427 fail:
29428 return NULL;
29429 }
29430
29431
29432 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29433 PyObject *resultobj = 0;
29434 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29435 bool result;
29436 void *argp1 = 0 ;
29437 int res1 = 0 ;
29438 PyObject *swig_obj[1] ;
29439
29440 if (!args) SWIG_fail;
29441 swig_obj[0] = args;
29442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29443 if (!SWIG_IsOK(res1)) {
29444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29445 }
29446 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29447 {
29448 PyThreadState* __tstate = wxPyBeginAllowThreads();
29449 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
29450 wxPyEndAllowThreads(__tstate);
29451 if (PyErr_Occurred()) SWIG_fail;
29452 }
29453 {
29454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29455 }
29456 return resultobj;
29457 fail:
29458 return NULL;
29459 }
29460
29461
29462 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29463 PyObject *resultobj = 0;
29464 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29465 bool arg2 ;
29466 void *argp1 = 0 ;
29467 int res1 = 0 ;
29468 bool val2 ;
29469 int ecode2 = 0 ;
29470 PyObject * obj0 = 0 ;
29471 PyObject * obj1 = 0 ;
29472 char * kwnames[] = {
29473 (char *) "self",(char *) "bIs", NULL
29474 };
29475
29476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
29477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29478 if (!SWIG_IsOK(res1)) {
29479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29480 }
29481 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29482 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29483 if (!SWIG_IsOK(ecode2)) {
29484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
29485 }
29486 arg2 = static_cast< bool >(val2);
29487 {
29488 PyThreadState* __tstate = wxPyBeginAllowThreads();
29489 (arg1)->SetFromTab(arg2);
29490 wxPyEndAllowThreads(__tstate);
29491 if (PyErr_Occurred()) SWIG_fail;
29492 }
29493 resultobj = SWIG_Py_Void();
29494 return resultobj;
29495 fail:
29496 return NULL;
29497 }
29498
29499
29500 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29501 PyObject *resultobj = 0;
29502 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29503 long arg2 ;
29504 void *argp1 = 0 ;
29505 int res1 = 0 ;
29506 long val2 ;
29507 int ecode2 = 0 ;
29508 PyObject * obj0 = 0 ;
29509 PyObject * obj1 = 0 ;
29510 char * kwnames[] = {
29511 (char *) "self",(char *) "flags", NULL
29512 };
29513
29514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
29515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29516 if (!SWIG_IsOK(res1)) {
29517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29518 }
29519 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29520 ecode2 = SWIG_AsVal_long(obj1, &val2);
29521 if (!SWIG_IsOK(ecode2)) {
29522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
29523 }
29524 arg2 = static_cast< long >(val2);
29525 {
29526 PyThreadState* __tstate = wxPyBeginAllowThreads();
29527 (arg1)->SetFlags(arg2);
29528 wxPyEndAllowThreads(__tstate);
29529 if (PyErr_Occurred()) SWIG_fail;
29530 }
29531 resultobj = SWIG_Py_Void();
29532 return resultobj;
29533 fail:
29534 return NULL;
29535 }
29536
29537
29538 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29539 PyObject *resultobj = 0;
29540 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29541 wxWindow *result = 0 ;
29542 void *argp1 = 0 ;
29543 int res1 = 0 ;
29544 PyObject *swig_obj[1] ;
29545
29546 if (!args) SWIG_fail;
29547 swig_obj[0] = args;
29548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29549 if (!SWIG_IsOK(res1)) {
29550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29551 }
29552 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29553 {
29554 PyThreadState* __tstate = wxPyBeginAllowThreads();
29555 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
29556 wxPyEndAllowThreads(__tstate);
29557 if (PyErr_Occurred()) SWIG_fail;
29558 }
29559 {
29560 resultobj = wxPyMake_wxObject(result, (bool)0);
29561 }
29562 return resultobj;
29563 fail:
29564 return NULL;
29565 }
29566
29567
29568 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29569 PyObject *resultobj = 0;
29570 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29571 wxWindow *arg2 = (wxWindow *) 0 ;
29572 void *argp1 = 0 ;
29573 int res1 = 0 ;
29574 void *argp2 = 0 ;
29575 int res2 = 0 ;
29576 PyObject * obj0 = 0 ;
29577 PyObject * obj1 = 0 ;
29578 char * kwnames[] = {
29579 (char *) "self",(char *) "win", NULL
29580 };
29581
29582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
29583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29584 if (!SWIG_IsOK(res1)) {
29585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29586 }
29587 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29588 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29589 if (!SWIG_IsOK(res2)) {
29590 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
29591 }
29592 arg2 = reinterpret_cast< wxWindow * >(argp2);
29593 {
29594 PyThreadState* __tstate = wxPyBeginAllowThreads();
29595 (arg1)->SetCurrentFocus(arg2);
29596 wxPyEndAllowThreads(__tstate);
29597 if (PyErr_Occurred()) SWIG_fail;
29598 }
29599 resultobj = SWIG_Py_Void();
29600 return resultobj;
29601 fail:
29602 return NULL;
29603 }
29604
29605
29606 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29607 PyObject *obj;
29608 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29609 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
29610 return SWIG_Py_Void();
29611 }
29612
29613 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29614 return SWIG_Python_InitShadowInstance(args);
29615 }
29616
29617 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29618 PyObject *resultobj = 0;
29619 wxWindow *arg1 = (wxWindow *) NULL ;
29620 wxWindowCreateEvent *result = 0 ;
29621 void *argp1 = 0 ;
29622 int res1 = 0 ;
29623 PyObject * obj0 = 0 ;
29624 char * kwnames[] = {
29625 (char *) "win", NULL
29626 };
29627
29628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29629 if (obj0) {
29630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29631 if (!SWIG_IsOK(res1)) {
29632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29633 }
29634 arg1 = reinterpret_cast< wxWindow * >(argp1);
29635 }
29636 {
29637 PyThreadState* __tstate = wxPyBeginAllowThreads();
29638 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29639 wxPyEndAllowThreads(__tstate);
29640 if (PyErr_Occurred()) SWIG_fail;
29641 }
29642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29643 return resultobj;
29644 fail:
29645 return NULL;
29646 }
29647
29648
29649 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29650 PyObject *resultobj = 0;
29651 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29652 wxWindow *result = 0 ;
29653 void *argp1 = 0 ;
29654 int res1 = 0 ;
29655 PyObject *swig_obj[1] ;
29656
29657 if (!args) SWIG_fail;
29658 swig_obj[0] = args;
29659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29660 if (!SWIG_IsOK(res1)) {
29661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29662 }
29663 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29664 {
29665 PyThreadState* __tstate = wxPyBeginAllowThreads();
29666 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29667 wxPyEndAllowThreads(__tstate);
29668 if (PyErr_Occurred()) SWIG_fail;
29669 }
29670 {
29671 resultobj = wxPyMake_wxObject(result, (bool)0);
29672 }
29673 return resultobj;
29674 fail:
29675 return NULL;
29676 }
29677
29678
29679 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29680 PyObject *obj;
29681 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29682 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29683 return SWIG_Py_Void();
29684 }
29685
29686 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29687 return SWIG_Python_InitShadowInstance(args);
29688 }
29689
29690 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29691 PyObject *resultobj = 0;
29692 wxWindow *arg1 = (wxWindow *) NULL ;
29693 wxWindowDestroyEvent *result = 0 ;
29694 void *argp1 = 0 ;
29695 int res1 = 0 ;
29696 PyObject * obj0 = 0 ;
29697 char * kwnames[] = {
29698 (char *) "win", NULL
29699 };
29700
29701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29702 if (obj0) {
29703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29704 if (!SWIG_IsOK(res1)) {
29705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29706 }
29707 arg1 = reinterpret_cast< wxWindow * >(argp1);
29708 }
29709 {
29710 PyThreadState* __tstate = wxPyBeginAllowThreads();
29711 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29712 wxPyEndAllowThreads(__tstate);
29713 if (PyErr_Occurred()) SWIG_fail;
29714 }
29715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29716 return resultobj;
29717 fail:
29718 return NULL;
29719 }
29720
29721
29722 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29723 PyObject *resultobj = 0;
29724 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29725 wxWindow *result = 0 ;
29726 void *argp1 = 0 ;
29727 int res1 = 0 ;
29728 PyObject *swig_obj[1] ;
29729
29730 if (!args) SWIG_fail;
29731 swig_obj[0] = args;
29732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29733 if (!SWIG_IsOK(res1)) {
29734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29735 }
29736 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29737 {
29738 PyThreadState* __tstate = wxPyBeginAllowThreads();
29739 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29740 wxPyEndAllowThreads(__tstate);
29741 if (PyErr_Occurred()) SWIG_fail;
29742 }
29743 {
29744 resultobj = wxPyMake_wxObject(result, (bool)0);
29745 }
29746 return resultobj;
29747 fail:
29748 return NULL;
29749 }
29750
29751
29752 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29753 PyObject *obj;
29754 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29755 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29756 return SWIG_Py_Void();
29757 }
29758
29759 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29760 return SWIG_Python_InitShadowInstance(args);
29761 }
29762
29763 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29764 PyObject *resultobj = 0;
29765 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29766 int arg2 = (int) 0 ;
29767 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29768 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29769 wxContextMenuEvent *result = 0 ;
29770 int val1 ;
29771 int ecode1 = 0 ;
29772 int val2 ;
29773 int ecode2 = 0 ;
29774 wxPoint temp3 ;
29775 PyObject * obj0 = 0 ;
29776 PyObject * obj1 = 0 ;
29777 PyObject * obj2 = 0 ;
29778 char * kwnames[] = {
29779 (char *) "type",(char *) "winid",(char *) "pt", NULL
29780 };
29781
29782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29783 if (obj0) {
29784 ecode1 = SWIG_AsVal_int(obj0, &val1);
29785 if (!SWIG_IsOK(ecode1)) {
29786 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29787 }
29788 arg1 = static_cast< wxEventType >(val1);
29789 }
29790 if (obj1) {
29791 ecode2 = SWIG_AsVal_int(obj1, &val2);
29792 if (!SWIG_IsOK(ecode2)) {
29793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29794 }
29795 arg2 = static_cast< int >(val2);
29796 }
29797 if (obj2) {
29798 {
29799 arg3 = &temp3;
29800 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29801 }
29802 }
29803 {
29804 PyThreadState* __tstate = wxPyBeginAllowThreads();
29805 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29806 wxPyEndAllowThreads(__tstate);
29807 if (PyErr_Occurred()) SWIG_fail;
29808 }
29809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29810 return resultobj;
29811 fail:
29812 return NULL;
29813 }
29814
29815
29816 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29817 PyObject *resultobj = 0;
29818 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29819 wxPoint *result = 0 ;
29820 void *argp1 = 0 ;
29821 int res1 = 0 ;
29822 PyObject *swig_obj[1] ;
29823
29824 if (!args) SWIG_fail;
29825 swig_obj[0] = args;
29826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29827 if (!SWIG_IsOK(res1)) {
29828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29829 }
29830 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29831 {
29832 PyThreadState* __tstate = wxPyBeginAllowThreads();
29833 {
29834 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29835 result = (wxPoint *) &_result_ref;
29836 }
29837 wxPyEndAllowThreads(__tstate);
29838 if (PyErr_Occurred()) SWIG_fail;
29839 }
29840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29841 return resultobj;
29842 fail:
29843 return NULL;
29844 }
29845
29846
29847 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29848 PyObject *resultobj = 0;
29849 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29850 wxPoint *arg2 = 0 ;
29851 void *argp1 = 0 ;
29852 int res1 = 0 ;
29853 wxPoint temp2 ;
29854 PyObject * obj0 = 0 ;
29855 PyObject * obj1 = 0 ;
29856 char * kwnames[] = {
29857 (char *) "self",(char *) "pos", NULL
29858 };
29859
29860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29862 if (!SWIG_IsOK(res1)) {
29863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29864 }
29865 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29866 {
29867 arg2 = &temp2;
29868 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29869 }
29870 {
29871 PyThreadState* __tstate = wxPyBeginAllowThreads();
29872 (arg1)->SetPosition((wxPoint const &)*arg2);
29873 wxPyEndAllowThreads(__tstate);
29874 if (PyErr_Occurred()) SWIG_fail;
29875 }
29876 resultobj = SWIG_Py_Void();
29877 return resultobj;
29878 fail:
29879 return NULL;
29880 }
29881
29882
29883 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29884 PyObject *obj;
29885 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29886 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29887 return SWIG_Py_Void();
29888 }
29889
29890 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29891 return SWIG_Python_InitShadowInstance(args);
29892 }
29893
29894 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29895 PyObject *resultobj = 0;
29896 wxIdleEvent *result = 0 ;
29897
29898 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29899 {
29900 PyThreadState* __tstate = wxPyBeginAllowThreads();
29901 result = (wxIdleEvent *)new wxIdleEvent();
29902 wxPyEndAllowThreads(__tstate);
29903 if (PyErr_Occurred()) SWIG_fail;
29904 }
29905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29906 return resultobj;
29907 fail:
29908 return NULL;
29909 }
29910
29911
29912 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29913 PyObject *resultobj = 0;
29914 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29915 bool arg2 = (bool) true ;
29916 void *argp1 = 0 ;
29917 int res1 = 0 ;
29918 bool val2 ;
29919 int ecode2 = 0 ;
29920 PyObject * obj0 = 0 ;
29921 PyObject * obj1 = 0 ;
29922 char * kwnames[] = {
29923 (char *) "self",(char *) "needMore", NULL
29924 };
29925
29926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29928 if (!SWIG_IsOK(res1)) {
29929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29930 }
29931 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29932 if (obj1) {
29933 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29934 if (!SWIG_IsOK(ecode2)) {
29935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29936 }
29937 arg2 = static_cast< bool >(val2);
29938 }
29939 {
29940 PyThreadState* __tstate = wxPyBeginAllowThreads();
29941 (arg1)->RequestMore(arg2);
29942 wxPyEndAllowThreads(__tstate);
29943 if (PyErr_Occurred()) SWIG_fail;
29944 }
29945 resultobj = SWIG_Py_Void();
29946 return resultobj;
29947 fail:
29948 return NULL;
29949 }
29950
29951
29952 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29953 PyObject *resultobj = 0;
29954 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29955 bool result;
29956 void *argp1 = 0 ;
29957 int res1 = 0 ;
29958 PyObject *swig_obj[1] ;
29959
29960 if (!args) SWIG_fail;
29961 swig_obj[0] = args;
29962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29963 if (!SWIG_IsOK(res1)) {
29964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29965 }
29966 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29967 {
29968 PyThreadState* __tstate = wxPyBeginAllowThreads();
29969 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29970 wxPyEndAllowThreads(__tstate);
29971 if (PyErr_Occurred()) SWIG_fail;
29972 }
29973 {
29974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29975 }
29976 return resultobj;
29977 fail:
29978 return NULL;
29979 }
29980
29981
29982 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29983 PyObject *resultobj = 0;
29984 wxIdleMode arg1 ;
29985 int val1 ;
29986 int ecode1 = 0 ;
29987 PyObject * obj0 = 0 ;
29988 char * kwnames[] = {
29989 (char *) "mode", NULL
29990 };
29991
29992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29993 ecode1 = SWIG_AsVal_int(obj0, &val1);
29994 if (!SWIG_IsOK(ecode1)) {
29995 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29996 }
29997 arg1 = static_cast< wxIdleMode >(val1);
29998 {
29999 PyThreadState* __tstate = wxPyBeginAllowThreads();
30000 wxIdleEvent::SetMode(arg1);
30001 wxPyEndAllowThreads(__tstate);
30002 if (PyErr_Occurred()) SWIG_fail;
30003 }
30004 resultobj = SWIG_Py_Void();
30005 return resultobj;
30006 fail:
30007 return NULL;
30008 }
30009
30010
30011 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30012 PyObject *resultobj = 0;
30013 wxIdleMode result;
30014
30015 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
30016 {
30017 PyThreadState* __tstate = wxPyBeginAllowThreads();
30018 result = (wxIdleMode)wxIdleEvent::GetMode();
30019 wxPyEndAllowThreads(__tstate);
30020 if (PyErr_Occurred()) SWIG_fail;
30021 }
30022 resultobj = SWIG_From_int(static_cast< int >(result));
30023 return resultobj;
30024 fail:
30025 return NULL;
30026 }
30027
30028
30029 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30030 PyObject *resultobj = 0;
30031 wxWindow *arg1 = (wxWindow *) 0 ;
30032 bool result;
30033 void *argp1 = 0 ;
30034 int res1 = 0 ;
30035 PyObject * obj0 = 0 ;
30036 char * kwnames[] = {
30037 (char *) "win", NULL
30038 };
30039
30040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
30041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30042 if (!SWIG_IsOK(res1)) {
30043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
30044 }
30045 arg1 = reinterpret_cast< wxWindow * >(argp1);
30046 {
30047 PyThreadState* __tstate = wxPyBeginAllowThreads();
30048 result = (bool)wxIdleEvent::CanSend(arg1);
30049 wxPyEndAllowThreads(__tstate);
30050 if (PyErr_Occurred()) SWIG_fail;
30051 }
30052 {
30053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30054 }
30055 return resultobj;
30056 fail:
30057 return NULL;
30058 }
30059
30060
30061 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30062 PyObject *obj;
30063 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30064 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
30065 return SWIG_Py_Void();
30066 }
30067
30068 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30069 return SWIG_Python_InitShadowInstance(args);
30070 }
30071
30072 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30073 PyObject *resultobj = 0;
30074 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
30075 int arg2 = (int) 0 ;
30076 wxClipboardTextEvent *result = 0 ;
30077 int val1 ;
30078 int ecode1 = 0 ;
30079 int val2 ;
30080 int ecode2 = 0 ;
30081 PyObject * obj0 = 0 ;
30082 PyObject * obj1 = 0 ;
30083 char * kwnames[] = {
30084 (char *) "type",(char *) "winid", NULL
30085 };
30086
30087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
30088 if (obj0) {
30089 ecode1 = SWIG_AsVal_int(obj0, &val1);
30090 if (!SWIG_IsOK(ecode1)) {
30091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
30092 }
30093 arg1 = static_cast< wxEventType >(val1);
30094 }
30095 if (obj1) {
30096 ecode2 = SWIG_AsVal_int(obj1, &val2);
30097 if (!SWIG_IsOK(ecode2)) {
30098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
30099 }
30100 arg2 = static_cast< int >(val2);
30101 }
30102 {
30103 PyThreadState* __tstate = wxPyBeginAllowThreads();
30104 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
30105 wxPyEndAllowThreads(__tstate);
30106 if (PyErr_Occurred()) SWIG_fail;
30107 }
30108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
30109 return resultobj;
30110 fail:
30111 return NULL;
30112 }
30113
30114
30115 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30116 PyObject *obj;
30117 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30118 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
30119 return SWIG_Py_Void();
30120 }
30121
30122 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30123 return SWIG_Python_InitShadowInstance(args);
30124 }
30125
30126 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30127 PyObject *resultobj = 0;
30128 int arg1 = (int) 0 ;
30129 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
30130 wxPyEvent *result = 0 ;
30131 int val1 ;
30132 int ecode1 = 0 ;
30133 int val2 ;
30134 int ecode2 = 0 ;
30135 PyObject * obj0 = 0 ;
30136 PyObject * obj1 = 0 ;
30137 char * kwnames[] = {
30138 (char *) "winid",(char *) "eventType", NULL
30139 };
30140
30141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
30142 if (obj0) {
30143 ecode1 = SWIG_AsVal_int(obj0, &val1);
30144 if (!SWIG_IsOK(ecode1)) {
30145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
30146 }
30147 arg1 = static_cast< int >(val1);
30148 }
30149 if (obj1) {
30150 ecode2 = SWIG_AsVal_int(obj1, &val2);
30151 if (!SWIG_IsOK(ecode2)) {
30152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
30153 }
30154 arg2 = static_cast< wxEventType >(val2);
30155 }
30156 {
30157 PyThreadState* __tstate = wxPyBeginAllowThreads();
30158 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
30159 wxPyEndAllowThreads(__tstate);
30160 if (PyErr_Occurred()) SWIG_fail;
30161 }
30162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
30163 return resultobj;
30164 fail:
30165 return NULL;
30166 }
30167
30168
30169 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30170 PyObject *resultobj = 0;
30171 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
30172 void *argp1 = 0 ;
30173 int res1 = 0 ;
30174 PyObject *swig_obj[1] ;
30175
30176 if (!args) SWIG_fail;
30177 swig_obj[0] = args;
30178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
30179 if (!SWIG_IsOK(res1)) {
30180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
30181 }
30182 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
30183 {
30184 PyThreadState* __tstate = wxPyBeginAllowThreads();
30185 delete arg1;
30186
30187 wxPyEndAllowThreads(__tstate);
30188 if (PyErr_Occurred()) SWIG_fail;
30189 }
30190 resultobj = SWIG_Py_Void();
30191 return resultobj;
30192 fail:
30193 return NULL;
30194 }
30195
30196
30197 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30198 PyObject *resultobj = 0;
30199 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
30200 PyObject *arg2 = (PyObject *) 0 ;
30201 void *argp1 = 0 ;
30202 int res1 = 0 ;
30203 PyObject * obj0 = 0 ;
30204 PyObject * obj1 = 0 ;
30205 char * kwnames[] = {
30206 (char *) "self",(char *) "self", NULL
30207 };
30208
30209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
30210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
30211 if (!SWIG_IsOK(res1)) {
30212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
30213 }
30214 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
30215 arg2 = obj1;
30216 {
30217 PyThreadState* __tstate = wxPyBeginAllowThreads();
30218 (arg1)->SetSelf(arg2);
30219 wxPyEndAllowThreads(__tstate);
30220 if (PyErr_Occurred()) SWIG_fail;
30221 }
30222 resultobj = SWIG_Py_Void();
30223 return resultobj;
30224 fail:
30225 return NULL;
30226 }
30227
30228
30229 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30230 PyObject *resultobj = 0;
30231 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
30232 PyObject *result = 0 ;
30233 void *argp1 = 0 ;
30234 int res1 = 0 ;
30235 PyObject *swig_obj[1] ;
30236
30237 if (!args) SWIG_fail;
30238 swig_obj[0] = args;
30239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
30240 if (!SWIG_IsOK(res1)) {
30241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
30242 }
30243 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
30244 {
30245 PyThreadState* __tstate = wxPyBeginAllowThreads();
30246 result = (PyObject *)(arg1)->GetSelf();
30247 wxPyEndAllowThreads(__tstate);
30248 if (PyErr_Occurred()) SWIG_fail;
30249 }
30250 resultobj = result;
30251 return resultobj;
30252 fail:
30253 return NULL;
30254 }
30255
30256
30257 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30258 PyObject *obj;
30259 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30260 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
30261 return SWIG_Py_Void();
30262 }
30263
30264 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30265 return SWIG_Python_InitShadowInstance(args);
30266 }
30267
30268 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30269 PyObject *resultobj = 0;
30270 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
30271 int arg2 = (int) 0 ;
30272 wxPyCommandEvent *result = 0 ;
30273 int val1 ;
30274 int ecode1 = 0 ;
30275 int val2 ;
30276 int ecode2 = 0 ;
30277 PyObject * obj0 = 0 ;
30278 PyObject * obj1 = 0 ;
30279 char * kwnames[] = {
30280 (char *) "eventType",(char *) "id", NULL
30281 };
30282
30283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
30284 if (obj0) {
30285 ecode1 = SWIG_AsVal_int(obj0, &val1);
30286 if (!SWIG_IsOK(ecode1)) {
30287 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
30288 }
30289 arg1 = static_cast< wxEventType >(val1);
30290 }
30291 if (obj1) {
30292 ecode2 = SWIG_AsVal_int(obj1, &val2);
30293 if (!SWIG_IsOK(ecode2)) {
30294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
30295 }
30296 arg2 = static_cast< int >(val2);
30297 }
30298 {
30299 PyThreadState* __tstate = wxPyBeginAllowThreads();
30300 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
30301 wxPyEndAllowThreads(__tstate);
30302 if (PyErr_Occurred()) SWIG_fail;
30303 }
30304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
30305 return resultobj;
30306 fail:
30307 return NULL;
30308 }
30309
30310
30311 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30312 PyObject *resultobj = 0;
30313 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
30314 void *argp1 = 0 ;
30315 int res1 = 0 ;
30316 PyObject *swig_obj[1] ;
30317
30318 if (!args) SWIG_fail;
30319 swig_obj[0] = args;
30320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
30321 if (!SWIG_IsOK(res1)) {
30322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
30323 }
30324 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
30325 {
30326 PyThreadState* __tstate = wxPyBeginAllowThreads();
30327 delete arg1;
30328
30329 wxPyEndAllowThreads(__tstate);
30330 if (PyErr_Occurred()) SWIG_fail;
30331 }
30332 resultobj = SWIG_Py_Void();
30333 return resultobj;
30334 fail:
30335 return NULL;
30336 }
30337
30338
30339 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30340 PyObject *resultobj = 0;
30341 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
30342 PyObject *arg2 = (PyObject *) 0 ;
30343 void *argp1 = 0 ;
30344 int res1 = 0 ;
30345 PyObject * obj0 = 0 ;
30346 PyObject * obj1 = 0 ;
30347 char * kwnames[] = {
30348 (char *) "self",(char *) "self", NULL
30349 };
30350
30351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
30352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
30353 if (!SWIG_IsOK(res1)) {
30354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
30355 }
30356 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
30357 arg2 = obj1;
30358 {
30359 PyThreadState* __tstate = wxPyBeginAllowThreads();
30360 (arg1)->SetSelf(arg2);
30361 wxPyEndAllowThreads(__tstate);
30362 if (PyErr_Occurred()) SWIG_fail;
30363 }
30364 resultobj = SWIG_Py_Void();
30365 return resultobj;
30366 fail:
30367 return NULL;
30368 }
30369
30370
30371 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30372 PyObject *resultobj = 0;
30373 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
30374 PyObject *result = 0 ;
30375 void *argp1 = 0 ;
30376 int res1 = 0 ;
30377 PyObject *swig_obj[1] ;
30378
30379 if (!args) SWIG_fail;
30380 swig_obj[0] = args;
30381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
30382 if (!SWIG_IsOK(res1)) {
30383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
30384 }
30385 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
30386 {
30387 PyThreadState* __tstate = wxPyBeginAllowThreads();
30388 result = (PyObject *)(arg1)->GetSelf();
30389 wxPyEndAllowThreads(__tstate);
30390 if (PyErr_Occurred()) SWIG_fail;
30391 }
30392 resultobj = result;
30393 return resultobj;
30394 fail:
30395 return NULL;
30396 }
30397
30398
30399 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30400 PyObject *obj;
30401 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30402 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
30403 return SWIG_Py_Void();
30404 }
30405
30406 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30407 return SWIG_Python_InitShadowInstance(args);
30408 }
30409
30410 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30411 PyObject *resultobj = 0;
30412 wxWindow *arg1 = (wxWindow *) 0 ;
30413 wxDateTime *arg2 = 0 ;
30414 wxEventType arg3 ;
30415 wxDateEvent *result = 0 ;
30416 void *argp1 = 0 ;
30417 int res1 = 0 ;
30418 void *argp2 = 0 ;
30419 int res2 = 0 ;
30420 int val3 ;
30421 int ecode3 = 0 ;
30422 PyObject * obj0 = 0 ;
30423 PyObject * obj1 = 0 ;
30424 PyObject * obj2 = 0 ;
30425 char * kwnames[] = {
30426 (char *) "win",(char *) "dt",(char *) "type", NULL
30427 };
30428
30429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30431 if (!SWIG_IsOK(res1)) {
30432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
30433 }
30434 arg1 = reinterpret_cast< wxWindow * >(argp1);
30435 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
30436 if (!SWIG_IsOK(res2)) {
30437 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30438 }
30439 if (!argp2) {
30440 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30441 }
30442 arg2 = reinterpret_cast< wxDateTime * >(argp2);
30443 ecode3 = SWIG_AsVal_int(obj2, &val3);
30444 if (!SWIG_IsOK(ecode3)) {
30445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
30446 }
30447 arg3 = static_cast< wxEventType >(val3);
30448 {
30449 PyThreadState* __tstate = wxPyBeginAllowThreads();
30450 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
30451 wxPyEndAllowThreads(__tstate);
30452 if (PyErr_Occurred()) SWIG_fail;
30453 }
30454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
30455 return resultobj;
30456 fail:
30457 return NULL;
30458 }
30459
30460
30461 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30462 PyObject *resultobj = 0;
30463 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
30464 wxDateTime *result = 0 ;
30465 void *argp1 = 0 ;
30466 int res1 = 0 ;
30467 PyObject *swig_obj[1] ;
30468
30469 if (!args) SWIG_fail;
30470 swig_obj[0] = args;
30471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
30472 if (!SWIG_IsOK(res1)) {
30473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
30474 }
30475 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
30476 {
30477 PyThreadState* __tstate = wxPyBeginAllowThreads();
30478 {
30479 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
30480 result = (wxDateTime *) &_result_ref;
30481 }
30482 wxPyEndAllowThreads(__tstate);
30483 if (PyErr_Occurred()) SWIG_fail;
30484 }
30485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
30486 return resultobj;
30487 fail:
30488 return NULL;
30489 }
30490
30491
30492 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30493 PyObject *resultobj = 0;
30494 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
30495 wxDateTime *arg2 = 0 ;
30496 void *argp1 = 0 ;
30497 int res1 = 0 ;
30498 void *argp2 = 0 ;
30499 int res2 = 0 ;
30500 PyObject * obj0 = 0 ;
30501 PyObject * obj1 = 0 ;
30502 char * kwnames[] = {
30503 (char *) "self",(char *) "date", NULL
30504 };
30505
30506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
30507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
30508 if (!SWIG_IsOK(res1)) {
30509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
30510 }
30511 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
30512 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
30513 if (!SWIG_IsOK(res2)) {
30514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30515 }
30516 if (!argp2) {
30517 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30518 }
30519 arg2 = reinterpret_cast< wxDateTime * >(argp2);
30520 {
30521 PyThreadState* __tstate = wxPyBeginAllowThreads();
30522 (arg1)->SetDate((wxDateTime const &)*arg2);
30523 wxPyEndAllowThreads(__tstate);
30524 if (PyErr_Occurred()) SWIG_fail;
30525 }
30526 resultobj = SWIG_Py_Void();
30527 return resultobj;
30528 fail:
30529 return NULL;
30530 }
30531
30532
30533 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30534 PyObject *obj;
30535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30536 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
30537 return SWIG_Py_Void();
30538 }
30539
30540 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30541 return SWIG_Python_InitShadowInstance(args);
30542 }
30543
30544 SWIGINTERN PyObject *_wrap_new_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30545 PyObject *resultobj = 0;
30546 wxWindow *arg1 = (wxWindow *) 0 ;
30547 wxEventType arg2 = (wxEventType) wxEVT_ANY ;
30548 wxEventBlocker *result = 0 ;
30549 void *argp1 = 0 ;
30550 int res1 = 0 ;
30551 int val2 ;
30552 int ecode2 = 0 ;
30553 PyObject * obj0 = 0 ;
30554 PyObject * obj1 = 0 ;
30555 char * kwnames[] = {
30556 (char *) "win",(char *) "type", NULL
30557 };
30558
30559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_EventBlocker",kwnames,&obj0,&obj1)) SWIG_fail;
30560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30561 if (!SWIG_IsOK(res1)) {
30562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventBlocker" "', expected argument " "1"" of type '" "wxWindow *""'");
30563 }
30564 arg1 = reinterpret_cast< wxWindow * >(argp1);
30565 if (obj1) {
30566 ecode2 = SWIG_AsVal_int(obj1, &val2);
30567 if (!SWIG_IsOK(ecode2)) {
30568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EventBlocker" "', expected argument " "2"" of type '" "wxEventType""'");
30569 }
30570 arg2 = static_cast< wxEventType >(val2);
30571 }
30572 {
30573 PyThreadState* __tstate = wxPyBeginAllowThreads();
30574 result = (wxEventBlocker *)new wxEventBlocker(arg1,arg2);
30575 wxPyEndAllowThreads(__tstate);
30576 if (PyErr_Occurred()) SWIG_fail;
30577 }
30578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_NEW | 0 );
30579 return resultobj;
30580 fail:
30581 return NULL;
30582 }
30583
30584
30585 SWIGINTERN PyObject *_wrap_delete_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30586 PyObject *resultobj = 0;
30587 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30588 void *argp1 = 0 ;
30589 int res1 = 0 ;
30590 PyObject *swig_obj[1] ;
30591
30592 if (!args) SWIG_fail;
30593 swig_obj[0] = args;
30594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_DISOWN | 0 );
30595 if (!SWIG_IsOK(res1)) {
30596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventBlocker" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30597 }
30598 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30599 {
30600 PyThreadState* __tstate = wxPyBeginAllowThreads();
30601 delete arg1;
30602
30603 wxPyEndAllowThreads(__tstate);
30604 if (PyErr_Occurred()) SWIG_fail;
30605 }
30606 resultobj = SWIG_Py_Void();
30607 return resultobj;
30608 fail:
30609 return NULL;
30610 }
30611
30612
30613 SWIGINTERN PyObject *_wrap_EventBlocker_Block(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30614 PyObject *resultobj = 0;
30615 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30616 wxEventType arg2 ;
30617 void *argp1 = 0 ;
30618 int res1 = 0 ;
30619 int val2 ;
30620 int ecode2 = 0 ;
30621 PyObject * obj0 = 0 ;
30622 PyObject * obj1 = 0 ;
30623 char * kwnames[] = {
30624 (char *) "self",(char *) "type", NULL
30625 };
30626
30627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EventBlocker_Block",kwnames,&obj0,&obj1)) SWIG_fail;
30628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventBlocker, 0 | 0 );
30629 if (!SWIG_IsOK(res1)) {
30630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventBlocker_Block" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30631 }
30632 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30633 ecode2 = SWIG_AsVal_int(obj1, &val2);
30634 if (!SWIG_IsOK(ecode2)) {
30635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventBlocker_Block" "', expected argument " "2"" of type '" "wxEventType""'");
30636 }
30637 arg2 = static_cast< wxEventType >(val2);
30638 {
30639 PyThreadState* __tstate = wxPyBeginAllowThreads();
30640 (arg1)->Block(arg2);
30641 wxPyEndAllowThreads(__tstate);
30642 if (PyErr_Occurred()) SWIG_fail;
30643 }
30644 resultobj = SWIG_Py_Void();
30645 return resultobj;
30646 fail:
30647 return NULL;
30648 }
30649
30650
30651 SWIGINTERN PyObject *EventBlocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30652 PyObject *obj;
30653 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30654 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventBlocker, SWIG_NewClientData(obj));
30655 return SWIG_Py_Void();
30656 }
30657
30658 SWIGINTERN PyObject *EventBlocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30659 return SWIG_Python_InitShadowInstance(args);
30660 }
30661
30662 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30663 PyObject *resultobj = 0;
30664 wxPyApp *result = 0 ;
30665
30666 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
30667 {
30668 PyThreadState* __tstate = wxPyBeginAllowThreads();
30669 result = (wxPyApp *)new_wxPyApp();
30670 wxPyEndAllowThreads(__tstate);
30671 if (PyErr_Occurred()) SWIG_fail;
30672 }
30673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
30674 return resultobj;
30675 fail:
30676 return NULL;
30677 }
30678
30679
30680 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30681 PyObject *resultobj = 0;
30682 wxPyApp *arg1 = (wxPyApp *) 0 ;
30683 void *argp1 = 0 ;
30684 int res1 = 0 ;
30685 PyObject *swig_obj[1] ;
30686
30687 if (!args) SWIG_fail;
30688 swig_obj[0] = args;
30689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30690 if (!SWIG_IsOK(res1)) {
30691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30692 }
30693 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30694 {
30695 PyThreadState* __tstate = wxPyBeginAllowThreads();
30696 delete arg1;
30697
30698 wxPyEndAllowThreads(__tstate);
30699 if (PyErr_Occurred()) SWIG_fail;
30700 }
30701 resultobj = SWIG_Py_Void();
30702 return resultobj;
30703 fail:
30704 return NULL;
30705 }
30706
30707
30708 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30709 PyObject *resultobj = 0;
30710 wxPyApp *arg1 = (wxPyApp *) 0 ;
30711 PyObject *arg2 = (PyObject *) 0 ;
30712 PyObject *arg3 = (PyObject *) 0 ;
30713 bool arg4 = (bool) false ;
30714 void *argp1 = 0 ;
30715 int res1 = 0 ;
30716 bool val4 ;
30717 int ecode4 = 0 ;
30718 PyObject * obj0 = 0 ;
30719 PyObject * obj1 = 0 ;
30720 PyObject * obj2 = 0 ;
30721 PyObject * obj3 = 0 ;
30722 char * kwnames[] = {
30723 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30724 };
30725
30726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30728 if (!SWIG_IsOK(res1)) {
30729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30730 }
30731 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30732 arg2 = obj1;
30733 arg3 = obj2;
30734 if (obj3) {
30735 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30736 if (!SWIG_IsOK(ecode4)) {
30737 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30738 }
30739 arg4 = static_cast< bool >(val4);
30740 }
30741 {
30742 PyThreadState* __tstate = wxPyBeginAllowThreads();
30743 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30744 wxPyEndAllowThreads(__tstate);
30745 if (PyErr_Occurred()) SWIG_fail;
30746 }
30747 resultobj = SWIG_Py_Void();
30748 return resultobj;
30749 fail:
30750 return NULL;
30751 }
30752
30753
30754 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30755 PyObject *resultobj = 0;
30756 wxPyApp *arg1 = (wxPyApp *) 0 ;
30757 wxString result;
30758 void *argp1 = 0 ;
30759 int res1 = 0 ;
30760 PyObject *swig_obj[1] ;
30761
30762 if (!args) SWIG_fail;
30763 swig_obj[0] = args;
30764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30765 if (!SWIG_IsOK(res1)) {
30766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30767 }
30768 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30769 {
30770 PyThreadState* __tstate = wxPyBeginAllowThreads();
30771 result = ((wxPyApp const *)arg1)->GetAppName();
30772 wxPyEndAllowThreads(__tstate);
30773 if (PyErr_Occurred()) SWIG_fail;
30774 }
30775 {
30776 #if wxUSE_UNICODE
30777 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30778 #else
30779 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30780 #endif
30781 }
30782 return resultobj;
30783 fail:
30784 return NULL;
30785 }
30786
30787
30788 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30789 PyObject *resultobj = 0;
30790 wxPyApp *arg1 = (wxPyApp *) 0 ;
30791 wxString *arg2 = 0 ;
30792 void *argp1 = 0 ;
30793 int res1 = 0 ;
30794 bool temp2 = false ;
30795 PyObject * obj0 = 0 ;
30796 PyObject * obj1 = 0 ;
30797 char * kwnames[] = {
30798 (char *) "self",(char *) "name", NULL
30799 };
30800
30801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30803 if (!SWIG_IsOK(res1)) {
30804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30805 }
30806 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30807 {
30808 arg2 = wxString_in_helper(obj1);
30809 if (arg2 == NULL) SWIG_fail;
30810 temp2 = true;
30811 }
30812 {
30813 PyThreadState* __tstate = wxPyBeginAllowThreads();
30814 (arg1)->SetAppName((wxString const &)*arg2);
30815 wxPyEndAllowThreads(__tstate);
30816 if (PyErr_Occurred()) SWIG_fail;
30817 }
30818 resultobj = SWIG_Py_Void();
30819 {
30820 if (temp2)
30821 delete arg2;
30822 }
30823 return resultobj;
30824 fail:
30825 {
30826 if (temp2)
30827 delete arg2;
30828 }
30829 return NULL;
30830 }
30831
30832
30833 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30834 PyObject *resultobj = 0;
30835 wxPyApp *arg1 = (wxPyApp *) 0 ;
30836 wxString result;
30837 void *argp1 = 0 ;
30838 int res1 = 0 ;
30839 PyObject *swig_obj[1] ;
30840
30841 if (!args) SWIG_fail;
30842 swig_obj[0] = args;
30843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30844 if (!SWIG_IsOK(res1)) {
30845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30846 }
30847 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30848 {
30849 PyThreadState* __tstate = wxPyBeginAllowThreads();
30850 result = ((wxPyApp const *)arg1)->GetClassName();
30851 wxPyEndAllowThreads(__tstate);
30852 if (PyErr_Occurred()) SWIG_fail;
30853 }
30854 {
30855 #if wxUSE_UNICODE
30856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30857 #else
30858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30859 #endif
30860 }
30861 return resultobj;
30862 fail:
30863 return NULL;
30864 }
30865
30866
30867 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30868 PyObject *resultobj = 0;
30869 wxPyApp *arg1 = (wxPyApp *) 0 ;
30870 wxString *arg2 = 0 ;
30871 void *argp1 = 0 ;
30872 int res1 = 0 ;
30873 bool temp2 = false ;
30874 PyObject * obj0 = 0 ;
30875 PyObject * obj1 = 0 ;
30876 char * kwnames[] = {
30877 (char *) "self",(char *) "name", NULL
30878 };
30879
30880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30882 if (!SWIG_IsOK(res1)) {
30883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30884 }
30885 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30886 {
30887 arg2 = wxString_in_helper(obj1);
30888 if (arg2 == NULL) SWIG_fail;
30889 temp2 = true;
30890 }
30891 {
30892 PyThreadState* __tstate = wxPyBeginAllowThreads();
30893 (arg1)->SetClassName((wxString const &)*arg2);
30894 wxPyEndAllowThreads(__tstate);
30895 if (PyErr_Occurred()) SWIG_fail;
30896 }
30897 resultobj = SWIG_Py_Void();
30898 {
30899 if (temp2)
30900 delete arg2;
30901 }
30902 return resultobj;
30903 fail:
30904 {
30905 if (temp2)
30906 delete arg2;
30907 }
30908 return NULL;
30909 }
30910
30911
30912 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30913 PyObject *resultobj = 0;
30914 wxPyApp *arg1 = (wxPyApp *) 0 ;
30915 wxString *result = 0 ;
30916 void *argp1 = 0 ;
30917 int res1 = 0 ;
30918 PyObject *swig_obj[1] ;
30919
30920 if (!args) SWIG_fail;
30921 swig_obj[0] = args;
30922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30923 if (!SWIG_IsOK(res1)) {
30924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30925 }
30926 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30927 {
30928 PyThreadState* __tstate = wxPyBeginAllowThreads();
30929 {
30930 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30931 result = (wxString *) &_result_ref;
30932 }
30933 wxPyEndAllowThreads(__tstate);
30934 if (PyErr_Occurred()) SWIG_fail;
30935 }
30936 {
30937 #if wxUSE_UNICODE
30938 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30939 #else
30940 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30941 #endif
30942 }
30943 return resultobj;
30944 fail:
30945 return NULL;
30946 }
30947
30948
30949 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30950 PyObject *resultobj = 0;
30951 wxPyApp *arg1 = (wxPyApp *) 0 ;
30952 wxString *arg2 = 0 ;
30953 void *argp1 = 0 ;
30954 int res1 = 0 ;
30955 bool temp2 = false ;
30956 PyObject * obj0 = 0 ;
30957 PyObject * obj1 = 0 ;
30958 char * kwnames[] = {
30959 (char *) "self",(char *) "name", NULL
30960 };
30961
30962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30964 if (!SWIG_IsOK(res1)) {
30965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30966 }
30967 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30968 {
30969 arg2 = wxString_in_helper(obj1);
30970 if (arg2 == NULL) SWIG_fail;
30971 temp2 = true;
30972 }
30973 {
30974 PyThreadState* __tstate = wxPyBeginAllowThreads();
30975 (arg1)->SetVendorName((wxString const &)*arg2);
30976 wxPyEndAllowThreads(__tstate);
30977 if (PyErr_Occurred()) SWIG_fail;
30978 }
30979 resultobj = SWIG_Py_Void();
30980 {
30981 if (temp2)
30982 delete arg2;
30983 }
30984 return resultobj;
30985 fail:
30986 {
30987 if (temp2)
30988 delete arg2;
30989 }
30990 return NULL;
30991 }
30992
30993
30994 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30995 PyObject *resultobj = 0;
30996 wxPyApp *arg1 = (wxPyApp *) 0 ;
30997 wxAppTraits *result = 0 ;
30998 void *argp1 = 0 ;
30999 int res1 = 0 ;
31000 PyObject *swig_obj[1] ;
31001
31002 if (!args) SWIG_fail;
31003 swig_obj[0] = args;
31004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31005 if (!SWIG_IsOK(res1)) {
31006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
31007 }
31008 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31009 {
31010 PyThreadState* __tstate = wxPyBeginAllowThreads();
31011 result = (wxAppTraits *)(arg1)->GetTraits();
31012 wxPyEndAllowThreads(__tstate);
31013 if (PyErr_Occurred()) SWIG_fail;
31014 }
31015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
31016 return resultobj;
31017 fail:
31018 return NULL;
31019 }
31020
31021
31022 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31023 PyObject *resultobj = 0;
31024 wxPyApp *arg1 = (wxPyApp *) 0 ;
31025 void *argp1 = 0 ;
31026 int res1 = 0 ;
31027 PyObject *swig_obj[1] ;
31028
31029 if (!args) SWIG_fail;
31030 swig_obj[0] = args;
31031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31032 if (!SWIG_IsOK(res1)) {
31033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
31034 }
31035 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31036 {
31037 PyThreadState* __tstate = wxPyBeginAllowThreads();
31038 (arg1)->ProcessPendingEvents();
31039 wxPyEndAllowThreads(__tstate);
31040 if (PyErr_Occurred()) SWIG_fail;
31041 }
31042 resultobj = SWIG_Py_Void();
31043 return resultobj;
31044 fail:
31045 return NULL;
31046 }
31047
31048
31049 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31050 PyObject *resultobj = 0;
31051 wxPyApp *arg1 = (wxPyApp *) 0 ;
31052 bool arg2 = (bool) false ;
31053 bool result;
31054 void *argp1 = 0 ;
31055 int res1 = 0 ;
31056 bool val2 ;
31057 int ecode2 = 0 ;
31058 PyObject * obj0 = 0 ;
31059 PyObject * obj1 = 0 ;
31060 char * kwnames[] = {
31061 (char *) "self",(char *) "onlyIfNeeded", NULL
31062 };
31063
31064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
31065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31066 if (!SWIG_IsOK(res1)) {
31067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
31068 }
31069 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31070 if (obj1) {
31071 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31072 if (!SWIG_IsOK(ecode2)) {
31073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
31074 }
31075 arg2 = static_cast< bool >(val2);
31076 }
31077 {
31078 PyThreadState* __tstate = wxPyBeginAllowThreads();
31079 result = (bool)(arg1)->Yield(arg2);
31080 wxPyEndAllowThreads(__tstate);
31081 if (PyErr_Occurred()) SWIG_fail;
31082 }
31083 {
31084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31085 }
31086 return resultobj;
31087 fail:
31088 return NULL;
31089 }
31090
31091
31092 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31093 PyObject *resultobj = 0;
31094 wxPyApp *arg1 = (wxPyApp *) 0 ;
31095 void *argp1 = 0 ;
31096 int res1 = 0 ;
31097 PyObject *swig_obj[1] ;
31098
31099 if (!args) SWIG_fail;
31100 swig_obj[0] = args;
31101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31102 if (!SWIG_IsOK(res1)) {
31103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
31104 }
31105 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31106 {
31107 PyThreadState* __tstate = wxPyBeginAllowThreads();
31108 (arg1)->WakeUpIdle();
31109 wxPyEndAllowThreads(__tstate);
31110 if (PyErr_Occurred()) SWIG_fail;
31111 }
31112 resultobj = SWIG_Py_Void();
31113 return resultobj;
31114 fail:
31115 return NULL;
31116 }
31117
31118
31119 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31120 PyObject *resultobj = 0;
31121 bool result;
31122
31123 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
31124 {
31125 PyThreadState* __tstate = wxPyBeginAllowThreads();
31126 result = (bool)wxPyApp::IsMainLoopRunning();
31127 wxPyEndAllowThreads(__tstate);
31128 if (PyErr_Occurred()) SWIG_fail;
31129 }
31130 {
31131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31132 }
31133 return resultobj;
31134 fail:
31135 return NULL;
31136 }
31137
31138
31139 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31140 PyObject *resultobj = 0;
31141 wxPyApp *arg1 = (wxPyApp *) 0 ;
31142 int result;
31143 void *argp1 = 0 ;
31144 int res1 = 0 ;
31145 PyObject *swig_obj[1] ;
31146
31147 if (!args) SWIG_fail;
31148 swig_obj[0] = args;
31149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31150 if (!SWIG_IsOK(res1)) {
31151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
31152 }
31153 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31154 {
31155 PyThreadState* __tstate = wxPyBeginAllowThreads();
31156 result = (int)(arg1)->MainLoop();
31157 wxPyEndAllowThreads(__tstate);
31158 if (PyErr_Occurred()) SWIG_fail;
31159 }
31160 resultobj = SWIG_From_int(static_cast< int >(result));
31161 return resultobj;
31162 fail:
31163 return NULL;
31164 }
31165
31166
31167 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31168 PyObject *resultobj = 0;
31169 wxPyApp *arg1 = (wxPyApp *) 0 ;
31170 void *argp1 = 0 ;
31171 int res1 = 0 ;
31172 PyObject *swig_obj[1] ;
31173
31174 if (!args) SWIG_fail;
31175 swig_obj[0] = args;
31176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31177 if (!SWIG_IsOK(res1)) {
31178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
31179 }
31180 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31181 {
31182 PyThreadState* __tstate = wxPyBeginAllowThreads();
31183 (arg1)->Exit();
31184 wxPyEndAllowThreads(__tstate);
31185 if (PyErr_Occurred()) SWIG_fail;
31186 }
31187 resultobj = SWIG_Py_Void();
31188 return resultobj;
31189 fail:
31190 return NULL;
31191 }
31192
31193
31194 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31195 PyObject *resultobj = 0;
31196 wxPyApp *arg1 = (wxPyApp *) 0 ;
31197 wxLayoutDirection result;
31198 void *argp1 = 0 ;
31199 int res1 = 0 ;
31200 PyObject *swig_obj[1] ;
31201
31202 if (!args) SWIG_fail;
31203 swig_obj[0] = args;
31204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31205 if (!SWIG_IsOK(res1)) {
31206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31207 }
31208 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31209 {
31210 PyThreadState* __tstate = wxPyBeginAllowThreads();
31211 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
31212 wxPyEndAllowThreads(__tstate);
31213 if (PyErr_Occurred()) SWIG_fail;
31214 }
31215 resultobj = SWIG_From_int(static_cast< int >(result));
31216 return resultobj;
31217 fail:
31218 return NULL;
31219 }
31220
31221
31222 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31223 PyObject *resultobj = 0;
31224 wxPyApp *arg1 = (wxPyApp *) 0 ;
31225 void *argp1 = 0 ;
31226 int res1 = 0 ;
31227 PyObject *swig_obj[1] ;
31228
31229 if (!args) SWIG_fail;
31230 swig_obj[0] = args;
31231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31232 if (!SWIG_IsOK(res1)) {
31233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
31234 }
31235 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31236 {
31237 PyThreadState* __tstate = wxPyBeginAllowThreads();
31238 (arg1)->ExitMainLoop();
31239 wxPyEndAllowThreads(__tstate);
31240 if (PyErr_Occurred()) SWIG_fail;
31241 }
31242 resultobj = SWIG_Py_Void();
31243 return resultobj;
31244 fail:
31245 return NULL;
31246 }
31247
31248
31249 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31250 PyObject *resultobj = 0;
31251 wxPyApp *arg1 = (wxPyApp *) 0 ;
31252 bool result;
31253 void *argp1 = 0 ;
31254 int res1 = 0 ;
31255 PyObject *swig_obj[1] ;
31256
31257 if (!args) SWIG_fail;
31258 swig_obj[0] = args;
31259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31260 if (!SWIG_IsOK(res1)) {
31261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
31262 }
31263 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31264 {
31265 PyThreadState* __tstate = wxPyBeginAllowThreads();
31266 result = (bool)(arg1)->Pending();
31267 wxPyEndAllowThreads(__tstate);
31268 if (PyErr_Occurred()) SWIG_fail;
31269 }
31270 {
31271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31272 }
31273 return resultobj;
31274 fail:
31275 return NULL;
31276 }
31277
31278
31279 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31280 PyObject *resultobj = 0;
31281 wxPyApp *arg1 = (wxPyApp *) 0 ;
31282 bool result;
31283 void *argp1 = 0 ;
31284 int res1 = 0 ;
31285 PyObject *swig_obj[1] ;
31286
31287 if (!args) SWIG_fail;
31288 swig_obj[0] = args;
31289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31290 if (!SWIG_IsOK(res1)) {
31291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
31292 }
31293 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31294 {
31295 PyThreadState* __tstate = wxPyBeginAllowThreads();
31296 result = (bool)(arg1)->Dispatch();
31297 wxPyEndAllowThreads(__tstate);
31298 if (PyErr_Occurred()) SWIG_fail;
31299 }
31300 {
31301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31302 }
31303 return resultobj;
31304 fail:
31305 return NULL;
31306 }
31307
31308
31309 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31310 PyObject *resultobj = 0;
31311 wxPyApp *arg1 = (wxPyApp *) 0 ;
31312 bool result;
31313 void *argp1 = 0 ;
31314 int res1 = 0 ;
31315 PyObject *swig_obj[1] ;
31316
31317 if (!args) SWIG_fail;
31318 swig_obj[0] = args;
31319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31320 if (!SWIG_IsOK(res1)) {
31321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
31322 }
31323 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31324 {
31325 PyThreadState* __tstate = wxPyBeginAllowThreads();
31326 result = (bool)(arg1)->ProcessIdle();
31327 wxPyEndAllowThreads(__tstate);
31328 if (PyErr_Occurred()) SWIG_fail;
31329 }
31330 {
31331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31332 }
31333 return resultobj;
31334 fail:
31335 return NULL;
31336 }
31337
31338
31339 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31340 PyObject *resultobj = 0;
31341 wxPyApp *arg1 = (wxPyApp *) 0 ;
31342 wxWindow *arg2 = (wxWindow *) 0 ;
31343 wxIdleEvent *arg3 = 0 ;
31344 bool result;
31345 void *argp1 = 0 ;
31346 int res1 = 0 ;
31347 void *argp2 = 0 ;
31348 int res2 = 0 ;
31349 void *argp3 = 0 ;
31350 int res3 = 0 ;
31351 PyObject * obj0 = 0 ;
31352 PyObject * obj1 = 0 ;
31353 PyObject * obj2 = 0 ;
31354 char * kwnames[] = {
31355 (char *) "self",(char *) "win",(char *) "event", NULL
31356 };
31357
31358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31360 if (!SWIG_IsOK(res1)) {
31361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
31362 }
31363 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31364 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
31365 if (!SWIG_IsOK(res2)) {
31366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
31367 }
31368 arg2 = reinterpret_cast< wxWindow * >(argp2);
31369 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
31370 if (!SWIG_IsOK(res3)) {
31371 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
31372 }
31373 if (!argp3) {
31374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
31375 }
31376 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
31377 {
31378 PyThreadState* __tstate = wxPyBeginAllowThreads();
31379 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
31380 wxPyEndAllowThreads(__tstate);
31381 if (PyErr_Occurred()) SWIG_fail;
31382 }
31383 {
31384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31385 }
31386 return resultobj;
31387 fail:
31388 return NULL;
31389 }
31390
31391
31392 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31393 PyObject *resultobj = 0;
31394 wxPyApp *arg1 = (wxPyApp *) 0 ;
31395 bool result;
31396 void *argp1 = 0 ;
31397 int res1 = 0 ;
31398 PyObject *swig_obj[1] ;
31399
31400 if (!args) SWIG_fail;
31401 swig_obj[0] = args;
31402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31403 if (!SWIG_IsOK(res1)) {
31404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31405 }
31406 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31407 {
31408 PyThreadState* __tstate = wxPyBeginAllowThreads();
31409 result = (bool)((wxPyApp const *)arg1)->IsActive();
31410 wxPyEndAllowThreads(__tstate);
31411 if (PyErr_Occurred()) SWIG_fail;
31412 }
31413 {
31414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31415 }
31416 return resultobj;
31417 fail:
31418 return NULL;
31419 }
31420
31421
31422 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31423 PyObject *resultobj = 0;
31424 wxPyApp *arg1 = (wxPyApp *) 0 ;
31425 wxWindow *arg2 = (wxWindow *) 0 ;
31426 void *argp1 = 0 ;
31427 int res1 = 0 ;
31428 void *argp2 = 0 ;
31429 int res2 = 0 ;
31430 PyObject * obj0 = 0 ;
31431 PyObject * obj1 = 0 ;
31432 char * kwnames[] = {
31433 (char *) "self",(char *) "win", NULL
31434 };
31435
31436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
31437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31438 if (!SWIG_IsOK(res1)) {
31439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
31440 }
31441 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31442 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
31443 if (!SWIG_IsOK(res2)) {
31444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
31445 }
31446 arg2 = reinterpret_cast< wxWindow * >(argp2);
31447 {
31448 PyThreadState* __tstate = wxPyBeginAllowThreads();
31449 (arg1)->SetTopWindow(arg2);
31450 wxPyEndAllowThreads(__tstate);
31451 if (PyErr_Occurred()) SWIG_fail;
31452 }
31453 resultobj = SWIG_Py_Void();
31454 return resultobj;
31455 fail:
31456 return NULL;
31457 }
31458
31459
31460 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31461 PyObject *resultobj = 0;
31462 wxPyApp *arg1 = (wxPyApp *) 0 ;
31463 wxWindow *result = 0 ;
31464 void *argp1 = 0 ;
31465 int res1 = 0 ;
31466 PyObject *swig_obj[1] ;
31467
31468 if (!args) SWIG_fail;
31469 swig_obj[0] = args;
31470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31471 if (!SWIG_IsOK(res1)) {
31472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31473 }
31474 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31475 {
31476 PyThreadState* __tstate = wxPyBeginAllowThreads();
31477 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
31478 wxPyEndAllowThreads(__tstate);
31479 if (PyErr_Occurred()) SWIG_fail;
31480 }
31481 {
31482 resultobj = wxPyMake_wxObject(result, (bool)0);
31483 }
31484 return resultobj;
31485 fail:
31486 return NULL;
31487 }
31488
31489
31490 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31491 PyObject *resultobj = 0;
31492 wxPyApp *arg1 = (wxPyApp *) 0 ;
31493 bool arg2 ;
31494 void *argp1 = 0 ;
31495 int res1 = 0 ;
31496 bool val2 ;
31497 int ecode2 = 0 ;
31498 PyObject * obj0 = 0 ;
31499 PyObject * obj1 = 0 ;
31500 char * kwnames[] = {
31501 (char *) "self",(char *) "flag", NULL
31502 };
31503
31504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
31505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31506 if (!SWIG_IsOK(res1)) {
31507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
31508 }
31509 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31510 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31511 if (!SWIG_IsOK(ecode2)) {
31512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
31513 }
31514 arg2 = static_cast< bool >(val2);
31515 {
31516 PyThreadState* __tstate = wxPyBeginAllowThreads();
31517 (arg1)->SetExitOnFrameDelete(arg2);
31518 wxPyEndAllowThreads(__tstate);
31519 if (PyErr_Occurred()) SWIG_fail;
31520 }
31521 resultobj = SWIG_Py_Void();
31522 return resultobj;
31523 fail:
31524 return NULL;
31525 }
31526
31527
31528 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31529 PyObject *resultobj = 0;
31530 wxPyApp *arg1 = (wxPyApp *) 0 ;
31531 bool result;
31532 void *argp1 = 0 ;
31533 int res1 = 0 ;
31534 PyObject *swig_obj[1] ;
31535
31536 if (!args) SWIG_fail;
31537 swig_obj[0] = args;
31538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31539 if (!SWIG_IsOK(res1)) {
31540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31541 }
31542 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31543 {
31544 PyThreadState* __tstate = wxPyBeginAllowThreads();
31545 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
31546 wxPyEndAllowThreads(__tstate);
31547 if (PyErr_Occurred()) SWIG_fail;
31548 }
31549 {
31550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31551 }
31552 return resultobj;
31553 fail:
31554 return NULL;
31555 }
31556
31557
31558 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31559 PyObject *resultobj = 0;
31560 wxPyApp *arg1 = (wxPyApp *) 0 ;
31561 bool arg2 ;
31562 bool arg3 = (bool) false ;
31563 void *argp1 = 0 ;
31564 int res1 = 0 ;
31565 bool val2 ;
31566 int ecode2 = 0 ;
31567 bool val3 ;
31568 int ecode3 = 0 ;
31569 PyObject * obj0 = 0 ;
31570 PyObject * obj1 = 0 ;
31571 PyObject * obj2 = 0 ;
31572 char * kwnames[] = {
31573 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
31574 };
31575
31576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31578 if (!SWIG_IsOK(res1)) {
31579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
31580 }
31581 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31582 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31583 if (!SWIG_IsOK(ecode2)) {
31584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
31585 }
31586 arg2 = static_cast< bool >(val2);
31587 if (obj2) {
31588 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31589 if (!SWIG_IsOK(ecode3)) {
31590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
31591 }
31592 arg3 = static_cast< bool >(val3);
31593 }
31594 {
31595 PyThreadState* __tstate = wxPyBeginAllowThreads();
31596 (arg1)->SetUseBestVisual(arg2,arg3);
31597 wxPyEndAllowThreads(__tstate);
31598 if (PyErr_Occurred()) SWIG_fail;
31599 }
31600 resultobj = SWIG_Py_Void();
31601 return resultobj;
31602 fail:
31603 return NULL;
31604 }
31605
31606
31607 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31608 PyObject *resultobj = 0;
31609 wxPyApp *arg1 = (wxPyApp *) 0 ;
31610 bool result;
31611 void *argp1 = 0 ;
31612 int res1 = 0 ;
31613 PyObject *swig_obj[1] ;
31614
31615 if (!args) SWIG_fail;
31616 swig_obj[0] = args;
31617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31618 if (!SWIG_IsOK(res1)) {
31619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31620 }
31621 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31622 {
31623 PyThreadState* __tstate = wxPyBeginAllowThreads();
31624 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
31625 wxPyEndAllowThreads(__tstate);
31626 if (PyErr_Occurred()) SWIG_fail;
31627 }
31628 {
31629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31630 }
31631 return resultobj;
31632 fail:
31633 return NULL;
31634 }
31635
31636
31637 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31638 PyObject *resultobj = 0;
31639 wxPyApp *arg1 = (wxPyApp *) 0 ;
31640 int arg2 ;
31641 void *argp1 = 0 ;
31642 int res1 = 0 ;
31643 int val2 ;
31644 int ecode2 = 0 ;
31645 PyObject * obj0 = 0 ;
31646 PyObject * obj1 = 0 ;
31647 char * kwnames[] = {
31648 (char *) "self",(char *) "mode", NULL
31649 };
31650
31651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
31652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31653 if (!SWIG_IsOK(res1)) {
31654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31655 }
31656 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31657 ecode2 = SWIG_AsVal_int(obj1, &val2);
31658 if (!SWIG_IsOK(ecode2)) {
31659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
31660 }
31661 arg2 = static_cast< int >(val2);
31662 {
31663 PyThreadState* __tstate = wxPyBeginAllowThreads();
31664 (arg1)->SetPrintMode(arg2);
31665 wxPyEndAllowThreads(__tstate);
31666 if (PyErr_Occurred()) SWIG_fail;
31667 }
31668 resultobj = SWIG_Py_Void();
31669 return resultobj;
31670 fail:
31671 return NULL;
31672 }
31673
31674
31675 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31676 PyObject *resultobj = 0;
31677 wxPyApp *arg1 = (wxPyApp *) 0 ;
31678 int result;
31679 void *argp1 = 0 ;
31680 int res1 = 0 ;
31681 PyObject *swig_obj[1] ;
31682
31683 if (!args) SWIG_fail;
31684 swig_obj[0] = args;
31685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31686 if (!SWIG_IsOK(res1)) {
31687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31688 }
31689 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31690 {
31691 PyThreadState* __tstate = wxPyBeginAllowThreads();
31692 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
31693 wxPyEndAllowThreads(__tstate);
31694 if (PyErr_Occurred()) SWIG_fail;
31695 }
31696 resultobj = SWIG_From_int(static_cast< int >(result));
31697 return resultobj;
31698 fail:
31699 return NULL;
31700 }
31701
31702
31703 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31704 PyObject *resultobj = 0;
31705 wxPyApp *arg1 = (wxPyApp *) 0 ;
31706 int arg2 ;
31707 void *argp1 = 0 ;
31708 int res1 = 0 ;
31709 int val2 ;
31710 int ecode2 = 0 ;
31711 PyObject * obj0 = 0 ;
31712 PyObject * obj1 = 0 ;
31713 char * kwnames[] = {
31714 (char *) "self",(char *) "mode", NULL
31715 };
31716
31717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31719 if (!SWIG_IsOK(res1)) {
31720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31721 }
31722 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31723 ecode2 = SWIG_AsVal_int(obj1, &val2);
31724 if (!SWIG_IsOK(ecode2)) {
31725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31726 }
31727 arg2 = static_cast< int >(val2);
31728 {
31729 PyThreadState* __tstate = wxPyBeginAllowThreads();
31730 (arg1)->SetAssertMode(arg2);
31731 wxPyEndAllowThreads(__tstate);
31732 if (PyErr_Occurred()) SWIG_fail;
31733 }
31734 resultobj = SWIG_Py_Void();
31735 return resultobj;
31736 fail:
31737 return NULL;
31738 }
31739
31740
31741 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31742 PyObject *resultobj = 0;
31743 wxPyApp *arg1 = (wxPyApp *) 0 ;
31744 int result;
31745 void *argp1 = 0 ;
31746 int res1 = 0 ;
31747 PyObject *swig_obj[1] ;
31748
31749 if (!args) SWIG_fail;
31750 swig_obj[0] = args;
31751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31752 if (!SWIG_IsOK(res1)) {
31753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31754 }
31755 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31756 {
31757 PyThreadState* __tstate = wxPyBeginAllowThreads();
31758 result = (int)(arg1)->GetAssertMode();
31759 wxPyEndAllowThreads(__tstate);
31760 if (PyErr_Occurred()) SWIG_fail;
31761 }
31762 resultobj = SWIG_From_int(static_cast< int >(result));
31763 return resultobj;
31764 fail:
31765 return NULL;
31766 }
31767
31768
31769 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31770 PyObject *resultobj = 0;
31771 bool result;
31772
31773 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31774 {
31775 PyThreadState* __tstate = wxPyBeginAllowThreads();
31776 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31777 wxPyEndAllowThreads(__tstate);
31778 if (PyErr_Occurred()) SWIG_fail;
31779 }
31780 {
31781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31782 }
31783 return resultobj;
31784 fail:
31785 return NULL;
31786 }
31787
31788
31789 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31790 PyObject *resultobj = 0;
31791 long result;
31792
31793 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31794 {
31795 PyThreadState* __tstate = wxPyBeginAllowThreads();
31796 result = (long)wxPyApp::GetMacAboutMenuItemId();
31797 wxPyEndAllowThreads(__tstate);
31798 if (PyErr_Occurred()) SWIG_fail;
31799 }
31800 resultobj = SWIG_From_long(static_cast< long >(result));
31801 return resultobj;
31802 fail:
31803 return NULL;
31804 }
31805
31806
31807 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31808 PyObject *resultobj = 0;
31809 long result;
31810
31811 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31812 {
31813 PyThreadState* __tstate = wxPyBeginAllowThreads();
31814 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31815 wxPyEndAllowThreads(__tstate);
31816 if (PyErr_Occurred()) SWIG_fail;
31817 }
31818 resultobj = SWIG_From_long(static_cast< long >(result));
31819 return resultobj;
31820 fail:
31821 return NULL;
31822 }
31823
31824
31825 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31826 PyObject *resultobj = 0;
31827 long result;
31828
31829 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31830 {
31831 PyThreadState* __tstate = wxPyBeginAllowThreads();
31832 result = (long)wxPyApp::GetMacExitMenuItemId();
31833 wxPyEndAllowThreads(__tstate);
31834 if (PyErr_Occurred()) SWIG_fail;
31835 }
31836 resultobj = SWIG_From_long(static_cast< long >(result));
31837 return resultobj;
31838 fail:
31839 return NULL;
31840 }
31841
31842
31843 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31844 PyObject *resultobj = 0;
31845 wxString result;
31846
31847 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31848 {
31849 PyThreadState* __tstate = wxPyBeginAllowThreads();
31850 result = wxPyApp::GetMacHelpMenuTitleName();
31851 wxPyEndAllowThreads(__tstate);
31852 if (PyErr_Occurred()) SWIG_fail;
31853 }
31854 {
31855 #if wxUSE_UNICODE
31856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31857 #else
31858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31859 #endif
31860 }
31861 return resultobj;
31862 fail:
31863 return NULL;
31864 }
31865
31866
31867 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31868 PyObject *resultobj = 0;
31869 bool arg1 ;
31870 bool val1 ;
31871 int ecode1 = 0 ;
31872 PyObject * obj0 = 0 ;
31873 char * kwnames[] = {
31874 (char *) "val", NULL
31875 };
31876
31877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31878 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31879 if (!SWIG_IsOK(ecode1)) {
31880 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31881 }
31882 arg1 = static_cast< bool >(val1);
31883 {
31884 PyThreadState* __tstate = wxPyBeginAllowThreads();
31885 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31886 wxPyEndAllowThreads(__tstate);
31887 if (PyErr_Occurred()) SWIG_fail;
31888 }
31889 resultobj = SWIG_Py_Void();
31890 return resultobj;
31891 fail:
31892 return NULL;
31893 }
31894
31895
31896 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31897 PyObject *resultobj = 0;
31898 long arg1 ;
31899 long val1 ;
31900 int ecode1 = 0 ;
31901 PyObject * obj0 = 0 ;
31902 char * kwnames[] = {
31903 (char *) "val", NULL
31904 };
31905
31906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31907 ecode1 = SWIG_AsVal_long(obj0, &val1);
31908 if (!SWIG_IsOK(ecode1)) {
31909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31910 }
31911 arg1 = static_cast< long >(val1);
31912 {
31913 PyThreadState* __tstate = wxPyBeginAllowThreads();
31914 wxPyApp::SetMacAboutMenuItemId(arg1);
31915 wxPyEndAllowThreads(__tstate);
31916 if (PyErr_Occurred()) SWIG_fail;
31917 }
31918 resultobj = SWIG_Py_Void();
31919 return resultobj;
31920 fail:
31921 return NULL;
31922 }
31923
31924
31925 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31926 PyObject *resultobj = 0;
31927 long arg1 ;
31928 long val1 ;
31929 int ecode1 = 0 ;
31930 PyObject * obj0 = 0 ;
31931 char * kwnames[] = {
31932 (char *) "val", NULL
31933 };
31934
31935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31936 ecode1 = SWIG_AsVal_long(obj0, &val1);
31937 if (!SWIG_IsOK(ecode1)) {
31938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31939 }
31940 arg1 = static_cast< long >(val1);
31941 {
31942 PyThreadState* __tstate = wxPyBeginAllowThreads();
31943 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31944 wxPyEndAllowThreads(__tstate);
31945 if (PyErr_Occurred()) SWIG_fail;
31946 }
31947 resultobj = SWIG_Py_Void();
31948 return resultobj;
31949 fail:
31950 return NULL;
31951 }
31952
31953
31954 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31955 PyObject *resultobj = 0;
31956 long arg1 ;
31957 long val1 ;
31958 int ecode1 = 0 ;
31959 PyObject * obj0 = 0 ;
31960 char * kwnames[] = {
31961 (char *) "val", NULL
31962 };
31963
31964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31965 ecode1 = SWIG_AsVal_long(obj0, &val1);
31966 if (!SWIG_IsOK(ecode1)) {
31967 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31968 }
31969 arg1 = static_cast< long >(val1);
31970 {
31971 PyThreadState* __tstate = wxPyBeginAllowThreads();
31972 wxPyApp::SetMacExitMenuItemId(arg1);
31973 wxPyEndAllowThreads(__tstate);
31974 if (PyErr_Occurred()) SWIG_fail;
31975 }
31976 resultobj = SWIG_Py_Void();
31977 return resultobj;
31978 fail:
31979 return NULL;
31980 }
31981
31982
31983 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31984 PyObject *resultobj = 0;
31985 wxString *arg1 = 0 ;
31986 bool temp1 = false ;
31987 PyObject * obj0 = 0 ;
31988 char * kwnames[] = {
31989 (char *) "val", NULL
31990 };
31991
31992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31993 {
31994 arg1 = wxString_in_helper(obj0);
31995 if (arg1 == NULL) SWIG_fail;
31996 temp1 = true;
31997 }
31998 {
31999 PyThreadState* __tstate = wxPyBeginAllowThreads();
32000 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
32001 wxPyEndAllowThreads(__tstate);
32002 if (PyErr_Occurred()) SWIG_fail;
32003 }
32004 resultobj = SWIG_Py_Void();
32005 {
32006 if (temp1)
32007 delete arg1;
32008 }
32009 return resultobj;
32010 fail:
32011 {
32012 if (temp1)
32013 delete arg1;
32014 }
32015 return NULL;
32016 }
32017
32018
32019 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32020 PyObject *resultobj = 0;
32021 wxPyApp *arg1 = (wxPyApp *) 0 ;
32022 void *argp1 = 0 ;
32023 int res1 = 0 ;
32024 PyObject *swig_obj[1] ;
32025
32026 if (!args) SWIG_fail;
32027 swig_obj[0] = args;
32028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
32029 if (!SWIG_IsOK(res1)) {
32030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
32031 }
32032 arg1 = reinterpret_cast< wxPyApp * >(argp1);
32033 {
32034 PyThreadState* __tstate = wxPyBeginAllowThreads();
32035 (arg1)->_BootstrapApp();
32036 wxPyEndAllowThreads(__tstate);
32037 if (PyErr_Occurred()) SWIG_fail;
32038 }
32039 resultobj = SWIG_Py_Void();
32040 return resultobj;
32041 fail:
32042 return NULL;
32043 }
32044
32045
32046 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32047 PyObject *resultobj = 0;
32048 int result;
32049
32050 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
32051 {
32052 PyThreadState* __tstate = wxPyBeginAllowThreads();
32053 result = (int)wxPyApp_GetComCtl32Version();
32054 wxPyEndAllowThreads(__tstate);
32055 if (PyErr_Occurred()) SWIG_fail;
32056 }
32057 resultobj = SWIG_From_int(static_cast< int >(result));
32058 return resultobj;
32059 fail:
32060 return NULL;
32061 }
32062
32063
32064 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32065 PyObject *resultobj = 0;
32066 bool result;
32067
32068 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
32069 {
32070 PyThreadState* __tstate = wxPyBeginAllowThreads();
32071 result = (bool)wxPyApp_IsDisplayAvailable();
32072 wxPyEndAllowThreads(__tstate);
32073 if (PyErr_Occurred()) SWIG_fail;
32074 }
32075 {
32076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32077 }
32078 return resultobj;
32079 fail:
32080 return NULL;
32081 }
32082
32083
32084 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32085 PyObject *obj;
32086 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32087 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
32088 return SWIG_Py_Void();
32089 }
32090
32091 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32092 return SWIG_Python_InitShadowInstance(args);
32093 }
32094
32095 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32096 PyObject *resultobj = 0;
32097
32098 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
32099 {
32100 PyThreadState* __tstate = wxPyBeginAllowThreads();
32101 wxExit();
32102 wxPyEndAllowThreads(__tstate);
32103 if (PyErr_Occurred()) SWIG_fail;
32104 }
32105 resultobj = SWIG_Py_Void();
32106 return resultobj;
32107 fail:
32108 return NULL;
32109 }
32110
32111
32112 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32113 PyObject *resultobj = 0;
32114 bool result;
32115
32116 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
32117 {
32118 PyThreadState* __tstate = wxPyBeginAllowThreads();
32119 result = (bool)wxYield();
32120 wxPyEndAllowThreads(__tstate);
32121 if (PyErr_Occurred()) SWIG_fail;
32122 }
32123 {
32124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32125 }
32126 return resultobj;
32127 fail:
32128 return NULL;
32129 }
32130
32131
32132 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32133 PyObject *resultobj = 0;
32134 bool result;
32135
32136 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
32137 {
32138 PyThreadState* __tstate = wxPyBeginAllowThreads();
32139 result = (bool)wxYieldIfNeeded();
32140 wxPyEndAllowThreads(__tstate);
32141 if (PyErr_Occurred()) SWIG_fail;
32142 }
32143 {
32144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32145 }
32146 return resultobj;
32147 fail:
32148 return NULL;
32149 }
32150
32151
32152 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32153 PyObject *resultobj = 0;
32154 wxWindow *arg1 = (wxWindow *) NULL ;
32155 bool arg2 = (bool) false ;
32156 bool result;
32157 void *argp1 = 0 ;
32158 int res1 = 0 ;
32159 bool val2 ;
32160 int ecode2 = 0 ;
32161 PyObject * obj0 = 0 ;
32162 PyObject * obj1 = 0 ;
32163 char * kwnames[] = {
32164 (char *) "win",(char *) "onlyIfNeeded", NULL
32165 };
32166
32167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
32168 if (obj0) {
32169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32170 if (!SWIG_IsOK(res1)) {
32171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
32172 }
32173 arg1 = reinterpret_cast< wxWindow * >(argp1);
32174 }
32175 if (obj1) {
32176 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32177 if (!SWIG_IsOK(ecode2)) {
32178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
32179 }
32180 arg2 = static_cast< bool >(val2);
32181 }
32182 {
32183 PyThreadState* __tstate = wxPyBeginAllowThreads();
32184 result = (bool)wxSafeYield(arg1,arg2);
32185 wxPyEndAllowThreads(__tstate);
32186 if (PyErr_Occurred()) SWIG_fail;
32187 }
32188 {
32189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32190 }
32191 return resultobj;
32192 fail:
32193 return NULL;
32194 }
32195
32196
32197 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32198 PyObject *resultobj = 0;
32199
32200 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
32201 {
32202 PyThreadState* __tstate = wxPyBeginAllowThreads();
32203 wxWakeUpIdle();
32204 wxPyEndAllowThreads(__tstate);
32205 if (PyErr_Occurred()) SWIG_fail;
32206 }
32207 resultobj = SWIG_Py_Void();
32208 return resultobj;
32209 fail:
32210 return NULL;
32211 }
32212
32213
32214 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32215 PyObject *resultobj = 0;
32216 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
32217 wxEvent *arg2 = 0 ;
32218 void *argp1 = 0 ;
32219 int res1 = 0 ;
32220 void *argp2 = 0 ;
32221 int res2 = 0 ;
32222 PyObject * obj0 = 0 ;
32223 PyObject * obj1 = 0 ;
32224 char * kwnames[] = {
32225 (char *) "dest",(char *) "event", NULL
32226 };
32227
32228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
32229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
32230 if (!SWIG_IsOK(res1)) {
32231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
32232 }
32233 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
32234 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
32235 if (!SWIG_IsOK(res2)) {
32236 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
32237 }
32238 if (!argp2) {
32239 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
32240 }
32241 arg2 = reinterpret_cast< wxEvent * >(argp2);
32242 {
32243 PyThreadState* __tstate = wxPyBeginAllowThreads();
32244 wxPostEvent(arg1,*arg2);
32245 wxPyEndAllowThreads(__tstate);
32246 if (PyErr_Occurred()) SWIG_fail;
32247 }
32248 resultobj = SWIG_Py_Void();
32249 return resultobj;
32250 fail:
32251 return NULL;
32252 }
32253
32254
32255 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32256 PyObject *resultobj = 0;
32257
32258 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
32259 {
32260 PyThreadState* __tstate = wxPyBeginAllowThreads();
32261 wxApp_CleanUp();
32262 wxPyEndAllowThreads(__tstate);
32263 if (PyErr_Occurred()) SWIG_fail;
32264 }
32265 resultobj = SWIG_Py_Void();
32266 return resultobj;
32267 fail:
32268 return NULL;
32269 }
32270
32271
32272 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32273 PyObject *resultobj = 0;
32274 wxPyApp *result = 0 ;
32275
32276 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
32277 {
32278 PyThreadState* __tstate = wxPyBeginAllowThreads();
32279 result = (wxPyApp *)wxPyGetApp();
32280 wxPyEndAllowThreads(__tstate);
32281 if (PyErr_Occurred()) SWIG_fail;
32282 }
32283 {
32284 resultobj = wxPyMake_wxObject(result, 0);
32285 }
32286 return resultobj;
32287 fail:
32288 return NULL;
32289 }
32290
32291
32292 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32293 PyObject *resultobj = 0;
32294 char *arg1 = (char *) 0 ;
32295 int res1 ;
32296 char *buf1 = 0 ;
32297 int alloc1 = 0 ;
32298 PyObject * obj0 = 0 ;
32299 char * kwnames[] = {
32300 (char *) "encoding", NULL
32301 };
32302
32303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
32304 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
32305 if (!SWIG_IsOK(res1)) {
32306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
32307 }
32308 arg1 = buf1;
32309 {
32310 PyThreadState* __tstate = wxPyBeginAllowThreads();
32311 wxSetDefaultPyEncoding((char const *)arg1);
32312 wxPyEndAllowThreads(__tstate);
32313 if (PyErr_Occurred()) SWIG_fail;
32314 }
32315 resultobj = SWIG_Py_Void();
32316 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
32317 return resultobj;
32318 fail:
32319 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
32320 return NULL;
32321 }
32322
32323
32324 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32325 PyObject *resultobj = 0;
32326 char *result = 0 ;
32327
32328 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
32329 {
32330 PyThreadState* __tstate = wxPyBeginAllowThreads();
32331 result = (char *)wxGetDefaultPyEncoding();
32332 wxPyEndAllowThreads(__tstate);
32333 if (PyErr_Occurred()) SWIG_fail;
32334 }
32335 resultobj = SWIG_FromCharPtr(result);
32336 return resultobj;
32337 fail:
32338 return NULL;
32339 }
32340
32341
32342 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32343 PyObject *resultobj = 0;
32344 wxEventLoop *result = 0 ;
32345
32346 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
32347 {
32348 PyThreadState* __tstate = wxPyBeginAllowThreads();
32349 result = (wxEventLoop *)new wxEventLoop();
32350 wxPyEndAllowThreads(__tstate);
32351 if (PyErr_Occurred()) SWIG_fail;
32352 }
32353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
32354 return resultobj;
32355 fail:
32356 return NULL;
32357 }
32358
32359
32360 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32361 PyObject *resultobj = 0;
32362 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32363 void *argp1 = 0 ;
32364 int res1 = 0 ;
32365 PyObject *swig_obj[1] ;
32366
32367 if (!args) SWIG_fail;
32368 swig_obj[0] = args;
32369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
32370 if (!SWIG_IsOK(res1)) {
32371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32372 }
32373 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32374 {
32375 PyThreadState* __tstate = wxPyBeginAllowThreads();
32376 delete arg1;
32377
32378 wxPyEndAllowThreads(__tstate);
32379 if (PyErr_Occurred()) SWIG_fail;
32380 }
32381 resultobj = SWIG_Py_Void();
32382 return resultobj;
32383 fail:
32384 return NULL;
32385 }
32386
32387
32388 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32389 PyObject *resultobj = 0;
32390 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32391 int result;
32392 void *argp1 = 0 ;
32393 int res1 = 0 ;
32394 PyObject *swig_obj[1] ;
32395
32396 if (!args) SWIG_fail;
32397 swig_obj[0] = args;
32398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32399 if (!SWIG_IsOK(res1)) {
32400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32401 }
32402 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32403 {
32404 PyThreadState* __tstate = wxPyBeginAllowThreads();
32405 result = (int)(arg1)->Run();
32406 wxPyEndAllowThreads(__tstate);
32407 if (PyErr_Occurred()) SWIG_fail;
32408 }
32409 resultobj = SWIG_From_int(static_cast< int >(result));
32410 return resultobj;
32411 fail:
32412 return NULL;
32413 }
32414
32415
32416 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32417 PyObject *resultobj = 0;
32418 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32419 int arg2 = (int) 0 ;
32420 void *argp1 = 0 ;
32421 int res1 = 0 ;
32422 int val2 ;
32423 int ecode2 = 0 ;
32424 PyObject * obj0 = 0 ;
32425 PyObject * obj1 = 0 ;
32426 char * kwnames[] = {
32427 (char *) "self",(char *) "rc", NULL
32428 };
32429
32430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
32431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32432 if (!SWIG_IsOK(res1)) {
32433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32434 }
32435 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32436 if (obj1) {
32437 ecode2 = SWIG_AsVal_int(obj1, &val2);
32438 if (!SWIG_IsOK(ecode2)) {
32439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
32440 }
32441 arg2 = static_cast< int >(val2);
32442 }
32443 {
32444 PyThreadState* __tstate = wxPyBeginAllowThreads();
32445 (arg1)->Exit(arg2);
32446 wxPyEndAllowThreads(__tstate);
32447 if (PyErr_Occurred()) SWIG_fail;
32448 }
32449 resultobj = SWIG_Py_Void();
32450 return resultobj;
32451 fail:
32452 return NULL;
32453 }
32454
32455
32456 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32457 PyObject *resultobj = 0;
32458 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32459 bool result;
32460 void *argp1 = 0 ;
32461 int res1 = 0 ;
32462 PyObject *swig_obj[1] ;
32463
32464 if (!args) SWIG_fail;
32465 swig_obj[0] = args;
32466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32467 if (!SWIG_IsOK(res1)) {
32468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
32469 }
32470 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32471 {
32472 PyThreadState* __tstate = wxPyBeginAllowThreads();
32473 result = (bool)((wxEventLoop const *)arg1)->Pending();
32474 wxPyEndAllowThreads(__tstate);
32475 if (PyErr_Occurred()) SWIG_fail;
32476 }
32477 {
32478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32479 }
32480 return resultobj;
32481 fail:
32482 return NULL;
32483 }
32484
32485
32486 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32487 PyObject *resultobj = 0;
32488 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32489 bool result;
32490 void *argp1 = 0 ;
32491 int res1 = 0 ;
32492 PyObject *swig_obj[1] ;
32493
32494 if (!args) SWIG_fail;
32495 swig_obj[0] = args;
32496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32497 if (!SWIG_IsOK(res1)) {
32498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32499 }
32500 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32501 {
32502 PyThreadState* __tstate = wxPyBeginAllowThreads();
32503 result = (bool)(arg1)->Dispatch();
32504 wxPyEndAllowThreads(__tstate);
32505 if (PyErr_Occurred()) SWIG_fail;
32506 }
32507 {
32508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32509 }
32510 return resultobj;
32511 fail:
32512 return NULL;
32513 }
32514
32515
32516 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32517 PyObject *resultobj = 0;
32518 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32519 bool result;
32520 void *argp1 = 0 ;
32521 int res1 = 0 ;
32522 PyObject *swig_obj[1] ;
32523
32524 if (!args) SWIG_fail;
32525 swig_obj[0] = args;
32526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32527 if (!SWIG_IsOK(res1)) {
32528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
32529 }
32530 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32531 {
32532 PyThreadState* __tstate = wxPyBeginAllowThreads();
32533 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
32534 wxPyEndAllowThreads(__tstate);
32535 if (PyErr_Occurred()) SWIG_fail;
32536 }
32537 {
32538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32539 }
32540 return resultobj;
32541 fail:
32542 return NULL;
32543 }
32544
32545
32546 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32547 PyObject *resultobj = 0;
32548 wxEventLoop *result = 0 ;
32549
32550 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
32551 {
32552 PyThreadState* __tstate = wxPyBeginAllowThreads();
32553 result = (wxEventLoop *)wxEventLoop::GetActive();
32554 wxPyEndAllowThreads(__tstate);
32555 if (PyErr_Occurred()) SWIG_fail;
32556 }
32557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
32558 return resultobj;
32559 fail:
32560 return NULL;
32561 }
32562
32563
32564 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32565 PyObject *resultobj = 0;
32566 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32567 void *argp1 = 0 ;
32568 int res1 = 0 ;
32569 PyObject * obj0 = 0 ;
32570 char * kwnames[] = {
32571 (char *) "loop", NULL
32572 };
32573
32574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
32575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32576 if (!SWIG_IsOK(res1)) {
32577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32578 }
32579 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32580 {
32581 PyThreadState* __tstate = wxPyBeginAllowThreads();
32582 wxEventLoop::SetActive(arg1);
32583 wxPyEndAllowThreads(__tstate);
32584 if (PyErr_Occurred()) SWIG_fail;
32585 }
32586 resultobj = SWIG_Py_Void();
32587 return resultobj;
32588 fail:
32589 return NULL;
32590 }
32591
32592
32593 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32594 PyObject *obj;
32595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32596 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
32597 return SWIG_Py_Void();
32598 }
32599
32600 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32601 return SWIG_Python_InitShadowInstance(args);
32602 }
32603
32604 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32605 PyObject *resultobj = 0;
32606 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32607 wxEventLoopActivator *result = 0 ;
32608 void *argp1 = 0 ;
32609 int res1 = 0 ;
32610 PyObject * obj0 = 0 ;
32611 char * kwnames[] = {
32612 (char *) "evtLoop", NULL
32613 };
32614
32615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
32616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32617 if (!SWIG_IsOK(res1)) {
32618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32619 }
32620 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32621 {
32622 PyThreadState* __tstate = wxPyBeginAllowThreads();
32623 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
32624 wxPyEndAllowThreads(__tstate);
32625 if (PyErr_Occurred()) SWIG_fail;
32626 }
32627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
32628 return resultobj;
32629 fail:
32630 return NULL;
32631 }
32632
32633
32634 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32635 PyObject *resultobj = 0;
32636 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
32637 void *argp1 = 0 ;
32638 int res1 = 0 ;
32639 PyObject *swig_obj[1] ;
32640
32641 if (!args) SWIG_fail;
32642 swig_obj[0] = args;
32643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
32644 if (!SWIG_IsOK(res1)) {
32645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
32646 }
32647 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
32648 {
32649 PyThreadState* __tstate = wxPyBeginAllowThreads();
32650 delete arg1;
32651
32652 wxPyEndAllowThreads(__tstate);
32653 if (PyErr_Occurred()) SWIG_fail;
32654 }
32655 resultobj = SWIG_Py_Void();
32656 return resultobj;
32657 fail:
32658 return NULL;
32659 }
32660
32661
32662 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32663 PyObject *obj;
32664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32665 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
32666 return SWIG_Py_Void();
32667 }
32668
32669 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32670 return SWIG_Python_InitShadowInstance(args);
32671 }
32672
32673 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32674 PyObject *resultobj = 0;
32675 int arg1 = (int) 0 ;
32676 int arg2 = (int) 0 ;
32677 int arg3 = (int) 0 ;
32678 wxAcceleratorEntry *result = 0 ;
32679 int val1 ;
32680 int ecode1 = 0 ;
32681 int val2 ;
32682 int ecode2 = 0 ;
32683 int val3 ;
32684 int ecode3 = 0 ;
32685 PyObject * obj0 = 0 ;
32686 PyObject * obj1 = 0 ;
32687 PyObject * obj2 = 0 ;
32688 char * kwnames[] = {
32689 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
32690 };
32691
32692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32693 if (obj0) {
32694 ecode1 = SWIG_AsVal_int(obj0, &val1);
32695 if (!SWIG_IsOK(ecode1)) {
32696 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
32697 }
32698 arg1 = static_cast< int >(val1);
32699 }
32700 if (obj1) {
32701 ecode2 = SWIG_AsVal_int(obj1, &val2);
32702 if (!SWIG_IsOK(ecode2)) {
32703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32704 }
32705 arg2 = static_cast< int >(val2);
32706 }
32707 if (obj2) {
32708 ecode3 = SWIG_AsVal_int(obj2, &val3);
32709 if (!SWIG_IsOK(ecode3)) {
32710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32711 }
32712 arg3 = static_cast< int >(val3);
32713 }
32714 {
32715 PyThreadState* __tstate = wxPyBeginAllowThreads();
32716 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32717 wxPyEndAllowThreads(__tstate);
32718 if (PyErr_Occurred()) SWIG_fail;
32719 }
32720 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32721 return resultobj;
32722 fail:
32723 return NULL;
32724 }
32725
32726
32727 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32728 PyObject *resultobj = 0;
32729 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32730 void *argp1 = 0 ;
32731 int res1 = 0 ;
32732 PyObject *swig_obj[1] ;
32733
32734 if (!args) SWIG_fail;
32735 swig_obj[0] = args;
32736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32737 if (!SWIG_IsOK(res1)) {
32738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32739 }
32740 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32741 {
32742 PyThreadState* __tstate = wxPyBeginAllowThreads();
32743 delete arg1;
32744
32745 wxPyEndAllowThreads(__tstate);
32746 if (PyErr_Occurred()) SWIG_fail;
32747 }
32748 resultobj = SWIG_Py_Void();
32749 return resultobj;
32750 fail:
32751 return NULL;
32752 }
32753
32754
32755 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32756 PyObject *resultobj = 0;
32757 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32758 int arg2 ;
32759 int arg3 ;
32760 int arg4 ;
32761 void *argp1 = 0 ;
32762 int res1 = 0 ;
32763 int val2 ;
32764 int ecode2 = 0 ;
32765 int val3 ;
32766 int ecode3 = 0 ;
32767 int val4 ;
32768 int ecode4 = 0 ;
32769 PyObject * obj0 = 0 ;
32770 PyObject * obj1 = 0 ;
32771 PyObject * obj2 = 0 ;
32772 PyObject * obj3 = 0 ;
32773 char * kwnames[] = {
32774 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32775 };
32776
32777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32779 if (!SWIG_IsOK(res1)) {
32780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32781 }
32782 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32783 ecode2 = SWIG_AsVal_int(obj1, &val2);
32784 if (!SWIG_IsOK(ecode2)) {
32785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32786 }
32787 arg2 = static_cast< int >(val2);
32788 ecode3 = SWIG_AsVal_int(obj2, &val3);
32789 if (!SWIG_IsOK(ecode3)) {
32790 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32791 }
32792 arg3 = static_cast< int >(val3);
32793 ecode4 = SWIG_AsVal_int(obj3, &val4);
32794 if (!SWIG_IsOK(ecode4)) {
32795 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32796 }
32797 arg4 = static_cast< int >(val4);
32798 {
32799 PyThreadState* __tstate = wxPyBeginAllowThreads();
32800 (arg1)->Set(arg2,arg3,arg4);
32801 wxPyEndAllowThreads(__tstate);
32802 if (PyErr_Occurred()) SWIG_fail;
32803 }
32804 resultobj = SWIG_Py_Void();
32805 return resultobj;
32806 fail:
32807 return NULL;
32808 }
32809
32810
32811 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32812 PyObject *resultobj = 0;
32813 wxString *arg1 = 0 ;
32814 wxAcceleratorEntry *result = 0 ;
32815 bool temp1 = false ;
32816 PyObject * obj0 = 0 ;
32817 char * kwnames[] = {
32818 (char *) "str", NULL
32819 };
32820
32821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32822 {
32823 arg1 = wxString_in_helper(obj0);
32824 if (arg1 == NULL) SWIG_fail;
32825 temp1 = true;
32826 }
32827 {
32828 PyThreadState* __tstate = wxPyBeginAllowThreads();
32829 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32830 wxPyEndAllowThreads(__tstate);
32831 if (PyErr_Occurred()) SWIG_fail;
32832 }
32833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32834 {
32835 if (temp1)
32836 delete arg1;
32837 }
32838 return resultobj;
32839 fail:
32840 {
32841 if (temp1)
32842 delete arg1;
32843 }
32844 return NULL;
32845 }
32846
32847
32848 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32849 PyObject *resultobj = 0;
32850 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32851 int result;
32852 void *argp1 = 0 ;
32853 int res1 = 0 ;
32854 PyObject *swig_obj[1] ;
32855
32856 if (!args) SWIG_fail;
32857 swig_obj[0] = args;
32858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32859 if (!SWIG_IsOK(res1)) {
32860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32861 }
32862 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32863 {
32864 PyThreadState* __tstate = wxPyBeginAllowThreads();
32865 result = (int)(arg1)->GetFlags();
32866 wxPyEndAllowThreads(__tstate);
32867 if (PyErr_Occurred()) SWIG_fail;
32868 }
32869 resultobj = SWIG_From_int(static_cast< int >(result));
32870 return resultobj;
32871 fail:
32872 return NULL;
32873 }
32874
32875
32876 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32877 PyObject *resultobj = 0;
32878 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32879 int result;
32880 void *argp1 = 0 ;
32881 int res1 = 0 ;
32882 PyObject *swig_obj[1] ;
32883
32884 if (!args) SWIG_fail;
32885 swig_obj[0] = args;
32886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32887 if (!SWIG_IsOK(res1)) {
32888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32889 }
32890 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32891 {
32892 PyThreadState* __tstate = wxPyBeginAllowThreads();
32893 result = (int)(arg1)->GetKeyCode();
32894 wxPyEndAllowThreads(__tstate);
32895 if (PyErr_Occurred()) SWIG_fail;
32896 }
32897 resultobj = SWIG_From_int(static_cast< int >(result));
32898 return resultobj;
32899 fail:
32900 return NULL;
32901 }
32902
32903
32904 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32905 PyObject *resultobj = 0;
32906 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32907 int result;
32908 void *argp1 = 0 ;
32909 int res1 = 0 ;
32910 PyObject *swig_obj[1] ;
32911
32912 if (!args) SWIG_fail;
32913 swig_obj[0] = args;
32914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32915 if (!SWIG_IsOK(res1)) {
32916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32917 }
32918 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32919 {
32920 PyThreadState* __tstate = wxPyBeginAllowThreads();
32921 result = (int)(arg1)->GetCommand();
32922 wxPyEndAllowThreads(__tstate);
32923 if (PyErr_Occurred()) SWIG_fail;
32924 }
32925 resultobj = SWIG_From_int(static_cast< int >(result));
32926 return resultobj;
32927 fail:
32928 return NULL;
32929 }
32930
32931
32932 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32933 PyObject *resultobj = 0;
32934 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32935 bool result;
32936 void *argp1 = 0 ;
32937 int res1 = 0 ;
32938 PyObject *swig_obj[1] ;
32939
32940 if (!args) SWIG_fail;
32941 swig_obj[0] = args;
32942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32943 if (!SWIG_IsOK(res1)) {
32944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32945 }
32946 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32947 {
32948 PyThreadState* __tstate = wxPyBeginAllowThreads();
32949 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32950 wxPyEndAllowThreads(__tstate);
32951 if (PyErr_Occurred()) SWIG_fail;
32952 }
32953 {
32954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32955 }
32956 return resultobj;
32957 fail:
32958 return NULL;
32959 }
32960
32961
32962 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32963 PyObject *resultobj = 0;
32964 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32965 wxString result;
32966 void *argp1 = 0 ;
32967 int res1 = 0 ;
32968 PyObject *swig_obj[1] ;
32969
32970 if (!args) SWIG_fail;
32971 swig_obj[0] = args;
32972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32973 if (!SWIG_IsOK(res1)) {
32974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32975 }
32976 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32977 {
32978 PyThreadState* __tstate = wxPyBeginAllowThreads();
32979 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32980 wxPyEndAllowThreads(__tstate);
32981 if (PyErr_Occurred()) SWIG_fail;
32982 }
32983 {
32984 #if wxUSE_UNICODE
32985 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32986 #else
32987 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32988 #endif
32989 }
32990 return resultobj;
32991 fail:
32992 return NULL;
32993 }
32994
32995
32996 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32997 PyObject *resultobj = 0;
32998 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32999 wxString *arg2 = 0 ;
33000 bool result;
33001 void *argp1 = 0 ;
33002 int res1 = 0 ;
33003 bool temp2 = false ;
33004 PyObject * obj0 = 0 ;
33005 PyObject * obj1 = 0 ;
33006 char * kwnames[] = {
33007 (char *) "self",(char *) "str", NULL
33008 };
33009
33010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
33011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
33012 if (!SWIG_IsOK(res1)) {
33013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
33014 }
33015 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
33016 {
33017 arg2 = wxString_in_helper(obj1);
33018 if (arg2 == NULL) SWIG_fail;
33019 temp2 = true;
33020 }
33021 {
33022 PyThreadState* __tstate = wxPyBeginAllowThreads();
33023 result = (bool)(arg1)->FromString((wxString const &)*arg2);
33024 wxPyEndAllowThreads(__tstate);
33025 if (PyErr_Occurred()) SWIG_fail;
33026 }
33027 {
33028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33029 }
33030 {
33031 if (temp2)
33032 delete arg2;
33033 }
33034 return resultobj;
33035 fail:
33036 {
33037 if (temp2)
33038 delete arg2;
33039 }
33040 return NULL;
33041 }
33042
33043
33044 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33045 PyObject *obj;
33046 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33047 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
33048 return SWIG_Py_Void();
33049 }
33050
33051 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33052 return SWIG_Python_InitShadowInstance(args);
33053 }
33054
33055 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33056 PyObject *resultobj = 0;
33057 int arg1 ;
33058 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
33059 wxAcceleratorTable *result = 0 ;
33060 PyObject * obj0 = 0 ;
33061 char * kwnames[] = {
33062 (char *) "n", NULL
33063 };
33064
33065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
33066 {
33067 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
33068 if (arg2) arg1 = PyList_Size(obj0);
33069 else arg1 = 0;
33070 }
33071 {
33072 PyThreadState* __tstate = wxPyBeginAllowThreads();
33073 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
33074 wxPyEndAllowThreads(__tstate);
33075 if (PyErr_Occurred()) SWIG_fail;
33076 }
33077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
33078 return resultobj;
33079 fail:
33080 return NULL;
33081 }
33082
33083
33084 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33085 PyObject *resultobj = 0;
33086 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
33087 void *argp1 = 0 ;
33088 int res1 = 0 ;
33089 PyObject *swig_obj[1] ;
33090
33091 if (!args) SWIG_fail;
33092 swig_obj[0] = args;
33093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
33094 if (!SWIG_IsOK(res1)) {
33095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
33096 }
33097 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
33098 {
33099 PyThreadState* __tstate = wxPyBeginAllowThreads();
33100 delete arg1;
33101
33102 wxPyEndAllowThreads(__tstate);
33103 if (PyErr_Occurred()) SWIG_fail;
33104 }
33105 resultobj = SWIG_Py_Void();
33106 return resultobj;
33107 fail:
33108 return NULL;
33109 }
33110
33111
33112 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33113 PyObject *resultobj = 0;
33114 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
33115 bool result;
33116 void *argp1 = 0 ;
33117 int res1 = 0 ;
33118 PyObject *swig_obj[1] ;
33119
33120 if (!args) SWIG_fail;
33121 swig_obj[0] = args;
33122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33123 if (!SWIG_IsOK(res1)) {
33124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
33125 }
33126 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
33127 {
33128 PyThreadState* __tstate = wxPyBeginAllowThreads();
33129 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
33130 wxPyEndAllowThreads(__tstate);
33131 if (PyErr_Occurred()) SWIG_fail;
33132 }
33133 {
33134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33135 }
33136 return resultobj;
33137 fail:
33138 return NULL;
33139 }
33140
33141
33142 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33143 PyObject *obj;
33144 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33145 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
33146 return SWIG_Py_Void();
33147 }
33148
33149 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33150 return SWIG_Python_InitShadowInstance(args);
33151 }
33152
33153 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
33154 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
33155 return 1;
33156 }
33157
33158
33159 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
33160 PyObject *pyobj = 0;
33161
33162 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
33163 return pyobj;
33164 }
33165
33166
33167 SWIGINTERN int PanelNameStr_set(PyObject *) {
33168 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
33169 return 1;
33170 }
33171
33172
33173 SWIGINTERN PyObject *PanelNameStr_get(void) {
33174 PyObject *pyobj = 0;
33175
33176 {
33177 #if wxUSE_UNICODE
33178 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
33179 #else
33180 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
33181 #endif
33182 }
33183 return pyobj;
33184 }
33185
33186
33187 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33188 PyObject *resultobj = 0;
33189 wxVisualAttributes *result = 0 ;
33190
33191 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
33192 {
33193 PyThreadState* __tstate = wxPyBeginAllowThreads();
33194 result = (wxVisualAttributes *)new_wxVisualAttributes();
33195 wxPyEndAllowThreads(__tstate);
33196 if (PyErr_Occurred()) SWIG_fail;
33197 }
33198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
33199 return resultobj;
33200 fail:
33201 return NULL;
33202 }
33203
33204
33205 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33206 PyObject *resultobj = 0;
33207 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33208 void *argp1 = 0 ;
33209 int res1 = 0 ;
33210 PyObject *swig_obj[1] ;
33211
33212 if (!args) SWIG_fail;
33213 swig_obj[0] = args;
33214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
33215 if (!SWIG_IsOK(res1)) {
33216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33217 }
33218 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33219 {
33220 PyThreadState* __tstate = wxPyBeginAllowThreads();
33221 delete_wxVisualAttributes(arg1);
33222
33223 wxPyEndAllowThreads(__tstate);
33224 if (PyErr_Occurred()) SWIG_fail;
33225 }
33226 resultobj = SWIG_Py_Void();
33227 return resultobj;
33228 fail:
33229 return NULL;
33230 }
33231
33232
33233 SWIGINTERN PyObject *_wrap_VisualAttributes__get_font(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33234 PyObject *resultobj = 0;
33235 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33236 wxFont result;
33237 void *argp1 = 0 ;
33238 int res1 = 0 ;
33239 PyObject *swig_obj[1] ;
33240
33241 if (!args) SWIG_fail;
33242 swig_obj[0] = args;
33243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
33244 if (!SWIG_IsOK(res1)) {
33245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes__get_font" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33246 }
33247 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33248 {
33249 PyThreadState* __tstate = wxPyBeginAllowThreads();
33250 result = wxVisualAttributes__get_font(arg1);
33251 wxPyEndAllowThreads(__tstate);
33252 if (PyErr_Occurred()) SWIG_fail;
33253 }
33254 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
33255 return resultobj;
33256 fail:
33257 return NULL;
33258 }
33259
33260
33261 SWIGINTERN PyObject *_wrap_VisualAttributes__get_colFg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33262 PyObject *resultobj = 0;
33263 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33264 wxColour result;
33265 void *argp1 = 0 ;
33266 int res1 = 0 ;
33267 PyObject *swig_obj[1] ;
33268
33269 if (!args) SWIG_fail;
33270 swig_obj[0] = args;
33271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
33272 if (!SWIG_IsOK(res1)) {
33273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes__get_colFg" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33274 }
33275 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33276 {
33277 PyThreadState* __tstate = wxPyBeginAllowThreads();
33278 result = wxVisualAttributes__get_colFg(arg1);
33279 wxPyEndAllowThreads(__tstate);
33280 if (PyErr_Occurred()) SWIG_fail;
33281 }
33282 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
33283 return resultobj;
33284 fail:
33285 return NULL;
33286 }
33287
33288
33289 SWIGINTERN PyObject *_wrap_VisualAttributes__get_colBg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33290 PyObject *resultobj = 0;
33291 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33292 wxColour result;
33293 void *argp1 = 0 ;
33294 int res1 = 0 ;
33295 PyObject *swig_obj[1] ;
33296
33297 if (!args) SWIG_fail;
33298 swig_obj[0] = args;
33299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
33300 if (!SWIG_IsOK(res1)) {
33301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes__get_colBg" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33302 }
33303 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33304 {
33305 PyThreadState* __tstate = wxPyBeginAllowThreads();
33306 result = wxVisualAttributes__get_colBg(arg1);
33307 wxPyEndAllowThreads(__tstate);
33308 if (PyErr_Occurred()) SWIG_fail;
33309 }
33310 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
33311 return resultobj;
33312 fail:
33313 return NULL;
33314 }
33315
33316
33317 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33318 PyObject *obj;
33319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33320 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
33321 return SWIG_Py_Void();
33322 }
33323
33324 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33325 return SWIG_Python_InitShadowInstance(args);
33326 }
33327
33328 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33329 PyObject *resultobj = 0;
33330 wxWindow *arg1 = (wxWindow *) 0 ;
33331 int arg2 = (int) (int)-1 ;
33332 wxPoint const &arg3_defvalue = wxDefaultPosition ;
33333 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
33334 wxSize const &arg4_defvalue = wxDefaultSize ;
33335 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
33336 long arg5 = (long) 0 ;
33337 wxString const &arg6_defvalue = wxPyPanelNameStr ;
33338 wxString *arg6 = (wxString *) &arg6_defvalue ;
33339 wxWindow *result = 0 ;
33340 void *argp1 = 0 ;
33341 int res1 = 0 ;
33342 int val2 ;
33343 int ecode2 = 0 ;
33344 wxPoint temp3 ;
33345 wxSize temp4 ;
33346 long val5 ;
33347 int ecode5 = 0 ;
33348 bool temp6 = false ;
33349 PyObject * obj0 = 0 ;
33350 PyObject * obj1 = 0 ;
33351 PyObject * obj2 = 0 ;
33352 PyObject * obj3 = 0 ;
33353 PyObject * obj4 = 0 ;
33354 PyObject * obj5 = 0 ;
33355 char * kwnames[] = {
33356 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
33357 };
33358
33359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33361 if (!SWIG_IsOK(res1)) {
33362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
33363 }
33364 arg1 = reinterpret_cast< wxWindow * >(argp1);
33365 if (obj1) {
33366 ecode2 = SWIG_AsVal_int(obj1, &val2);
33367 if (!SWIG_IsOK(ecode2)) {
33368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
33369 }
33370 arg2 = static_cast< int >(val2);
33371 }
33372 if (obj2) {
33373 {
33374 arg3 = &temp3;
33375 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
33376 }
33377 }
33378 if (obj3) {
33379 {
33380 arg4 = &temp4;
33381 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
33382 }
33383 }
33384 if (obj4) {
33385 ecode5 = SWIG_AsVal_long(obj4, &val5);
33386 if (!SWIG_IsOK(ecode5)) {
33387 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
33388 }
33389 arg5 = static_cast< long >(val5);
33390 }
33391 if (obj5) {
33392 {
33393 arg6 = wxString_in_helper(obj5);
33394 if (arg6 == NULL) SWIG_fail;
33395 temp6 = true;
33396 }
33397 }
33398 {
33399 if (!wxPyCheckForApp()) SWIG_fail;
33400 PyThreadState* __tstate = wxPyBeginAllowThreads();
33401 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
33402 wxPyEndAllowThreads(__tstate);
33403 if (PyErr_Occurred()) SWIG_fail;
33404 }
33405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
33406 {
33407 if (temp6)
33408 delete arg6;
33409 }
33410 return resultobj;
33411 fail:
33412 {
33413 if (temp6)
33414 delete arg6;
33415 }
33416 return NULL;
33417 }
33418
33419
33420 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33421 PyObject *resultobj = 0;
33422 wxWindow *result = 0 ;
33423
33424 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
33425 {
33426 if (!wxPyCheckForApp()) SWIG_fail;
33427 PyThreadState* __tstate = wxPyBeginAllowThreads();
33428 result = (wxWindow *)new wxWindow();
33429 wxPyEndAllowThreads(__tstate);
33430 if (PyErr_Occurred()) SWIG_fail;
33431 }
33432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
33433 return resultobj;
33434 fail:
33435 return NULL;
33436 }
33437
33438
33439 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33440 PyObject *resultobj = 0;
33441 wxWindow *arg1 = (wxWindow *) 0 ;
33442 wxWindow *arg2 = (wxWindow *) 0 ;
33443 int arg3 = (int) (int)-1 ;
33444 wxPoint const &arg4_defvalue = wxDefaultPosition ;
33445 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
33446 wxSize const &arg5_defvalue = wxDefaultSize ;
33447 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
33448 long arg6 = (long) 0 ;
33449 wxString const &arg7_defvalue = wxPyPanelNameStr ;
33450 wxString *arg7 = (wxString *) &arg7_defvalue ;
33451 bool result;
33452 void *argp1 = 0 ;
33453 int res1 = 0 ;
33454 void *argp2 = 0 ;
33455 int res2 = 0 ;
33456 int val3 ;
33457 int ecode3 = 0 ;
33458 wxPoint temp4 ;
33459 wxSize temp5 ;
33460 long val6 ;
33461 int ecode6 = 0 ;
33462 bool temp7 = false ;
33463 PyObject * obj0 = 0 ;
33464 PyObject * obj1 = 0 ;
33465 PyObject * obj2 = 0 ;
33466 PyObject * obj3 = 0 ;
33467 PyObject * obj4 = 0 ;
33468 PyObject * obj5 = 0 ;
33469 PyObject * obj6 = 0 ;
33470 char * kwnames[] = {
33471 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
33472 };
33473
33474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
33475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33476 if (!SWIG_IsOK(res1)) {
33477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
33478 }
33479 arg1 = reinterpret_cast< wxWindow * >(argp1);
33480 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33481 if (!SWIG_IsOK(res2)) {
33482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
33483 }
33484 arg2 = reinterpret_cast< wxWindow * >(argp2);
33485 if (obj2) {
33486 ecode3 = SWIG_AsVal_int(obj2, &val3);
33487 if (!SWIG_IsOK(ecode3)) {
33488 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
33489 }
33490 arg3 = static_cast< int >(val3);
33491 }
33492 if (obj3) {
33493 {
33494 arg4 = &temp4;
33495 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
33496 }
33497 }
33498 if (obj4) {
33499 {
33500 arg5 = &temp5;
33501 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
33502 }
33503 }
33504 if (obj5) {
33505 ecode6 = SWIG_AsVal_long(obj5, &val6);
33506 if (!SWIG_IsOK(ecode6)) {
33507 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
33508 }
33509 arg6 = static_cast< long >(val6);
33510 }
33511 if (obj6) {
33512 {
33513 arg7 = wxString_in_helper(obj6);
33514 if (arg7 == NULL) SWIG_fail;
33515 temp7 = true;
33516 }
33517 }
33518 {
33519 PyThreadState* __tstate = wxPyBeginAllowThreads();
33520 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
33521 wxPyEndAllowThreads(__tstate);
33522 if (PyErr_Occurred()) SWIG_fail;
33523 }
33524 {
33525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33526 }
33527 {
33528 if (temp7)
33529 delete arg7;
33530 }
33531 return resultobj;
33532 fail:
33533 {
33534 if (temp7)
33535 delete arg7;
33536 }
33537 return NULL;
33538 }
33539
33540
33541 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33542 PyObject *resultobj = 0;
33543 wxWindow *arg1 = (wxWindow *) 0 ;
33544 bool arg2 = (bool) false ;
33545 bool result;
33546 void *argp1 = 0 ;
33547 int res1 = 0 ;
33548 bool val2 ;
33549 int ecode2 = 0 ;
33550 PyObject * obj0 = 0 ;
33551 PyObject * obj1 = 0 ;
33552 char * kwnames[] = {
33553 (char *) "self",(char *) "force", NULL
33554 };
33555
33556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
33557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33558 if (!SWIG_IsOK(res1)) {
33559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
33560 }
33561 arg1 = reinterpret_cast< wxWindow * >(argp1);
33562 if (obj1) {
33563 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33564 if (!SWIG_IsOK(ecode2)) {
33565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
33566 }
33567 arg2 = static_cast< bool >(val2);
33568 }
33569 {
33570 PyThreadState* __tstate = wxPyBeginAllowThreads();
33571 result = (bool)(arg1)->Close(arg2);
33572 wxPyEndAllowThreads(__tstate);
33573 if (PyErr_Occurred()) SWIG_fail;
33574 }
33575 {
33576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33577 }
33578 return resultobj;
33579 fail:
33580 return NULL;
33581 }
33582
33583
33584 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33585 PyObject *resultobj = 0;
33586 wxWindow *arg1 = (wxWindow *) 0 ;
33587 bool result;
33588 void *argp1 = 0 ;
33589 int res1 = 0 ;
33590 PyObject *swig_obj[1] ;
33591
33592 if (!args) SWIG_fail;
33593 swig_obj[0] = args;
33594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33595 if (!SWIG_IsOK(res1)) {
33596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33597 }
33598 arg1 = reinterpret_cast< wxWindow * >(argp1);
33599 {
33600 PyThreadState* __tstate = wxPyBeginAllowThreads();
33601 result = (bool)(arg1)->Destroy();
33602 wxPyEndAllowThreads(__tstate);
33603 if (PyErr_Occurred()) SWIG_fail;
33604 }
33605 {
33606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33607 }
33608 return resultobj;
33609 fail:
33610 return NULL;
33611 }
33612
33613
33614 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33615 PyObject *resultobj = 0;
33616 wxWindow *arg1 = (wxWindow *) 0 ;
33617 bool result;
33618 void *argp1 = 0 ;
33619 int res1 = 0 ;
33620 PyObject *swig_obj[1] ;
33621
33622 if (!args) SWIG_fail;
33623 swig_obj[0] = args;
33624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33625 if (!SWIG_IsOK(res1)) {
33626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33627 }
33628 arg1 = reinterpret_cast< wxWindow * >(argp1);
33629 {
33630 PyThreadState* __tstate = wxPyBeginAllowThreads();
33631 result = (bool)(arg1)->DestroyChildren();
33632 wxPyEndAllowThreads(__tstate);
33633 if (PyErr_Occurred()) SWIG_fail;
33634 }
33635 {
33636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33637 }
33638 return resultobj;
33639 fail:
33640 return NULL;
33641 }
33642
33643
33644 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33645 PyObject *resultobj = 0;
33646 wxWindow *arg1 = (wxWindow *) 0 ;
33647 bool result;
33648 void *argp1 = 0 ;
33649 int res1 = 0 ;
33650 PyObject *swig_obj[1] ;
33651
33652 if (!args) SWIG_fail;
33653 swig_obj[0] = args;
33654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33655 if (!SWIG_IsOK(res1)) {
33656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33657 }
33658 arg1 = reinterpret_cast< wxWindow * >(argp1);
33659 {
33660 PyThreadState* __tstate = wxPyBeginAllowThreads();
33661 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33662 wxPyEndAllowThreads(__tstate);
33663 if (PyErr_Occurred()) SWIG_fail;
33664 }
33665 {
33666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33667 }
33668 return resultobj;
33669 fail:
33670 return NULL;
33671 }
33672
33673
33674 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33675 PyObject *resultobj = 0;
33676 wxWindow *arg1 = (wxWindow *) 0 ;
33677 wxString *arg2 = 0 ;
33678 void *argp1 = 0 ;
33679 int res1 = 0 ;
33680 bool temp2 = false ;
33681 PyObject * obj0 = 0 ;
33682 PyObject * obj1 = 0 ;
33683 char * kwnames[] = {
33684 (char *) "self",(char *) "label", NULL
33685 };
33686
33687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33689 if (!SWIG_IsOK(res1)) {
33690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33691 }
33692 arg1 = reinterpret_cast< wxWindow * >(argp1);
33693 {
33694 arg2 = wxString_in_helper(obj1);
33695 if (arg2 == NULL) SWIG_fail;
33696 temp2 = true;
33697 }
33698 {
33699 PyThreadState* __tstate = wxPyBeginAllowThreads();
33700 (arg1)->SetLabel((wxString const &)*arg2);
33701 wxPyEndAllowThreads(__tstate);
33702 if (PyErr_Occurred()) SWIG_fail;
33703 }
33704 resultobj = SWIG_Py_Void();
33705 {
33706 if (temp2)
33707 delete arg2;
33708 }
33709 return resultobj;
33710 fail:
33711 {
33712 if (temp2)
33713 delete arg2;
33714 }
33715 return NULL;
33716 }
33717
33718
33719 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33720 PyObject *resultobj = 0;
33721 wxWindow *arg1 = (wxWindow *) 0 ;
33722 wxString result;
33723 void *argp1 = 0 ;
33724 int res1 = 0 ;
33725 PyObject *swig_obj[1] ;
33726
33727 if (!args) SWIG_fail;
33728 swig_obj[0] = args;
33729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33730 if (!SWIG_IsOK(res1)) {
33731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33732 }
33733 arg1 = reinterpret_cast< wxWindow * >(argp1);
33734 {
33735 PyThreadState* __tstate = wxPyBeginAllowThreads();
33736 result = ((wxWindow const *)arg1)->GetLabel();
33737 wxPyEndAllowThreads(__tstate);
33738 if (PyErr_Occurred()) SWIG_fail;
33739 }
33740 {
33741 #if wxUSE_UNICODE
33742 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33743 #else
33744 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33745 #endif
33746 }
33747 return resultobj;
33748 fail:
33749 return NULL;
33750 }
33751
33752
33753 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33754 PyObject *resultobj = 0;
33755 wxWindow *arg1 = (wxWindow *) 0 ;
33756 wxString *arg2 = 0 ;
33757 void *argp1 = 0 ;
33758 int res1 = 0 ;
33759 bool temp2 = false ;
33760 PyObject * obj0 = 0 ;
33761 PyObject * obj1 = 0 ;
33762 char * kwnames[] = {
33763 (char *) "self",(char *) "name", NULL
33764 };
33765
33766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33768 if (!SWIG_IsOK(res1)) {
33769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33770 }
33771 arg1 = reinterpret_cast< wxWindow * >(argp1);
33772 {
33773 arg2 = wxString_in_helper(obj1);
33774 if (arg2 == NULL) SWIG_fail;
33775 temp2 = true;
33776 }
33777 {
33778 PyThreadState* __tstate = wxPyBeginAllowThreads();
33779 (arg1)->SetName((wxString const &)*arg2);
33780 wxPyEndAllowThreads(__tstate);
33781 if (PyErr_Occurred()) SWIG_fail;
33782 }
33783 resultobj = SWIG_Py_Void();
33784 {
33785 if (temp2)
33786 delete arg2;
33787 }
33788 return resultobj;
33789 fail:
33790 {
33791 if (temp2)
33792 delete arg2;
33793 }
33794 return NULL;
33795 }
33796
33797
33798 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33799 PyObject *resultobj = 0;
33800 wxWindow *arg1 = (wxWindow *) 0 ;
33801 wxString result;
33802 void *argp1 = 0 ;
33803 int res1 = 0 ;
33804 PyObject *swig_obj[1] ;
33805
33806 if (!args) SWIG_fail;
33807 swig_obj[0] = args;
33808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33809 if (!SWIG_IsOK(res1)) {
33810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33811 }
33812 arg1 = reinterpret_cast< wxWindow * >(argp1);
33813 {
33814 PyThreadState* __tstate = wxPyBeginAllowThreads();
33815 result = ((wxWindow const *)arg1)->GetName();
33816 wxPyEndAllowThreads(__tstate);
33817 if (PyErr_Occurred()) SWIG_fail;
33818 }
33819 {
33820 #if wxUSE_UNICODE
33821 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33822 #else
33823 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33824 #endif
33825 }
33826 return resultobj;
33827 fail:
33828 return NULL;
33829 }
33830
33831
33832 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33833 PyObject *resultobj = 0;
33834 wxWindow *arg1 = (wxWindow *) 0 ;
33835 wxWindowVariant arg2 ;
33836 void *argp1 = 0 ;
33837 int res1 = 0 ;
33838 int val2 ;
33839 int ecode2 = 0 ;
33840 PyObject * obj0 = 0 ;
33841 PyObject * obj1 = 0 ;
33842 char * kwnames[] = {
33843 (char *) "self",(char *) "variant", NULL
33844 };
33845
33846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33848 if (!SWIG_IsOK(res1)) {
33849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33850 }
33851 arg1 = reinterpret_cast< wxWindow * >(argp1);
33852 ecode2 = SWIG_AsVal_int(obj1, &val2);
33853 if (!SWIG_IsOK(ecode2)) {
33854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33855 }
33856 arg2 = static_cast< wxWindowVariant >(val2);
33857 {
33858 PyThreadState* __tstate = wxPyBeginAllowThreads();
33859 (arg1)->SetWindowVariant(arg2);
33860 wxPyEndAllowThreads(__tstate);
33861 if (PyErr_Occurred()) SWIG_fail;
33862 }
33863 resultobj = SWIG_Py_Void();
33864 return resultobj;
33865 fail:
33866 return NULL;
33867 }
33868
33869
33870 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33871 PyObject *resultobj = 0;
33872 wxWindow *arg1 = (wxWindow *) 0 ;
33873 wxWindowVariant result;
33874 void *argp1 = 0 ;
33875 int res1 = 0 ;
33876 PyObject *swig_obj[1] ;
33877
33878 if (!args) SWIG_fail;
33879 swig_obj[0] = args;
33880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33881 if (!SWIG_IsOK(res1)) {
33882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33883 }
33884 arg1 = reinterpret_cast< wxWindow * >(argp1);
33885 {
33886 PyThreadState* __tstate = wxPyBeginAllowThreads();
33887 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33888 wxPyEndAllowThreads(__tstate);
33889 if (PyErr_Occurred()) SWIG_fail;
33890 }
33891 resultobj = SWIG_From_int(static_cast< int >(result));
33892 return resultobj;
33893 fail:
33894 return NULL;
33895 }
33896
33897
33898 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33899 PyObject *resultobj = 0;
33900 wxWindow *arg1 = (wxWindow *) 0 ;
33901 int arg2 ;
33902 void *argp1 = 0 ;
33903 int res1 = 0 ;
33904 int val2 ;
33905 int ecode2 = 0 ;
33906 PyObject * obj0 = 0 ;
33907 PyObject * obj1 = 0 ;
33908 char * kwnames[] = {
33909 (char *) "self",(char *) "winid", NULL
33910 };
33911
33912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33914 if (!SWIG_IsOK(res1)) {
33915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33916 }
33917 arg1 = reinterpret_cast< wxWindow * >(argp1);
33918 ecode2 = SWIG_AsVal_int(obj1, &val2);
33919 if (!SWIG_IsOK(ecode2)) {
33920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33921 }
33922 arg2 = static_cast< int >(val2);
33923 {
33924 PyThreadState* __tstate = wxPyBeginAllowThreads();
33925 (arg1)->SetId(arg2);
33926 wxPyEndAllowThreads(__tstate);
33927 if (PyErr_Occurred()) SWIG_fail;
33928 }
33929 resultobj = SWIG_Py_Void();
33930 return resultobj;
33931 fail:
33932 return NULL;
33933 }
33934
33935
33936 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33937 PyObject *resultobj = 0;
33938 wxWindow *arg1 = (wxWindow *) 0 ;
33939 int result;
33940 void *argp1 = 0 ;
33941 int res1 = 0 ;
33942 PyObject *swig_obj[1] ;
33943
33944 if (!args) SWIG_fail;
33945 swig_obj[0] = args;
33946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33947 if (!SWIG_IsOK(res1)) {
33948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33949 }
33950 arg1 = reinterpret_cast< wxWindow * >(argp1);
33951 {
33952 PyThreadState* __tstate = wxPyBeginAllowThreads();
33953 result = (int)((wxWindow const *)arg1)->GetId();
33954 wxPyEndAllowThreads(__tstate);
33955 if (PyErr_Occurred()) SWIG_fail;
33956 }
33957 resultobj = SWIG_From_int(static_cast< int >(result));
33958 return resultobj;
33959 fail:
33960 return NULL;
33961 }
33962
33963
33964 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33965 PyObject *resultobj = 0;
33966 int result;
33967
33968 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33969 {
33970 PyThreadState* __tstate = wxPyBeginAllowThreads();
33971 result = (int)wxWindow::NewControlId();
33972 wxPyEndAllowThreads(__tstate);
33973 if (PyErr_Occurred()) SWIG_fail;
33974 }
33975 resultobj = SWIG_From_int(static_cast< int >(result));
33976 return resultobj;
33977 fail:
33978 return NULL;
33979 }
33980
33981
33982 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33983 PyObject *resultobj = 0;
33984 int arg1 ;
33985 int result;
33986 int val1 ;
33987 int ecode1 = 0 ;
33988 PyObject * obj0 = 0 ;
33989 char * kwnames[] = {
33990 (char *) "winid", NULL
33991 };
33992
33993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33994 ecode1 = SWIG_AsVal_int(obj0, &val1);
33995 if (!SWIG_IsOK(ecode1)) {
33996 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33997 }
33998 arg1 = static_cast< int >(val1);
33999 {
34000 PyThreadState* __tstate = wxPyBeginAllowThreads();
34001 result = (int)wxWindow::NextControlId(arg1);
34002 wxPyEndAllowThreads(__tstate);
34003 if (PyErr_Occurred()) SWIG_fail;
34004 }
34005 resultobj = SWIG_From_int(static_cast< int >(result));
34006 return resultobj;
34007 fail:
34008 return NULL;
34009 }
34010
34011
34012 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34013 PyObject *resultobj = 0;
34014 int arg1 ;
34015 int result;
34016 int val1 ;
34017 int ecode1 = 0 ;
34018 PyObject * obj0 = 0 ;
34019 char * kwnames[] = {
34020 (char *) "winid", NULL
34021 };
34022
34023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
34024 ecode1 = SWIG_AsVal_int(obj0, &val1);
34025 if (!SWIG_IsOK(ecode1)) {
34026 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
34027 }
34028 arg1 = static_cast< int >(val1);
34029 {
34030 PyThreadState* __tstate = wxPyBeginAllowThreads();
34031 result = (int)wxWindow::PrevControlId(arg1);
34032 wxPyEndAllowThreads(__tstate);
34033 if (PyErr_Occurred()) SWIG_fail;
34034 }
34035 resultobj = SWIG_From_int(static_cast< int >(result));
34036 return resultobj;
34037 fail:
34038 return NULL;
34039 }
34040
34041
34042 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34043 PyObject *resultobj = 0;
34044 wxWindow *arg1 = (wxWindow *) 0 ;
34045 wxLayoutDirection result;
34046 void *argp1 = 0 ;
34047 int res1 = 0 ;
34048 PyObject *swig_obj[1] ;
34049
34050 if (!args) SWIG_fail;
34051 swig_obj[0] = args;
34052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34053 if (!SWIG_IsOK(res1)) {
34054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
34055 }
34056 arg1 = reinterpret_cast< wxWindow * >(argp1);
34057 {
34058 PyThreadState* __tstate = wxPyBeginAllowThreads();
34059 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
34060 wxPyEndAllowThreads(__tstate);
34061 if (PyErr_Occurred()) SWIG_fail;
34062 }
34063 resultobj = SWIG_From_int(static_cast< int >(result));
34064 return resultobj;
34065 fail:
34066 return NULL;
34067 }
34068
34069
34070 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34071 PyObject *resultobj = 0;
34072 wxWindow *arg1 = (wxWindow *) 0 ;
34073 wxLayoutDirection arg2 ;
34074 void *argp1 = 0 ;
34075 int res1 = 0 ;
34076 int val2 ;
34077 int ecode2 = 0 ;
34078 PyObject * obj0 = 0 ;
34079 PyObject * obj1 = 0 ;
34080 char * kwnames[] = {
34081 (char *) "self",(char *) "dir", NULL
34082 };
34083
34084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
34085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34086 if (!SWIG_IsOK(res1)) {
34087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
34088 }
34089 arg1 = reinterpret_cast< wxWindow * >(argp1);
34090 ecode2 = SWIG_AsVal_int(obj1, &val2);
34091 if (!SWIG_IsOK(ecode2)) {
34092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
34093 }
34094 arg2 = static_cast< wxLayoutDirection >(val2);
34095 {
34096 PyThreadState* __tstate = wxPyBeginAllowThreads();
34097 (arg1)->SetLayoutDirection(arg2);
34098 wxPyEndAllowThreads(__tstate);
34099 if (PyErr_Occurred()) SWIG_fail;
34100 }
34101 resultobj = SWIG_Py_Void();
34102 return resultobj;
34103 fail:
34104 return NULL;
34105 }
34106
34107
34108 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34109 PyObject *resultobj = 0;
34110 wxWindow *arg1 = (wxWindow *) 0 ;
34111 int arg2 ;
34112 int arg3 ;
34113 int arg4 ;
34114 int result;
34115 void *argp1 = 0 ;
34116 int res1 = 0 ;
34117 int val2 ;
34118 int ecode2 = 0 ;
34119 int val3 ;
34120 int ecode3 = 0 ;
34121 int val4 ;
34122 int ecode4 = 0 ;
34123 PyObject * obj0 = 0 ;
34124 PyObject * obj1 = 0 ;
34125 PyObject * obj2 = 0 ;
34126 PyObject * obj3 = 0 ;
34127 char * kwnames[] = {
34128 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
34129 };
34130
34131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34133 if (!SWIG_IsOK(res1)) {
34134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
34135 }
34136 arg1 = reinterpret_cast< wxWindow * >(argp1);
34137 ecode2 = SWIG_AsVal_int(obj1, &val2);
34138 if (!SWIG_IsOK(ecode2)) {
34139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
34140 }
34141 arg2 = static_cast< int >(val2);
34142 ecode3 = SWIG_AsVal_int(obj2, &val3);
34143 if (!SWIG_IsOK(ecode3)) {
34144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
34145 }
34146 arg3 = static_cast< int >(val3);
34147 ecode4 = SWIG_AsVal_int(obj3, &val4);
34148 if (!SWIG_IsOK(ecode4)) {
34149 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
34150 }
34151 arg4 = static_cast< int >(val4);
34152 {
34153 PyThreadState* __tstate = wxPyBeginAllowThreads();
34154 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
34155 wxPyEndAllowThreads(__tstate);
34156 if (PyErr_Occurred()) SWIG_fail;
34157 }
34158 resultobj = SWIG_From_int(static_cast< int >(result));
34159 return resultobj;
34160 fail:
34161 return NULL;
34162 }
34163
34164
34165 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34166 PyObject *resultobj = 0;
34167 wxWindow *arg1 = (wxWindow *) 0 ;
34168 wxSize *arg2 = 0 ;
34169 void *argp1 = 0 ;
34170 int res1 = 0 ;
34171 wxSize temp2 ;
34172 PyObject * obj0 = 0 ;
34173 PyObject * obj1 = 0 ;
34174 char * kwnames[] = {
34175 (char *) "self",(char *) "size", NULL
34176 };
34177
34178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
34179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34180 if (!SWIG_IsOK(res1)) {
34181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34182 }
34183 arg1 = reinterpret_cast< wxWindow * >(argp1);
34184 {
34185 arg2 = &temp2;
34186 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34187 }
34188 {
34189 PyThreadState* __tstate = wxPyBeginAllowThreads();
34190 (arg1)->SetSize((wxSize const &)*arg2);
34191 wxPyEndAllowThreads(__tstate);
34192 if (PyErr_Occurred()) SWIG_fail;
34193 }
34194 resultobj = SWIG_Py_Void();
34195 return resultobj;
34196 fail:
34197 return NULL;
34198 }
34199
34200
34201 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34202 PyObject *resultobj = 0;
34203 wxWindow *arg1 = (wxWindow *) 0 ;
34204 int arg2 ;
34205 int arg3 ;
34206 int arg4 ;
34207 int arg5 ;
34208 int arg6 = (int) wxSIZE_AUTO ;
34209 void *argp1 = 0 ;
34210 int res1 = 0 ;
34211 int val2 ;
34212 int ecode2 = 0 ;
34213 int val3 ;
34214 int ecode3 = 0 ;
34215 int val4 ;
34216 int ecode4 = 0 ;
34217 int val5 ;
34218 int ecode5 = 0 ;
34219 int val6 ;
34220 int ecode6 = 0 ;
34221 PyObject * obj0 = 0 ;
34222 PyObject * obj1 = 0 ;
34223 PyObject * obj2 = 0 ;
34224 PyObject * obj3 = 0 ;
34225 PyObject * obj4 = 0 ;
34226 PyObject * obj5 = 0 ;
34227 char * kwnames[] = {
34228 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
34229 };
34230
34231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
34232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34233 if (!SWIG_IsOK(res1)) {
34234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
34235 }
34236 arg1 = reinterpret_cast< wxWindow * >(argp1);
34237 ecode2 = SWIG_AsVal_int(obj1, &val2);
34238 if (!SWIG_IsOK(ecode2)) {
34239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
34240 }
34241 arg2 = static_cast< int >(val2);
34242 ecode3 = SWIG_AsVal_int(obj2, &val3);
34243 if (!SWIG_IsOK(ecode3)) {
34244 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
34245 }
34246 arg3 = static_cast< int >(val3);
34247 ecode4 = SWIG_AsVal_int(obj3, &val4);
34248 if (!SWIG_IsOK(ecode4)) {
34249 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
34250 }
34251 arg4 = static_cast< int >(val4);
34252 ecode5 = SWIG_AsVal_int(obj4, &val5);
34253 if (!SWIG_IsOK(ecode5)) {
34254 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
34255 }
34256 arg5 = static_cast< int >(val5);
34257 if (obj5) {
34258 ecode6 = SWIG_AsVal_int(obj5, &val6);
34259 if (!SWIG_IsOK(ecode6)) {
34260 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
34261 }
34262 arg6 = static_cast< int >(val6);
34263 }
34264 {
34265 PyThreadState* __tstate = wxPyBeginAllowThreads();
34266 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
34267 wxPyEndAllowThreads(__tstate);
34268 if (PyErr_Occurred()) SWIG_fail;
34269 }
34270 resultobj = SWIG_Py_Void();
34271 return resultobj;
34272 fail:
34273 return NULL;
34274 }
34275
34276
34277 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34278 PyObject *resultobj = 0;
34279 wxWindow *arg1 = (wxWindow *) 0 ;
34280 wxRect *arg2 = 0 ;
34281 int arg3 = (int) wxSIZE_AUTO ;
34282 void *argp1 = 0 ;
34283 int res1 = 0 ;
34284 wxRect temp2 ;
34285 int val3 ;
34286 int ecode3 = 0 ;
34287 PyObject * obj0 = 0 ;
34288 PyObject * obj1 = 0 ;
34289 PyObject * obj2 = 0 ;
34290 char * kwnames[] = {
34291 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
34292 };
34293
34294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34296 if (!SWIG_IsOK(res1)) {
34297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34298 }
34299 arg1 = reinterpret_cast< wxWindow * >(argp1);
34300 {
34301 arg2 = &temp2;
34302 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34303 }
34304 if (obj2) {
34305 ecode3 = SWIG_AsVal_int(obj2, &val3);
34306 if (!SWIG_IsOK(ecode3)) {
34307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
34308 }
34309 arg3 = static_cast< int >(val3);
34310 }
34311 {
34312 PyThreadState* __tstate = wxPyBeginAllowThreads();
34313 (arg1)->SetSize((wxRect const &)*arg2,arg3);
34314 wxPyEndAllowThreads(__tstate);
34315 if (PyErr_Occurred()) SWIG_fail;
34316 }
34317 resultobj = SWIG_Py_Void();
34318 return resultobj;
34319 fail:
34320 return NULL;
34321 }
34322
34323
34324 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34325 PyObject *resultobj = 0;
34326 wxWindow *arg1 = (wxWindow *) 0 ;
34327 int arg2 ;
34328 int arg3 ;
34329 void *argp1 = 0 ;
34330 int res1 = 0 ;
34331 int val2 ;
34332 int ecode2 = 0 ;
34333 int val3 ;
34334 int ecode3 = 0 ;
34335 PyObject * obj0 = 0 ;
34336 PyObject * obj1 = 0 ;
34337 PyObject * obj2 = 0 ;
34338 char * kwnames[] = {
34339 (char *) "self",(char *) "width",(char *) "height", NULL
34340 };
34341
34342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34344 if (!SWIG_IsOK(res1)) {
34345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34346 }
34347 arg1 = reinterpret_cast< wxWindow * >(argp1);
34348 ecode2 = SWIG_AsVal_int(obj1, &val2);
34349 if (!SWIG_IsOK(ecode2)) {
34350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
34351 }
34352 arg2 = static_cast< int >(val2);
34353 ecode3 = SWIG_AsVal_int(obj2, &val3);
34354 if (!SWIG_IsOK(ecode3)) {
34355 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
34356 }
34357 arg3 = static_cast< int >(val3);
34358 {
34359 PyThreadState* __tstate = wxPyBeginAllowThreads();
34360 (arg1)->SetSize(arg2,arg3);
34361 wxPyEndAllowThreads(__tstate);
34362 if (PyErr_Occurred()) SWIG_fail;
34363 }
34364 resultobj = SWIG_Py_Void();
34365 return resultobj;
34366 fail:
34367 return NULL;
34368 }
34369
34370
34371 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34372 PyObject *resultobj = 0;
34373 wxWindow *arg1 = (wxWindow *) 0 ;
34374 wxPoint *arg2 = 0 ;
34375 int arg3 = (int) wxSIZE_USE_EXISTING ;
34376 void *argp1 = 0 ;
34377 int res1 = 0 ;
34378 wxPoint temp2 ;
34379 int val3 ;
34380 int ecode3 = 0 ;
34381 PyObject * obj0 = 0 ;
34382 PyObject * obj1 = 0 ;
34383 PyObject * obj2 = 0 ;
34384 char * kwnames[] = {
34385 (char *) "self",(char *) "pt",(char *) "flags", NULL
34386 };
34387
34388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34390 if (!SWIG_IsOK(res1)) {
34391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
34392 }
34393 arg1 = reinterpret_cast< wxWindow * >(argp1);
34394 {
34395 arg2 = &temp2;
34396 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34397 }
34398 if (obj2) {
34399 ecode3 = SWIG_AsVal_int(obj2, &val3);
34400 if (!SWIG_IsOK(ecode3)) {
34401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
34402 }
34403 arg3 = static_cast< int >(val3);
34404 }
34405 {
34406 PyThreadState* __tstate = wxPyBeginAllowThreads();
34407 (arg1)->Move((wxPoint const &)*arg2,arg3);
34408 wxPyEndAllowThreads(__tstate);
34409 if (PyErr_Occurred()) SWIG_fail;
34410 }
34411 resultobj = SWIG_Py_Void();
34412 return resultobj;
34413 fail:
34414 return NULL;
34415 }
34416
34417
34418 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34419 PyObject *resultobj = 0;
34420 wxWindow *arg1 = (wxWindow *) 0 ;
34421 int arg2 ;
34422 int arg3 ;
34423 int arg4 = (int) wxSIZE_USE_EXISTING ;
34424 void *argp1 = 0 ;
34425 int res1 = 0 ;
34426 int val2 ;
34427 int ecode2 = 0 ;
34428 int val3 ;
34429 int ecode3 = 0 ;
34430 int val4 ;
34431 int ecode4 = 0 ;
34432 PyObject * obj0 = 0 ;
34433 PyObject * obj1 = 0 ;
34434 PyObject * obj2 = 0 ;
34435 PyObject * obj3 = 0 ;
34436 char * kwnames[] = {
34437 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
34438 };
34439
34440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34442 if (!SWIG_IsOK(res1)) {
34443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
34444 }
34445 arg1 = reinterpret_cast< wxWindow * >(argp1);
34446 ecode2 = SWIG_AsVal_int(obj1, &val2);
34447 if (!SWIG_IsOK(ecode2)) {
34448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
34449 }
34450 arg2 = static_cast< int >(val2);
34451 ecode3 = SWIG_AsVal_int(obj2, &val3);
34452 if (!SWIG_IsOK(ecode3)) {
34453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
34454 }
34455 arg3 = static_cast< int >(val3);
34456 if (obj3) {
34457 ecode4 = SWIG_AsVal_int(obj3, &val4);
34458 if (!SWIG_IsOK(ecode4)) {
34459 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
34460 }
34461 arg4 = static_cast< int >(val4);
34462 }
34463 {
34464 PyThreadState* __tstate = wxPyBeginAllowThreads();
34465 (arg1)->Move(arg2,arg3,arg4);
34466 wxPyEndAllowThreads(__tstate);
34467 if (PyErr_Occurred()) SWIG_fail;
34468 }
34469 resultobj = SWIG_Py_Void();
34470 return resultobj;
34471 fail:
34472 return NULL;
34473 }
34474
34475
34476 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34477 PyObject *resultobj = 0;
34478 wxWindow *arg1 = (wxWindow *) 0 ;
34479 wxSize const &arg2_defvalue = wxDefaultSize ;
34480 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
34481 void *argp1 = 0 ;
34482 int res1 = 0 ;
34483 wxSize temp2 ;
34484 PyObject * obj0 = 0 ;
34485 PyObject * obj1 = 0 ;
34486 char * kwnames[] = {
34487 (char *) "self",(char *) "size", NULL
34488 };
34489
34490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
34491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34492 if (!SWIG_IsOK(res1)) {
34493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34494 }
34495 arg1 = reinterpret_cast< wxWindow * >(argp1);
34496 if (obj1) {
34497 {
34498 arg2 = &temp2;
34499 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34500 }
34501 }
34502 {
34503 PyThreadState* __tstate = wxPyBeginAllowThreads();
34504 (arg1)->SetInitialSize((wxSize const &)*arg2);
34505 wxPyEndAllowThreads(__tstate);
34506 if (PyErr_Occurred()) SWIG_fail;
34507 }
34508 resultobj = SWIG_Py_Void();
34509 return resultobj;
34510 fail:
34511 return NULL;
34512 }
34513
34514
34515 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34516 PyObject *resultobj = 0;
34517 wxWindow *arg1 = (wxWindow *) 0 ;
34518 void *argp1 = 0 ;
34519 int res1 = 0 ;
34520 PyObject *swig_obj[1] ;
34521
34522 if (!args) SWIG_fail;
34523 swig_obj[0] = args;
34524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34525 if (!SWIG_IsOK(res1)) {
34526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
34527 }
34528 arg1 = reinterpret_cast< wxWindow * >(argp1);
34529 {
34530 PyThreadState* __tstate = wxPyBeginAllowThreads();
34531 (arg1)->Raise();
34532 wxPyEndAllowThreads(__tstate);
34533 if (PyErr_Occurred()) SWIG_fail;
34534 }
34535 resultobj = SWIG_Py_Void();
34536 return resultobj;
34537 fail:
34538 return NULL;
34539 }
34540
34541
34542 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34543 PyObject *resultobj = 0;
34544 wxWindow *arg1 = (wxWindow *) 0 ;
34545 void *argp1 = 0 ;
34546 int res1 = 0 ;
34547 PyObject *swig_obj[1] ;
34548
34549 if (!args) SWIG_fail;
34550 swig_obj[0] = args;
34551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34552 if (!SWIG_IsOK(res1)) {
34553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
34554 }
34555 arg1 = reinterpret_cast< wxWindow * >(argp1);
34556 {
34557 PyThreadState* __tstate = wxPyBeginAllowThreads();
34558 (arg1)->Lower();
34559 wxPyEndAllowThreads(__tstate);
34560 if (PyErr_Occurred()) SWIG_fail;
34561 }
34562 resultobj = SWIG_Py_Void();
34563 return resultobj;
34564 fail:
34565 return NULL;
34566 }
34567
34568
34569 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34570 PyObject *resultobj = 0;
34571 wxWindow *arg1 = (wxWindow *) 0 ;
34572 wxSize *arg2 = 0 ;
34573 void *argp1 = 0 ;
34574 int res1 = 0 ;
34575 wxSize temp2 ;
34576 PyObject * obj0 = 0 ;
34577 PyObject * obj1 = 0 ;
34578 char * kwnames[] = {
34579 (char *) "self",(char *) "size", NULL
34580 };
34581
34582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
34583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34584 if (!SWIG_IsOK(res1)) {
34585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34586 }
34587 arg1 = reinterpret_cast< wxWindow * >(argp1);
34588 {
34589 arg2 = &temp2;
34590 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34591 }
34592 {
34593 PyThreadState* __tstate = wxPyBeginAllowThreads();
34594 (arg1)->SetClientSize((wxSize const &)*arg2);
34595 wxPyEndAllowThreads(__tstate);
34596 if (PyErr_Occurred()) SWIG_fail;
34597 }
34598 resultobj = SWIG_Py_Void();
34599 return resultobj;
34600 fail:
34601 return NULL;
34602 }
34603
34604
34605 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34606 PyObject *resultobj = 0;
34607 wxWindow *arg1 = (wxWindow *) 0 ;
34608 int arg2 ;
34609 int arg3 ;
34610 void *argp1 = 0 ;
34611 int res1 = 0 ;
34612 int val2 ;
34613 int ecode2 = 0 ;
34614 int val3 ;
34615 int ecode3 = 0 ;
34616 PyObject * obj0 = 0 ;
34617 PyObject * obj1 = 0 ;
34618 PyObject * obj2 = 0 ;
34619 char * kwnames[] = {
34620 (char *) "self",(char *) "width",(char *) "height", NULL
34621 };
34622
34623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34625 if (!SWIG_IsOK(res1)) {
34626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34627 }
34628 arg1 = reinterpret_cast< wxWindow * >(argp1);
34629 ecode2 = SWIG_AsVal_int(obj1, &val2);
34630 if (!SWIG_IsOK(ecode2)) {
34631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34632 }
34633 arg2 = static_cast< int >(val2);
34634 ecode3 = SWIG_AsVal_int(obj2, &val3);
34635 if (!SWIG_IsOK(ecode3)) {
34636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34637 }
34638 arg3 = static_cast< int >(val3);
34639 {
34640 PyThreadState* __tstate = wxPyBeginAllowThreads();
34641 (arg1)->SetClientSize(arg2,arg3);
34642 wxPyEndAllowThreads(__tstate);
34643 if (PyErr_Occurred()) SWIG_fail;
34644 }
34645 resultobj = SWIG_Py_Void();
34646 return resultobj;
34647 fail:
34648 return NULL;
34649 }
34650
34651
34652 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34653 PyObject *resultobj = 0;
34654 wxWindow *arg1 = (wxWindow *) 0 ;
34655 wxRect *arg2 = 0 ;
34656 void *argp1 = 0 ;
34657 int res1 = 0 ;
34658 wxRect temp2 ;
34659 PyObject * obj0 = 0 ;
34660 PyObject * obj1 = 0 ;
34661 char * kwnames[] = {
34662 (char *) "self",(char *) "rect", NULL
34663 };
34664
34665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34667 if (!SWIG_IsOK(res1)) {
34668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34669 }
34670 arg1 = reinterpret_cast< wxWindow * >(argp1);
34671 {
34672 arg2 = &temp2;
34673 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34674 }
34675 {
34676 PyThreadState* __tstate = wxPyBeginAllowThreads();
34677 (arg1)->SetClientSize((wxRect const &)*arg2);
34678 wxPyEndAllowThreads(__tstate);
34679 if (PyErr_Occurred()) SWIG_fail;
34680 }
34681 resultobj = SWIG_Py_Void();
34682 return resultobj;
34683 fail:
34684 return NULL;
34685 }
34686
34687
34688 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34689 PyObject *resultobj = 0;
34690 wxWindow *arg1 = (wxWindow *) 0 ;
34691 wxPoint result;
34692 void *argp1 = 0 ;
34693 int res1 = 0 ;
34694 PyObject *swig_obj[1] ;
34695
34696 if (!args) SWIG_fail;
34697 swig_obj[0] = args;
34698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34699 if (!SWIG_IsOK(res1)) {
34700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34701 }
34702 arg1 = reinterpret_cast< wxWindow * >(argp1);
34703 {
34704 PyThreadState* __tstate = wxPyBeginAllowThreads();
34705 result = ((wxWindow const *)arg1)->GetPosition();
34706 wxPyEndAllowThreads(__tstate);
34707 if (PyErr_Occurred()) SWIG_fail;
34708 }
34709 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34710 return resultobj;
34711 fail:
34712 return NULL;
34713 }
34714
34715
34716 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34717 PyObject *resultobj = 0;
34718 wxWindow *arg1 = (wxWindow *) 0 ;
34719 int *arg2 = (int *) 0 ;
34720 int *arg3 = (int *) 0 ;
34721 void *argp1 = 0 ;
34722 int res1 = 0 ;
34723 int temp2 ;
34724 int res2 = SWIG_TMPOBJ ;
34725 int temp3 ;
34726 int res3 = SWIG_TMPOBJ ;
34727 PyObject *swig_obj[1] ;
34728
34729 arg2 = &temp2;
34730 arg3 = &temp3;
34731 if (!args) SWIG_fail;
34732 swig_obj[0] = args;
34733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34734 if (!SWIG_IsOK(res1)) {
34735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34736 }
34737 arg1 = reinterpret_cast< wxWindow * >(argp1);
34738 {
34739 PyThreadState* __tstate = wxPyBeginAllowThreads();
34740 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34741 wxPyEndAllowThreads(__tstate);
34742 if (PyErr_Occurred()) SWIG_fail;
34743 }
34744 resultobj = SWIG_Py_Void();
34745 if (SWIG_IsTmpObj(res2)) {
34746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34747 } else {
34748 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34750 }
34751 if (SWIG_IsTmpObj(res3)) {
34752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34753 } else {
34754 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34755 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34756 }
34757 return resultobj;
34758 fail:
34759 return NULL;
34760 }
34761
34762
34763 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34764 PyObject *resultobj = 0;
34765 wxWindow *arg1 = (wxWindow *) 0 ;
34766 wxPoint result;
34767 void *argp1 = 0 ;
34768 int res1 = 0 ;
34769 PyObject *swig_obj[1] ;
34770
34771 if (!args) SWIG_fail;
34772 swig_obj[0] = args;
34773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34774 if (!SWIG_IsOK(res1)) {
34775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34776 }
34777 arg1 = reinterpret_cast< wxWindow * >(argp1);
34778 {
34779 PyThreadState* __tstate = wxPyBeginAllowThreads();
34780 result = ((wxWindow const *)arg1)->GetScreenPosition();
34781 wxPyEndAllowThreads(__tstate);
34782 if (PyErr_Occurred()) SWIG_fail;
34783 }
34784 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34785 return resultobj;
34786 fail:
34787 return NULL;
34788 }
34789
34790
34791 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34792 PyObject *resultobj = 0;
34793 wxWindow *arg1 = (wxWindow *) 0 ;
34794 int *arg2 = (int *) 0 ;
34795 int *arg3 = (int *) 0 ;
34796 void *argp1 = 0 ;
34797 int res1 = 0 ;
34798 int temp2 ;
34799 int res2 = SWIG_TMPOBJ ;
34800 int temp3 ;
34801 int res3 = SWIG_TMPOBJ ;
34802 PyObject *swig_obj[1] ;
34803
34804 arg2 = &temp2;
34805 arg3 = &temp3;
34806 if (!args) SWIG_fail;
34807 swig_obj[0] = args;
34808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34809 if (!SWIG_IsOK(res1)) {
34810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34811 }
34812 arg1 = reinterpret_cast< wxWindow * >(argp1);
34813 {
34814 PyThreadState* __tstate = wxPyBeginAllowThreads();
34815 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34816 wxPyEndAllowThreads(__tstate);
34817 if (PyErr_Occurred()) SWIG_fail;
34818 }
34819 resultobj = SWIG_Py_Void();
34820 if (SWIG_IsTmpObj(res2)) {
34821 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34822 } else {
34823 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34824 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34825 }
34826 if (SWIG_IsTmpObj(res3)) {
34827 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34828 } else {
34829 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34830 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34831 }
34832 return resultobj;
34833 fail:
34834 return NULL;
34835 }
34836
34837
34838 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34839 PyObject *resultobj = 0;
34840 wxWindow *arg1 = (wxWindow *) 0 ;
34841 wxRect result;
34842 void *argp1 = 0 ;
34843 int res1 = 0 ;
34844 PyObject *swig_obj[1] ;
34845
34846 if (!args) SWIG_fail;
34847 swig_obj[0] = args;
34848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34849 if (!SWIG_IsOK(res1)) {
34850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34851 }
34852 arg1 = reinterpret_cast< wxWindow * >(argp1);
34853 {
34854 PyThreadState* __tstate = wxPyBeginAllowThreads();
34855 result = ((wxWindow const *)arg1)->GetScreenRect();
34856 wxPyEndAllowThreads(__tstate);
34857 if (PyErr_Occurred()) SWIG_fail;
34858 }
34859 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34860 return resultobj;
34861 fail:
34862 return NULL;
34863 }
34864
34865
34866 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34867 PyObject *resultobj = 0;
34868 wxWindow *arg1 = (wxWindow *) 0 ;
34869 wxSize result;
34870 void *argp1 = 0 ;
34871 int res1 = 0 ;
34872 PyObject *swig_obj[1] ;
34873
34874 if (!args) SWIG_fail;
34875 swig_obj[0] = args;
34876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34877 if (!SWIG_IsOK(res1)) {
34878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34879 }
34880 arg1 = reinterpret_cast< wxWindow * >(argp1);
34881 {
34882 PyThreadState* __tstate = wxPyBeginAllowThreads();
34883 result = ((wxWindow const *)arg1)->GetSize();
34884 wxPyEndAllowThreads(__tstate);
34885 if (PyErr_Occurred()) SWIG_fail;
34886 }
34887 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34888 return resultobj;
34889 fail:
34890 return NULL;
34891 }
34892
34893
34894 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34895 PyObject *resultobj = 0;
34896 wxWindow *arg1 = (wxWindow *) 0 ;
34897 int *arg2 = (int *) 0 ;
34898 int *arg3 = (int *) 0 ;
34899 void *argp1 = 0 ;
34900 int res1 = 0 ;
34901 int temp2 ;
34902 int res2 = SWIG_TMPOBJ ;
34903 int temp3 ;
34904 int res3 = SWIG_TMPOBJ ;
34905 PyObject *swig_obj[1] ;
34906
34907 arg2 = &temp2;
34908 arg3 = &temp3;
34909 if (!args) SWIG_fail;
34910 swig_obj[0] = args;
34911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34912 if (!SWIG_IsOK(res1)) {
34913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34914 }
34915 arg1 = reinterpret_cast< wxWindow * >(argp1);
34916 {
34917 PyThreadState* __tstate = wxPyBeginAllowThreads();
34918 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34919 wxPyEndAllowThreads(__tstate);
34920 if (PyErr_Occurred()) SWIG_fail;
34921 }
34922 resultobj = SWIG_Py_Void();
34923 if (SWIG_IsTmpObj(res2)) {
34924 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34925 } else {
34926 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34927 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34928 }
34929 if (SWIG_IsTmpObj(res3)) {
34930 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34931 } else {
34932 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34933 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34934 }
34935 return resultobj;
34936 fail:
34937 return NULL;
34938 }
34939
34940
34941 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34942 PyObject *resultobj = 0;
34943 wxWindow *arg1 = (wxWindow *) 0 ;
34944 wxRect result;
34945 void *argp1 = 0 ;
34946 int res1 = 0 ;
34947 PyObject *swig_obj[1] ;
34948
34949 if (!args) SWIG_fail;
34950 swig_obj[0] = args;
34951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34952 if (!SWIG_IsOK(res1)) {
34953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34954 }
34955 arg1 = reinterpret_cast< wxWindow * >(argp1);
34956 {
34957 PyThreadState* __tstate = wxPyBeginAllowThreads();
34958 result = ((wxWindow const *)arg1)->GetRect();
34959 wxPyEndAllowThreads(__tstate);
34960 if (PyErr_Occurred()) SWIG_fail;
34961 }
34962 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34963 return resultobj;
34964 fail:
34965 return NULL;
34966 }
34967
34968
34969 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34970 PyObject *resultobj = 0;
34971 wxWindow *arg1 = (wxWindow *) 0 ;
34972 wxSize result;
34973 void *argp1 = 0 ;
34974 int res1 = 0 ;
34975 PyObject *swig_obj[1] ;
34976
34977 if (!args) SWIG_fail;
34978 swig_obj[0] = args;
34979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34980 if (!SWIG_IsOK(res1)) {
34981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34982 }
34983 arg1 = reinterpret_cast< wxWindow * >(argp1);
34984 {
34985 PyThreadState* __tstate = wxPyBeginAllowThreads();
34986 result = ((wxWindow const *)arg1)->GetClientSize();
34987 wxPyEndAllowThreads(__tstate);
34988 if (PyErr_Occurred()) SWIG_fail;
34989 }
34990 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34991 return resultobj;
34992 fail:
34993 return NULL;
34994 }
34995
34996
34997 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34998 PyObject *resultobj = 0;
34999 wxWindow *arg1 = (wxWindow *) 0 ;
35000 int *arg2 = (int *) 0 ;
35001 int *arg3 = (int *) 0 ;
35002 void *argp1 = 0 ;
35003 int res1 = 0 ;
35004 int temp2 ;
35005 int res2 = SWIG_TMPOBJ ;
35006 int temp3 ;
35007 int res3 = SWIG_TMPOBJ ;
35008 PyObject *swig_obj[1] ;
35009
35010 arg2 = &temp2;
35011 arg3 = &temp3;
35012 if (!args) SWIG_fail;
35013 swig_obj[0] = args;
35014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35015 if (!SWIG_IsOK(res1)) {
35016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35017 }
35018 arg1 = reinterpret_cast< wxWindow * >(argp1);
35019 {
35020 PyThreadState* __tstate = wxPyBeginAllowThreads();
35021 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
35022 wxPyEndAllowThreads(__tstate);
35023 if (PyErr_Occurred()) SWIG_fail;
35024 }
35025 resultobj = SWIG_Py_Void();
35026 if (SWIG_IsTmpObj(res2)) {
35027 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35028 } else {
35029 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35030 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35031 }
35032 if (SWIG_IsTmpObj(res3)) {
35033 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35034 } else {
35035 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35036 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35037 }
35038 return resultobj;
35039 fail:
35040 return NULL;
35041 }
35042
35043
35044 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35045 PyObject *resultobj = 0;
35046 wxWindow *arg1 = (wxWindow *) 0 ;
35047 wxPoint result;
35048 void *argp1 = 0 ;
35049 int res1 = 0 ;
35050 PyObject *swig_obj[1] ;
35051
35052 if (!args) SWIG_fail;
35053 swig_obj[0] = args;
35054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35055 if (!SWIG_IsOK(res1)) {
35056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
35057 }
35058 arg1 = reinterpret_cast< wxWindow * >(argp1);
35059 {
35060 PyThreadState* __tstate = wxPyBeginAllowThreads();
35061 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
35062 wxPyEndAllowThreads(__tstate);
35063 if (PyErr_Occurred()) SWIG_fail;
35064 }
35065 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35066 return resultobj;
35067 fail:
35068 return NULL;
35069 }
35070
35071
35072 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35073 PyObject *resultobj = 0;
35074 wxWindow *arg1 = (wxWindow *) 0 ;
35075 wxRect result;
35076 void *argp1 = 0 ;
35077 int res1 = 0 ;
35078 PyObject *swig_obj[1] ;
35079
35080 if (!args) SWIG_fail;
35081 swig_obj[0] = args;
35082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35083 if (!SWIG_IsOK(res1)) {
35084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35085 }
35086 arg1 = reinterpret_cast< wxWindow * >(argp1);
35087 {
35088 PyThreadState* __tstate = wxPyBeginAllowThreads();
35089 result = ((wxWindow const *)arg1)->GetClientRect();
35090 wxPyEndAllowThreads(__tstate);
35091 if (PyErr_Occurred()) SWIG_fail;
35092 }
35093 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35094 return resultobj;
35095 fail:
35096 return NULL;
35097 }
35098
35099
35100 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35101 PyObject *resultobj = 0;
35102 wxWindow *arg1 = (wxWindow *) 0 ;
35103 wxSize result;
35104 void *argp1 = 0 ;
35105 int res1 = 0 ;
35106 PyObject *swig_obj[1] ;
35107
35108 if (!args) SWIG_fail;
35109 swig_obj[0] = args;
35110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35111 if (!SWIG_IsOK(res1)) {
35112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35113 }
35114 arg1 = reinterpret_cast< wxWindow * >(argp1);
35115 {
35116 PyThreadState* __tstate = wxPyBeginAllowThreads();
35117 result = ((wxWindow const *)arg1)->GetBestSize();
35118 wxPyEndAllowThreads(__tstate);
35119 if (PyErr_Occurred()) SWIG_fail;
35120 }
35121 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35122 return resultobj;
35123 fail:
35124 return NULL;
35125 }
35126
35127
35128 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35129 PyObject *resultobj = 0;
35130 wxWindow *arg1 = (wxWindow *) 0 ;
35131 int *arg2 = (int *) 0 ;
35132 int *arg3 = (int *) 0 ;
35133 void *argp1 = 0 ;
35134 int res1 = 0 ;
35135 int temp2 ;
35136 int res2 = SWIG_TMPOBJ ;
35137 int temp3 ;
35138 int res3 = SWIG_TMPOBJ ;
35139 PyObject *swig_obj[1] ;
35140
35141 arg2 = &temp2;
35142 arg3 = &temp3;
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_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35148 }
35149 arg1 = reinterpret_cast< wxWindow * >(argp1);
35150 {
35151 PyThreadState* __tstate = wxPyBeginAllowThreads();
35152 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
35153 wxPyEndAllowThreads(__tstate);
35154 if (PyErr_Occurred()) SWIG_fail;
35155 }
35156 resultobj = SWIG_Py_Void();
35157 if (SWIG_IsTmpObj(res2)) {
35158 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35159 } else {
35160 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35161 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35162 }
35163 if (SWIG_IsTmpObj(res3)) {
35164 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35165 } else {
35166 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35167 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35168 }
35169 return resultobj;
35170 fail:
35171 return NULL;
35172 }
35173
35174
35175 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35176 PyObject *resultobj = 0;
35177 wxWindow *arg1 = (wxWindow *) 0 ;
35178 void *argp1 = 0 ;
35179 int res1 = 0 ;
35180 PyObject *swig_obj[1] ;
35181
35182 if (!args) SWIG_fail;
35183 swig_obj[0] = args;
35184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35185 if (!SWIG_IsOK(res1)) {
35186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35187 }
35188 arg1 = reinterpret_cast< wxWindow * >(argp1);
35189 {
35190 PyThreadState* __tstate = wxPyBeginAllowThreads();
35191 (arg1)->InvalidateBestSize();
35192 wxPyEndAllowThreads(__tstate);
35193 if (PyErr_Occurred()) SWIG_fail;
35194 }
35195 resultobj = SWIG_Py_Void();
35196 return resultobj;
35197 fail:
35198 return NULL;
35199 }
35200
35201
35202 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35203 PyObject *resultobj = 0;
35204 wxWindow *arg1 = (wxWindow *) 0 ;
35205 wxSize *arg2 = 0 ;
35206 void *argp1 = 0 ;
35207 int res1 = 0 ;
35208 wxSize temp2 ;
35209 PyObject * obj0 = 0 ;
35210 PyObject * obj1 = 0 ;
35211 char * kwnames[] = {
35212 (char *) "self",(char *) "size", NULL
35213 };
35214
35215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
35216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35217 if (!SWIG_IsOK(res1)) {
35218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35219 }
35220 arg1 = reinterpret_cast< wxWindow * >(argp1);
35221 {
35222 arg2 = &temp2;
35223 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35224 }
35225 {
35226 PyThreadState* __tstate = wxPyBeginAllowThreads();
35227 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
35228 wxPyEndAllowThreads(__tstate);
35229 if (PyErr_Occurred()) SWIG_fail;
35230 }
35231 resultobj = SWIG_Py_Void();
35232 return resultobj;
35233 fail:
35234 return NULL;
35235 }
35236
35237
35238 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35239 PyObject *resultobj = 0;
35240 wxWindow *arg1 = (wxWindow *) 0 ;
35241 wxSize result;
35242 void *argp1 = 0 ;
35243 int res1 = 0 ;
35244 PyObject *swig_obj[1] ;
35245
35246 if (!args) SWIG_fail;
35247 swig_obj[0] = args;
35248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35249 if (!SWIG_IsOK(res1)) {
35250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35251 }
35252 arg1 = reinterpret_cast< wxWindow * >(argp1);
35253 {
35254 PyThreadState* __tstate = wxPyBeginAllowThreads();
35255 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
35256 wxPyEndAllowThreads(__tstate);
35257 if (PyErr_Occurred()) SWIG_fail;
35258 }
35259 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35260 return resultobj;
35261 fail:
35262 return NULL;
35263 }
35264
35265
35266 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35267 PyObject *resultobj = 0;
35268 wxWindow *arg1 = (wxWindow *) 0 ;
35269 int arg2 = (int) wxBOTH ;
35270 void *argp1 = 0 ;
35271 int res1 = 0 ;
35272 int val2 ;
35273 int ecode2 = 0 ;
35274 PyObject * obj0 = 0 ;
35275 PyObject * obj1 = 0 ;
35276 char * kwnames[] = {
35277 (char *) "self",(char *) "direction", NULL
35278 };
35279
35280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
35281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35282 if (!SWIG_IsOK(res1)) {
35283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
35284 }
35285 arg1 = reinterpret_cast< wxWindow * >(argp1);
35286 if (obj1) {
35287 ecode2 = SWIG_AsVal_int(obj1, &val2);
35288 if (!SWIG_IsOK(ecode2)) {
35289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
35290 }
35291 arg2 = static_cast< int >(val2);
35292 }
35293 {
35294 PyThreadState* __tstate = wxPyBeginAllowThreads();
35295 (arg1)->Center(arg2);
35296 wxPyEndAllowThreads(__tstate);
35297 if (PyErr_Occurred()) SWIG_fail;
35298 }
35299 resultobj = SWIG_Py_Void();
35300 return resultobj;
35301 fail:
35302 return NULL;
35303 }
35304
35305
35306 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35307 PyObject *resultobj = 0;
35308 wxWindow *arg1 = (wxWindow *) 0 ;
35309 int arg2 = (int) wxBOTH ;
35310 void *argp1 = 0 ;
35311 int res1 = 0 ;
35312 int val2 ;
35313 int ecode2 = 0 ;
35314 PyObject * obj0 = 0 ;
35315 PyObject * obj1 = 0 ;
35316 char * kwnames[] = {
35317 (char *) "self",(char *) "dir", NULL
35318 };
35319
35320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
35321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35322 if (!SWIG_IsOK(res1)) {
35323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
35324 }
35325 arg1 = reinterpret_cast< wxWindow * >(argp1);
35326 if (obj1) {
35327 ecode2 = SWIG_AsVal_int(obj1, &val2);
35328 if (!SWIG_IsOK(ecode2)) {
35329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
35330 }
35331 arg2 = static_cast< int >(val2);
35332 }
35333 {
35334 PyThreadState* __tstate = wxPyBeginAllowThreads();
35335 (arg1)->CenterOnParent(arg2);
35336 wxPyEndAllowThreads(__tstate);
35337 if (PyErr_Occurred()) SWIG_fail;
35338 }
35339 resultobj = SWIG_Py_Void();
35340 return resultobj;
35341 fail:
35342 return NULL;
35343 }
35344
35345
35346 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35347 PyObject *resultobj = 0;
35348 wxWindow *arg1 = (wxWindow *) 0 ;
35349 void *argp1 = 0 ;
35350 int res1 = 0 ;
35351 PyObject *swig_obj[1] ;
35352
35353 if (!args) SWIG_fail;
35354 swig_obj[0] = args;
35355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35356 if (!SWIG_IsOK(res1)) {
35357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
35358 }
35359 arg1 = reinterpret_cast< wxWindow * >(argp1);
35360 {
35361 PyThreadState* __tstate = wxPyBeginAllowThreads();
35362 (arg1)->Fit();
35363 wxPyEndAllowThreads(__tstate);
35364 if (PyErr_Occurred()) SWIG_fail;
35365 }
35366 resultobj = SWIG_Py_Void();
35367 return resultobj;
35368 fail:
35369 return NULL;
35370 }
35371
35372
35373 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35374 PyObject *resultobj = 0;
35375 wxWindow *arg1 = (wxWindow *) 0 ;
35376 void *argp1 = 0 ;
35377 int res1 = 0 ;
35378 PyObject *swig_obj[1] ;
35379
35380 if (!args) SWIG_fail;
35381 swig_obj[0] = args;
35382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35383 if (!SWIG_IsOK(res1)) {
35384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
35385 }
35386 arg1 = reinterpret_cast< wxWindow * >(argp1);
35387 {
35388 PyThreadState* __tstate = wxPyBeginAllowThreads();
35389 (arg1)->FitInside();
35390 wxPyEndAllowThreads(__tstate);
35391 if (PyErr_Occurred()) SWIG_fail;
35392 }
35393 resultobj = SWIG_Py_Void();
35394 return resultobj;
35395 fail:
35396 return NULL;
35397 }
35398
35399
35400 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35401 PyObject *resultobj = 0;
35402 wxWindow *arg1 = (wxWindow *) 0 ;
35403 int arg2 ;
35404 int arg3 ;
35405 int arg4 = (int) -1 ;
35406 int arg5 = (int) -1 ;
35407 int arg6 = (int) -1 ;
35408 int arg7 = (int) -1 ;
35409 void *argp1 = 0 ;
35410 int res1 = 0 ;
35411 int val2 ;
35412 int ecode2 = 0 ;
35413 int val3 ;
35414 int ecode3 = 0 ;
35415 int val4 ;
35416 int ecode4 = 0 ;
35417 int val5 ;
35418 int ecode5 = 0 ;
35419 int val6 ;
35420 int ecode6 = 0 ;
35421 int val7 ;
35422 int ecode7 = 0 ;
35423 PyObject * obj0 = 0 ;
35424 PyObject * obj1 = 0 ;
35425 PyObject * obj2 = 0 ;
35426 PyObject * obj3 = 0 ;
35427 PyObject * obj4 = 0 ;
35428 PyObject * obj5 = 0 ;
35429 PyObject * obj6 = 0 ;
35430 char * kwnames[] = {
35431 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
35432 };
35433
35434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
35435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35436 if (!SWIG_IsOK(res1)) {
35437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35438 }
35439 arg1 = reinterpret_cast< wxWindow * >(argp1);
35440 ecode2 = SWIG_AsVal_int(obj1, &val2);
35441 if (!SWIG_IsOK(ecode2)) {
35442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
35443 }
35444 arg2 = static_cast< int >(val2);
35445 ecode3 = SWIG_AsVal_int(obj2, &val3);
35446 if (!SWIG_IsOK(ecode3)) {
35447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
35448 }
35449 arg3 = static_cast< int >(val3);
35450 if (obj3) {
35451 ecode4 = SWIG_AsVal_int(obj3, &val4);
35452 if (!SWIG_IsOK(ecode4)) {
35453 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
35454 }
35455 arg4 = static_cast< int >(val4);
35456 }
35457 if (obj4) {
35458 ecode5 = SWIG_AsVal_int(obj4, &val5);
35459 if (!SWIG_IsOK(ecode5)) {
35460 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
35461 }
35462 arg5 = static_cast< int >(val5);
35463 }
35464 if (obj5) {
35465 ecode6 = SWIG_AsVal_int(obj5, &val6);
35466 if (!SWIG_IsOK(ecode6)) {
35467 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
35468 }
35469 arg6 = static_cast< int >(val6);
35470 }
35471 if (obj6) {
35472 ecode7 = SWIG_AsVal_int(obj6, &val7);
35473 if (!SWIG_IsOK(ecode7)) {
35474 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
35475 }
35476 arg7 = static_cast< int >(val7);
35477 }
35478 {
35479 PyThreadState* __tstate = wxPyBeginAllowThreads();
35480 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
35481 wxPyEndAllowThreads(__tstate);
35482 if (PyErr_Occurred()) SWIG_fail;
35483 }
35484 resultobj = SWIG_Py_Void();
35485 return resultobj;
35486 fail:
35487 return NULL;
35488 }
35489
35490
35491 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35492 PyObject *resultobj = 0;
35493 wxWindow *arg1 = (wxWindow *) 0 ;
35494 wxSize *arg2 = 0 ;
35495 wxSize const &arg3_defvalue = wxDefaultSize ;
35496 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35497 wxSize const &arg4_defvalue = wxDefaultSize ;
35498 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
35499 void *argp1 = 0 ;
35500 int res1 = 0 ;
35501 wxSize temp2 ;
35502 wxSize temp3 ;
35503 wxSize temp4 ;
35504 PyObject * obj0 = 0 ;
35505 PyObject * obj1 = 0 ;
35506 PyObject * obj2 = 0 ;
35507 PyObject * obj3 = 0 ;
35508 char * kwnames[] = {
35509 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
35510 };
35511
35512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35514 if (!SWIG_IsOK(res1)) {
35515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35516 }
35517 arg1 = reinterpret_cast< wxWindow * >(argp1);
35518 {
35519 arg2 = &temp2;
35520 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35521 }
35522 if (obj2) {
35523 {
35524 arg3 = &temp3;
35525 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35526 }
35527 }
35528 if (obj3) {
35529 {
35530 arg4 = &temp4;
35531 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
35532 }
35533 }
35534 {
35535 PyThreadState* __tstate = wxPyBeginAllowThreads();
35536 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
35537 wxPyEndAllowThreads(__tstate);
35538 if (PyErr_Occurred()) SWIG_fail;
35539 }
35540 resultobj = SWIG_Py_Void();
35541 return resultobj;
35542 fail:
35543 return NULL;
35544 }
35545
35546
35547 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35548 PyObject *resultobj = 0;
35549 wxWindow *arg1 = (wxWindow *) 0 ;
35550 int arg2 ;
35551 int arg3 ;
35552 int arg4 = (int) -1 ;
35553 int arg5 = (int) -1 ;
35554 void *argp1 = 0 ;
35555 int res1 = 0 ;
35556 int val2 ;
35557 int ecode2 = 0 ;
35558 int val3 ;
35559 int ecode3 = 0 ;
35560 int val4 ;
35561 int ecode4 = 0 ;
35562 int val5 ;
35563 int ecode5 = 0 ;
35564 PyObject * obj0 = 0 ;
35565 PyObject * obj1 = 0 ;
35566 PyObject * obj2 = 0 ;
35567 PyObject * obj3 = 0 ;
35568 PyObject * obj4 = 0 ;
35569 char * kwnames[] = {
35570 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
35571 };
35572
35573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35575 if (!SWIG_IsOK(res1)) {
35576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35577 }
35578 arg1 = reinterpret_cast< wxWindow * >(argp1);
35579 ecode2 = SWIG_AsVal_int(obj1, &val2);
35580 if (!SWIG_IsOK(ecode2)) {
35581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
35582 }
35583 arg2 = static_cast< int >(val2);
35584 ecode3 = SWIG_AsVal_int(obj2, &val3);
35585 if (!SWIG_IsOK(ecode3)) {
35586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
35587 }
35588 arg3 = static_cast< int >(val3);
35589 if (obj3) {
35590 ecode4 = SWIG_AsVal_int(obj3, &val4);
35591 if (!SWIG_IsOK(ecode4)) {
35592 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35593 }
35594 arg4 = static_cast< int >(val4);
35595 }
35596 if (obj4) {
35597 ecode5 = SWIG_AsVal_int(obj4, &val5);
35598 if (!SWIG_IsOK(ecode5)) {
35599 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35600 }
35601 arg5 = static_cast< int >(val5);
35602 }
35603 {
35604 PyThreadState* __tstate = wxPyBeginAllowThreads();
35605 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35606 wxPyEndAllowThreads(__tstate);
35607 if (PyErr_Occurred()) SWIG_fail;
35608 }
35609 resultobj = SWIG_Py_Void();
35610 return resultobj;
35611 fail:
35612 return NULL;
35613 }
35614
35615
35616 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35617 PyObject *resultobj = 0;
35618 wxWindow *arg1 = (wxWindow *) 0 ;
35619 wxSize *arg2 = 0 ;
35620 wxSize const &arg3_defvalue = wxDefaultSize ;
35621 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35622 void *argp1 = 0 ;
35623 int res1 = 0 ;
35624 wxSize temp2 ;
35625 wxSize temp3 ;
35626 PyObject * obj0 = 0 ;
35627 PyObject * obj1 = 0 ;
35628 PyObject * obj2 = 0 ;
35629 char * kwnames[] = {
35630 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35631 };
35632
35633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35635 if (!SWIG_IsOK(res1)) {
35636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35637 }
35638 arg1 = reinterpret_cast< wxWindow * >(argp1);
35639 {
35640 arg2 = &temp2;
35641 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35642 }
35643 if (obj2) {
35644 {
35645 arg3 = &temp3;
35646 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35647 }
35648 }
35649 {
35650 PyThreadState* __tstate = wxPyBeginAllowThreads();
35651 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35652 wxPyEndAllowThreads(__tstate);
35653 if (PyErr_Occurred()) SWIG_fail;
35654 }
35655 resultobj = SWIG_Py_Void();
35656 return resultobj;
35657 fail:
35658 return NULL;
35659 }
35660
35661
35662 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35663 PyObject *resultobj = 0;
35664 wxWindow *arg1 = (wxWindow *) 0 ;
35665 wxSize result;
35666 void *argp1 = 0 ;
35667 int res1 = 0 ;
35668 PyObject *swig_obj[1] ;
35669
35670 if (!args) SWIG_fail;
35671 swig_obj[0] = args;
35672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35673 if (!SWIG_IsOK(res1)) {
35674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35675 }
35676 arg1 = reinterpret_cast< wxWindow * >(argp1);
35677 {
35678 PyThreadState* __tstate = wxPyBeginAllowThreads();
35679 result = ((wxWindow const *)arg1)->GetMaxSize();
35680 wxPyEndAllowThreads(__tstate);
35681 if (PyErr_Occurred()) SWIG_fail;
35682 }
35683 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35684 return resultobj;
35685 fail:
35686 return NULL;
35687 }
35688
35689
35690 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35691 PyObject *resultobj = 0;
35692 wxWindow *arg1 = (wxWindow *) 0 ;
35693 wxSize result;
35694 void *argp1 = 0 ;
35695 int res1 = 0 ;
35696 PyObject *swig_obj[1] ;
35697
35698 if (!args) SWIG_fail;
35699 swig_obj[0] = args;
35700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35701 if (!SWIG_IsOK(res1)) {
35702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35703 }
35704 arg1 = reinterpret_cast< wxWindow * >(argp1);
35705 {
35706 PyThreadState* __tstate = wxPyBeginAllowThreads();
35707 result = ((wxWindow const *)arg1)->GetMinSize();
35708 wxPyEndAllowThreads(__tstate);
35709 if (PyErr_Occurred()) SWIG_fail;
35710 }
35711 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35712 return resultobj;
35713 fail:
35714 return NULL;
35715 }
35716
35717
35718 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35719 PyObject *resultobj = 0;
35720 wxWindow *arg1 = (wxWindow *) 0 ;
35721 wxSize *arg2 = 0 ;
35722 void *argp1 = 0 ;
35723 int res1 = 0 ;
35724 wxSize temp2 ;
35725 PyObject * obj0 = 0 ;
35726 PyObject * obj1 = 0 ;
35727 char * kwnames[] = {
35728 (char *) "self",(char *) "minSize", NULL
35729 };
35730
35731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35733 if (!SWIG_IsOK(res1)) {
35734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35735 }
35736 arg1 = reinterpret_cast< wxWindow * >(argp1);
35737 {
35738 arg2 = &temp2;
35739 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35740 }
35741 {
35742 PyThreadState* __tstate = wxPyBeginAllowThreads();
35743 (arg1)->SetMinSize((wxSize const &)*arg2);
35744 wxPyEndAllowThreads(__tstate);
35745 if (PyErr_Occurred()) SWIG_fail;
35746 }
35747 resultobj = SWIG_Py_Void();
35748 return resultobj;
35749 fail:
35750 return NULL;
35751 }
35752
35753
35754 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35755 PyObject *resultobj = 0;
35756 wxWindow *arg1 = (wxWindow *) 0 ;
35757 wxSize *arg2 = 0 ;
35758 void *argp1 = 0 ;
35759 int res1 = 0 ;
35760 wxSize temp2 ;
35761 PyObject * obj0 = 0 ;
35762 PyObject * obj1 = 0 ;
35763 char * kwnames[] = {
35764 (char *) "self",(char *) "maxSize", NULL
35765 };
35766
35767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35769 if (!SWIG_IsOK(res1)) {
35770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35771 }
35772 arg1 = reinterpret_cast< wxWindow * >(argp1);
35773 {
35774 arg2 = &temp2;
35775 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35776 }
35777 {
35778 PyThreadState* __tstate = wxPyBeginAllowThreads();
35779 (arg1)->SetMaxSize((wxSize const &)*arg2);
35780 wxPyEndAllowThreads(__tstate);
35781 if (PyErr_Occurred()) SWIG_fail;
35782 }
35783 resultobj = SWIG_Py_Void();
35784 return resultobj;
35785 fail:
35786 return NULL;
35787 }
35788
35789
35790 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35791 PyObject *resultobj = 0;
35792 wxWindow *arg1 = (wxWindow *) 0 ;
35793 int result;
35794 void *argp1 = 0 ;
35795 int res1 = 0 ;
35796 PyObject *swig_obj[1] ;
35797
35798 if (!args) SWIG_fail;
35799 swig_obj[0] = args;
35800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35801 if (!SWIG_IsOK(res1)) {
35802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35803 }
35804 arg1 = reinterpret_cast< wxWindow * >(argp1);
35805 {
35806 PyThreadState* __tstate = wxPyBeginAllowThreads();
35807 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35808 wxPyEndAllowThreads(__tstate);
35809 if (PyErr_Occurred()) SWIG_fail;
35810 }
35811 resultobj = SWIG_From_int(static_cast< int >(result));
35812 return resultobj;
35813 fail:
35814 return NULL;
35815 }
35816
35817
35818 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35819 PyObject *resultobj = 0;
35820 wxWindow *arg1 = (wxWindow *) 0 ;
35821 int result;
35822 void *argp1 = 0 ;
35823 int res1 = 0 ;
35824 PyObject *swig_obj[1] ;
35825
35826 if (!args) SWIG_fail;
35827 swig_obj[0] = args;
35828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35829 if (!SWIG_IsOK(res1)) {
35830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35831 }
35832 arg1 = reinterpret_cast< wxWindow * >(argp1);
35833 {
35834 PyThreadState* __tstate = wxPyBeginAllowThreads();
35835 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35836 wxPyEndAllowThreads(__tstate);
35837 if (PyErr_Occurred()) SWIG_fail;
35838 }
35839 resultobj = SWIG_From_int(static_cast< int >(result));
35840 return resultobj;
35841 fail:
35842 return NULL;
35843 }
35844
35845
35846 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35847 PyObject *resultobj = 0;
35848 wxWindow *arg1 = (wxWindow *) 0 ;
35849 int result;
35850 void *argp1 = 0 ;
35851 int res1 = 0 ;
35852 PyObject *swig_obj[1] ;
35853
35854 if (!args) SWIG_fail;
35855 swig_obj[0] = args;
35856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35857 if (!SWIG_IsOK(res1)) {
35858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35859 }
35860 arg1 = reinterpret_cast< wxWindow * >(argp1);
35861 {
35862 PyThreadState* __tstate = wxPyBeginAllowThreads();
35863 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35864 wxPyEndAllowThreads(__tstate);
35865 if (PyErr_Occurred()) SWIG_fail;
35866 }
35867 resultobj = SWIG_From_int(static_cast< int >(result));
35868 return resultobj;
35869 fail:
35870 return NULL;
35871 }
35872
35873
35874 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35875 PyObject *resultobj = 0;
35876 wxWindow *arg1 = (wxWindow *) 0 ;
35877 int result;
35878 void *argp1 = 0 ;
35879 int res1 = 0 ;
35880 PyObject *swig_obj[1] ;
35881
35882 if (!args) SWIG_fail;
35883 swig_obj[0] = args;
35884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35885 if (!SWIG_IsOK(res1)) {
35886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35887 }
35888 arg1 = reinterpret_cast< wxWindow * >(argp1);
35889 {
35890 PyThreadState* __tstate = wxPyBeginAllowThreads();
35891 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35892 wxPyEndAllowThreads(__tstate);
35893 if (PyErr_Occurred()) SWIG_fail;
35894 }
35895 resultobj = SWIG_From_int(static_cast< int >(result));
35896 return resultobj;
35897 fail:
35898 return NULL;
35899 }
35900
35901
35902 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35903 PyObject *resultobj = 0;
35904 wxWindow *arg1 = (wxWindow *) 0 ;
35905 wxSize *arg2 = 0 ;
35906 void *argp1 = 0 ;
35907 int res1 = 0 ;
35908 wxSize temp2 ;
35909 PyObject * obj0 = 0 ;
35910 PyObject * obj1 = 0 ;
35911 char * kwnames[] = {
35912 (char *) "self",(char *) "size", NULL
35913 };
35914
35915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35917 if (!SWIG_IsOK(res1)) {
35918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35919 }
35920 arg1 = reinterpret_cast< wxWindow * >(argp1);
35921 {
35922 arg2 = &temp2;
35923 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35924 }
35925 {
35926 PyThreadState* __tstate = wxPyBeginAllowThreads();
35927 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35928 wxPyEndAllowThreads(__tstate);
35929 if (PyErr_Occurred()) SWIG_fail;
35930 }
35931 resultobj = SWIG_Py_Void();
35932 return resultobj;
35933 fail:
35934 return NULL;
35935 }
35936
35937
35938 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35939 PyObject *resultobj = 0;
35940 wxWindow *arg1 = (wxWindow *) 0 ;
35941 int arg2 ;
35942 int arg3 ;
35943 void *argp1 = 0 ;
35944 int res1 = 0 ;
35945 int val2 ;
35946 int ecode2 = 0 ;
35947 int val3 ;
35948 int ecode3 = 0 ;
35949 PyObject * obj0 = 0 ;
35950 PyObject * obj1 = 0 ;
35951 PyObject * obj2 = 0 ;
35952 char * kwnames[] = {
35953 (char *) "self",(char *) "w",(char *) "h", NULL
35954 };
35955
35956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35958 if (!SWIG_IsOK(res1)) {
35959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35960 }
35961 arg1 = reinterpret_cast< wxWindow * >(argp1);
35962 ecode2 = SWIG_AsVal_int(obj1, &val2);
35963 if (!SWIG_IsOK(ecode2)) {
35964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35965 }
35966 arg2 = static_cast< int >(val2);
35967 ecode3 = SWIG_AsVal_int(obj2, &val3);
35968 if (!SWIG_IsOK(ecode3)) {
35969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35970 }
35971 arg3 = static_cast< int >(val3);
35972 {
35973 PyThreadState* __tstate = wxPyBeginAllowThreads();
35974 (arg1)->SetVirtualSize(arg2,arg3);
35975 wxPyEndAllowThreads(__tstate);
35976 if (PyErr_Occurred()) SWIG_fail;
35977 }
35978 resultobj = SWIG_Py_Void();
35979 return resultobj;
35980 fail:
35981 return NULL;
35982 }
35983
35984
35985 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35986 PyObject *resultobj = 0;
35987 wxWindow *arg1 = (wxWindow *) 0 ;
35988 wxSize result;
35989 void *argp1 = 0 ;
35990 int res1 = 0 ;
35991 PyObject *swig_obj[1] ;
35992
35993 if (!args) SWIG_fail;
35994 swig_obj[0] = args;
35995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35996 if (!SWIG_IsOK(res1)) {
35997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35998 }
35999 arg1 = reinterpret_cast< wxWindow * >(argp1);
36000 {
36001 PyThreadState* __tstate = wxPyBeginAllowThreads();
36002 result = ((wxWindow const *)arg1)->GetVirtualSize();
36003 wxPyEndAllowThreads(__tstate);
36004 if (PyErr_Occurred()) SWIG_fail;
36005 }
36006 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
36007 return resultobj;
36008 fail:
36009 return NULL;
36010 }
36011
36012
36013 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36014 PyObject *resultobj = 0;
36015 wxWindow *arg1 = (wxWindow *) 0 ;
36016 int *arg2 = (int *) 0 ;
36017 int *arg3 = (int *) 0 ;
36018 void *argp1 = 0 ;
36019 int res1 = 0 ;
36020 int temp2 ;
36021 int res2 = SWIG_TMPOBJ ;
36022 int temp3 ;
36023 int res3 = SWIG_TMPOBJ ;
36024 PyObject *swig_obj[1] ;
36025
36026 arg2 = &temp2;
36027 arg3 = &temp3;
36028 if (!args) SWIG_fail;
36029 swig_obj[0] = args;
36030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36031 if (!SWIG_IsOK(res1)) {
36032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
36033 }
36034 arg1 = reinterpret_cast< wxWindow * >(argp1);
36035 {
36036 PyThreadState* __tstate = wxPyBeginAllowThreads();
36037 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
36038 wxPyEndAllowThreads(__tstate);
36039 if (PyErr_Occurred()) SWIG_fail;
36040 }
36041 resultobj = SWIG_Py_Void();
36042 if (SWIG_IsTmpObj(res2)) {
36043 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36044 } else {
36045 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36046 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36047 }
36048 if (SWIG_IsTmpObj(res3)) {
36049 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36050 } else {
36051 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36052 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36053 }
36054 return resultobj;
36055 fail:
36056 return NULL;
36057 }
36058
36059
36060 SWIGINTERN PyObject *_wrap_Window_GetWindowBorderSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36061 PyObject *resultobj = 0;
36062 wxWindow *arg1 = (wxWindow *) 0 ;
36063 wxSize result;
36064 void *argp1 = 0 ;
36065 int res1 = 0 ;
36066 PyObject *swig_obj[1] ;
36067
36068 if (!args) SWIG_fail;
36069 swig_obj[0] = args;
36070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36071 if (!SWIG_IsOK(res1)) {
36072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowBorderSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
36073 }
36074 arg1 = reinterpret_cast< wxWindow * >(argp1);
36075 {
36076 PyThreadState* __tstate = wxPyBeginAllowThreads();
36077 result = ((wxWindow const *)arg1)->GetWindowBorderSize();
36078 wxPyEndAllowThreads(__tstate);
36079 if (PyErr_Occurred()) SWIG_fail;
36080 }
36081 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
36082 return resultobj;
36083 fail:
36084 return NULL;
36085 }
36086
36087
36088 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36089 PyObject *resultobj = 0;
36090 wxWindow *arg1 = (wxWindow *) 0 ;
36091 wxSize result;
36092 void *argp1 = 0 ;
36093 int res1 = 0 ;
36094 PyObject *swig_obj[1] ;
36095
36096 if (!args) SWIG_fail;
36097 swig_obj[0] = args;
36098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36099 if (!SWIG_IsOK(res1)) {
36100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
36101 }
36102 arg1 = reinterpret_cast< wxWindow * >(argp1);
36103 {
36104 PyThreadState* __tstate = wxPyBeginAllowThreads();
36105 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
36106 wxPyEndAllowThreads(__tstate);
36107 if (PyErr_Occurred()) SWIG_fail;
36108 }
36109 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
36110 return resultobj;
36111 fail:
36112 return NULL;
36113 }
36114
36115
36116 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36117 PyObject *resultobj = 0;
36118 wxWindow *arg1 = (wxWindow *) 0 ;
36119 bool arg2 = (bool) true ;
36120 bool result;
36121 void *argp1 = 0 ;
36122 int res1 = 0 ;
36123 bool val2 ;
36124 int ecode2 = 0 ;
36125 PyObject * obj0 = 0 ;
36126 PyObject * obj1 = 0 ;
36127 char * kwnames[] = {
36128 (char *) "self",(char *) "show", NULL
36129 };
36130
36131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
36132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36133 if (!SWIG_IsOK(res1)) {
36134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
36135 }
36136 arg1 = reinterpret_cast< wxWindow * >(argp1);
36137 if (obj1) {
36138 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36139 if (!SWIG_IsOK(ecode2)) {
36140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
36141 }
36142 arg2 = static_cast< bool >(val2);
36143 }
36144 {
36145 PyThreadState* __tstate = wxPyBeginAllowThreads();
36146 result = (bool)(arg1)->Show(arg2);
36147 wxPyEndAllowThreads(__tstate);
36148 if (PyErr_Occurred()) SWIG_fail;
36149 }
36150 {
36151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36152 }
36153 return resultobj;
36154 fail:
36155 return NULL;
36156 }
36157
36158
36159 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36160 PyObject *resultobj = 0;
36161 wxWindow *arg1 = (wxWindow *) 0 ;
36162 bool result;
36163 void *argp1 = 0 ;
36164 int res1 = 0 ;
36165 PyObject *swig_obj[1] ;
36166
36167 if (!args) SWIG_fail;
36168 swig_obj[0] = args;
36169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36170 if (!SWIG_IsOK(res1)) {
36171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
36172 }
36173 arg1 = reinterpret_cast< wxWindow * >(argp1);
36174 {
36175 PyThreadState* __tstate = wxPyBeginAllowThreads();
36176 result = (bool)(arg1)->Hide();
36177 wxPyEndAllowThreads(__tstate);
36178 if (PyErr_Occurred()) SWIG_fail;
36179 }
36180 {
36181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36182 }
36183 return resultobj;
36184 fail:
36185 return NULL;
36186 }
36187
36188
36189 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36190 PyObject *resultobj = 0;
36191 wxWindow *arg1 = (wxWindow *) 0 ;
36192 bool arg2 = (bool) true ;
36193 bool result;
36194 void *argp1 = 0 ;
36195 int res1 = 0 ;
36196 bool val2 ;
36197 int ecode2 = 0 ;
36198 PyObject * obj0 = 0 ;
36199 PyObject * obj1 = 0 ;
36200 char * kwnames[] = {
36201 (char *) "self",(char *) "enable", NULL
36202 };
36203
36204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
36205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36206 if (!SWIG_IsOK(res1)) {
36207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
36208 }
36209 arg1 = reinterpret_cast< wxWindow * >(argp1);
36210 if (obj1) {
36211 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36212 if (!SWIG_IsOK(ecode2)) {
36213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
36214 }
36215 arg2 = static_cast< bool >(val2);
36216 }
36217 {
36218 PyThreadState* __tstate = wxPyBeginAllowThreads();
36219 result = (bool)(arg1)->Enable(arg2);
36220 wxPyEndAllowThreads(__tstate);
36221 if (PyErr_Occurred()) SWIG_fail;
36222 }
36223 {
36224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36225 }
36226 return resultobj;
36227 fail:
36228 return NULL;
36229 }
36230
36231
36232 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36233 PyObject *resultobj = 0;
36234 wxWindow *arg1 = (wxWindow *) 0 ;
36235 bool result;
36236 void *argp1 = 0 ;
36237 int res1 = 0 ;
36238 PyObject *swig_obj[1] ;
36239
36240 if (!args) SWIG_fail;
36241 swig_obj[0] = args;
36242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36243 if (!SWIG_IsOK(res1)) {
36244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
36245 }
36246 arg1 = reinterpret_cast< wxWindow * >(argp1);
36247 {
36248 PyThreadState* __tstate = wxPyBeginAllowThreads();
36249 result = (bool)(arg1)->Disable();
36250 wxPyEndAllowThreads(__tstate);
36251 if (PyErr_Occurred()) SWIG_fail;
36252 }
36253 {
36254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36255 }
36256 return resultobj;
36257 fail:
36258 return NULL;
36259 }
36260
36261
36262 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36263 PyObject *resultobj = 0;
36264 wxWindow *arg1 = (wxWindow *) 0 ;
36265 bool result;
36266 void *argp1 = 0 ;
36267 int res1 = 0 ;
36268 PyObject *swig_obj[1] ;
36269
36270 if (!args) SWIG_fail;
36271 swig_obj[0] = args;
36272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36273 if (!SWIG_IsOK(res1)) {
36274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
36275 }
36276 arg1 = reinterpret_cast< wxWindow * >(argp1);
36277 {
36278 PyThreadState* __tstate = wxPyBeginAllowThreads();
36279 result = (bool)((wxWindow const *)arg1)->IsShown();
36280 wxPyEndAllowThreads(__tstate);
36281 if (PyErr_Occurred()) SWIG_fail;
36282 }
36283 {
36284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36285 }
36286 return resultobj;
36287 fail:
36288 return NULL;
36289 }
36290
36291
36292 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36293 PyObject *resultobj = 0;
36294 wxWindow *arg1 = (wxWindow *) 0 ;
36295 bool result;
36296 void *argp1 = 0 ;
36297 int res1 = 0 ;
36298 PyObject *swig_obj[1] ;
36299
36300 if (!args) SWIG_fail;
36301 swig_obj[0] = args;
36302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36303 if (!SWIG_IsOK(res1)) {
36304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36305 }
36306 arg1 = reinterpret_cast< wxWindow * >(argp1);
36307 {
36308 PyThreadState* __tstate = wxPyBeginAllowThreads();
36309 result = (bool)((wxWindow const *)arg1)->IsEnabled();
36310 wxPyEndAllowThreads(__tstate);
36311 if (PyErr_Occurred()) SWIG_fail;
36312 }
36313 {
36314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36315 }
36316 return resultobj;
36317 fail:
36318 return NULL;
36319 }
36320
36321
36322 SWIGINTERN PyObject *_wrap_Window_IsThisEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36323 PyObject *resultobj = 0;
36324 wxWindow *arg1 = (wxWindow *) 0 ;
36325 bool result;
36326 void *argp1 = 0 ;
36327 int res1 = 0 ;
36328 PyObject *swig_obj[1] ;
36329
36330 if (!args) SWIG_fail;
36331 swig_obj[0] = args;
36332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36333 if (!SWIG_IsOK(res1)) {
36334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsThisEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36335 }
36336 arg1 = reinterpret_cast< wxWindow * >(argp1);
36337 {
36338 PyThreadState* __tstate = wxPyBeginAllowThreads();
36339 result = (bool)((wxWindow const *)arg1)->IsThisEnabled();
36340 wxPyEndAllowThreads(__tstate);
36341 if (PyErr_Occurred()) SWIG_fail;
36342 }
36343 {
36344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36345 }
36346 return resultobj;
36347 fail:
36348 return NULL;
36349 }
36350
36351
36352 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36353 PyObject *resultobj = 0;
36354 wxWindow *arg1 = (wxWindow *) 0 ;
36355 bool result;
36356 void *argp1 = 0 ;
36357 int res1 = 0 ;
36358 PyObject *swig_obj[1] ;
36359
36360 if (!args) SWIG_fail;
36361 swig_obj[0] = args;
36362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36363 if (!SWIG_IsOK(res1)) {
36364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36365 }
36366 arg1 = reinterpret_cast< wxWindow * >(argp1);
36367 {
36368 PyThreadState* __tstate = wxPyBeginAllowThreads();
36369 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
36370 wxPyEndAllowThreads(__tstate);
36371 if (PyErr_Occurred()) SWIG_fail;
36372 }
36373 {
36374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36375 }
36376 return resultobj;
36377 fail:
36378 return NULL;
36379 }
36380
36381
36382 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36383 PyObject *resultobj = 0;
36384 wxWindow *arg1 = (wxWindow *) 0 ;
36385 long arg2 ;
36386 void *argp1 = 0 ;
36387 int res1 = 0 ;
36388 long val2 ;
36389 int ecode2 = 0 ;
36390 PyObject * obj0 = 0 ;
36391 PyObject * obj1 = 0 ;
36392 char * kwnames[] = {
36393 (char *) "self",(char *) "style", NULL
36394 };
36395
36396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
36397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36398 if (!SWIG_IsOK(res1)) {
36399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
36400 }
36401 arg1 = reinterpret_cast< wxWindow * >(argp1);
36402 ecode2 = SWIG_AsVal_long(obj1, &val2);
36403 if (!SWIG_IsOK(ecode2)) {
36404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
36405 }
36406 arg2 = static_cast< long >(val2);
36407 {
36408 PyThreadState* __tstate = wxPyBeginAllowThreads();
36409 (arg1)->SetWindowStyleFlag(arg2);
36410 wxPyEndAllowThreads(__tstate);
36411 if (PyErr_Occurred()) SWIG_fail;
36412 }
36413 resultobj = SWIG_Py_Void();
36414 return resultobj;
36415 fail:
36416 return NULL;
36417 }
36418
36419
36420 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36421 PyObject *resultobj = 0;
36422 wxWindow *arg1 = (wxWindow *) 0 ;
36423 long result;
36424 void *argp1 = 0 ;
36425 int res1 = 0 ;
36426 PyObject *swig_obj[1] ;
36427
36428 if (!args) SWIG_fail;
36429 swig_obj[0] = args;
36430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36431 if (!SWIG_IsOK(res1)) {
36432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
36433 }
36434 arg1 = reinterpret_cast< wxWindow * >(argp1);
36435 {
36436 PyThreadState* __tstate = wxPyBeginAllowThreads();
36437 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
36438 wxPyEndAllowThreads(__tstate);
36439 if (PyErr_Occurred()) SWIG_fail;
36440 }
36441 resultobj = SWIG_From_long(static_cast< long >(result));
36442 return resultobj;
36443 fail:
36444 return NULL;
36445 }
36446
36447
36448 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36449 PyObject *resultobj = 0;
36450 wxWindow *arg1 = (wxWindow *) 0 ;
36451 int arg2 ;
36452 bool result;
36453 void *argp1 = 0 ;
36454 int res1 = 0 ;
36455 int val2 ;
36456 int ecode2 = 0 ;
36457 PyObject * obj0 = 0 ;
36458 PyObject * obj1 = 0 ;
36459 char * kwnames[] = {
36460 (char *) "self",(char *) "flag", NULL
36461 };
36462
36463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
36464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36465 if (!SWIG_IsOK(res1)) {
36466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
36467 }
36468 arg1 = reinterpret_cast< wxWindow * >(argp1);
36469 ecode2 = SWIG_AsVal_int(obj1, &val2);
36470 if (!SWIG_IsOK(ecode2)) {
36471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
36472 }
36473 arg2 = static_cast< int >(val2);
36474 {
36475 PyThreadState* __tstate = wxPyBeginAllowThreads();
36476 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
36477 wxPyEndAllowThreads(__tstate);
36478 if (PyErr_Occurred()) SWIG_fail;
36479 }
36480 {
36481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36482 }
36483 return resultobj;
36484 fail:
36485 return NULL;
36486 }
36487
36488
36489 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36490 PyObject *resultobj = 0;
36491 wxWindow *arg1 = (wxWindow *) 0 ;
36492 bool result;
36493 void *argp1 = 0 ;
36494 int res1 = 0 ;
36495 PyObject *swig_obj[1] ;
36496
36497 if (!args) SWIG_fail;
36498 swig_obj[0] = args;
36499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36500 if (!SWIG_IsOK(res1)) {
36501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
36502 }
36503 arg1 = reinterpret_cast< wxWindow * >(argp1);
36504 {
36505 PyThreadState* __tstate = wxPyBeginAllowThreads();
36506 result = (bool)((wxWindow const *)arg1)->IsRetained();
36507 wxPyEndAllowThreads(__tstate);
36508 if (PyErr_Occurred()) SWIG_fail;
36509 }
36510 {
36511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36512 }
36513 return resultobj;
36514 fail:
36515 return NULL;
36516 }
36517
36518
36519 SWIGINTERN PyObject *_wrap_Window_ToggleWindowStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36520 PyObject *resultobj = 0;
36521 wxWindow *arg1 = (wxWindow *) 0 ;
36522 int arg2 ;
36523 bool result;
36524 void *argp1 = 0 ;
36525 int res1 = 0 ;
36526 int val2 ;
36527 int ecode2 = 0 ;
36528 PyObject * obj0 = 0 ;
36529 PyObject * obj1 = 0 ;
36530 char * kwnames[] = {
36531 (char *) "self",(char *) "flag", NULL
36532 };
36533
36534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ToggleWindowStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36536 if (!SWIG_IsOK(res1)) {
36537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ToggleWindowStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36538 }
36539 arg1 = reinterpret_cast< wxWindow * >(argp1);
36540 ecode2 = SWIG_AsVal_int(obj1, &val2);
36541 if (!SWIG_IsOK(ecode2)) {
36542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ToggleWindowStyle" "', expected argument " "2"" of type '" "int""'");
36543 }
36544 arg2 = static_cast< int >(val2);
36545 {
36546 PyThreadState* __tstate = wxPyBeginAllowThreads();
36547 result = (bool)(arg1)->ToggleWindowStyle(arg2);
36548 wxPyEndAllowThreads(__tstate);
36549 if (PyErr_Occurred()) SWIG_fail;
36550 }
36551 {
36552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36553 }
36554 return resultobj;
36555 fail:
36556 return NULL;
36557 }
36558
36559
36560 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36561 PyObject *resultobj = 0;
36562 wxWindow *arg1 = (wxWindow *) 0 ;
36563 long arg2 ;
36564 void *argp1 = 0 ;
36565 int res1 = 0 ;
36566 long val2 ;
36567 int ecode2 = 0 ;
36568 PyObject * obj0 = 0 ;
36569 PyObject * obj1 = 0 ;
36570 char * kwnames[] = {
36571 (char *) "self",(char *) "exStyle", NULL
36572 };
36573
36574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36576 if (!SWIG_IsOK(res1)) {
36577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36578 }
36579 arg1 = reinterpret_cast< wxWindow * >(argp1);
36580 ecode2 = SWIG_AsVal_long(obj1, &val2);
36581 if (!SWIG_IsOK(ecode2)) {
36582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
36583 }
36584 arg2 = static_cast< long >(val2);
36585 {
36586 PyThreadState* __tstate = wxPyBeginAllowThreads();
36587 (arg1)->SetExtraStyle(arg2);
36588 wxPyEndAllowThreads(__tstate);
36589 if (PyErr_Occurred()) SWIG_fail;
36590 }
36591 resultobj = SWIG_Py_Void();
36592 return resultobj;
36593 fail:
36594 return NULL;
36595 }
36596
36597
36598 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36599 PyObject *resultobj = 0;
36600 wxWindow *arg1 = (wxWindow *) 0 ;
36601 long result;
36602 void *argp1 = 0 ;
36603 int res1 = 0 ;
36604 PyObject *swig_obj[1] ;
36605
36606 if (!args) SWIG_fail;
36607 swig_obj[0] = args;
36608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36609 if (!SWIG_IsOK(res1)) {
36610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36611 }
36612 arg1 = reinterpret_cast< wxWindow * >(argp1);
36613 {
36614 PyThreadState* __tstate = wxPyBeginAllowThreads();
36615 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
36616 wxPyEndAllowThreads(__tstate);
36617 if (PyErr_Occurred()) SWIG_fail;
36618 }
36619 resultobj = SWIG_From_long(static_cast< long >(result));
36620 return resultobj;
36621 fail:
36622 return NULL;
36623 }
36624
36625
36626 SWIGINTERN PyObject *_wrap_Window_HasExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36627 PyObject *resultobj = 0;
36628 wxWindow *arg1 = (wxWindow *) 0 ;
36629 int arg2 ;
36630 bool result;
36631 void *argp1 = 0 ;
36632 int res1 = 0 ;
36633 int val2 ;
36634 int ecode2 = 0 ;
36635 PyObject * obj0 = 0 ;
36636 PyObject * obj1 = 0 ;
36637 char * kwnames[] = {
36638 (char *) "self",(char *) "exFlag", NULL
36639 };
36640
36641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36643 if (!SWIG_IsOK(res1)) {
36644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36645 }
36646 arg1 = reinterpret_cast< wxWindow * >(argp1);
36647 ecode2 = SWIG_AsVal_int(obj1, &val2);
36648 if (!SWIG_IsOK(ecode2)) {
36649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasExtraStyle" "', expected argument " "2"" of type '" "int""'");
36650 }
36651 arg2 = static_cast< int >(val2);
36652 {
36653 PyThreadState* __tstate = wxPyBeginAllowThreads();
36654 result = (bool)((wxWindow const *)arg1)->HasExtraStyle(arg2);
36655 wxPyEndAllowThreads(__tstate);
36656 if (PyErr_Occurred()) SWIG_fail;
36657 }
36658 {
36659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36660 }
36661 return resultobj;
36662 fail:
36663 return NULL;
36664 }
36665
36666
36667 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36668 PyObject *resultobj = 0;
36669 wxWindow *arg1 = (wxWindow *) 0 ;
36670 bool arg2 = (bool) true ;
36671 void *argp1 = 0 ;
36672 int res1 = 0 ;
36673 bool val2 ;
36674 int ecode2 = 0 ;
36675 PyObject * obj0 = 0 ;
36676 PyObject * obj1 = 0 ;
36677 char * kwnames[] = {
36678 (char *) "self",(char *) "modal", NULL
36679 };
36680
36681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
36682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36683 if (!SWIG_IsOK(res1)) {
36684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
36685 }
36686 arg1 = reinterpret_cast< wxWindow * >(argp1);
36687 if (obj1) {
36688 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36689 if (!SWIG_IsOK(ecode2)) {
36690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
36691 }
36692 arg2 = static_cast< bool >(val2);
36693 }
36694 {
36695 PyThreadState* __tstate = wxPyBeginAllowThreads();
36696 (arg1)->MakeModal(arg2);
36697 wxPyEndAllowThreads(__tstate);
36698 if (PyErr_Occurred()) SWIG_fail;
36699 }
36700 resultobj = SWIG_Py_Void();
36701 return resultobj;
36702 fail:
36703 return NULL;
36704 }
36705
36706
36707 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36708 PyObject *resultobj = 0;
36709 wxWindow *arg1 = (wxWindow *) 0 ;
36710 bool arg2 ;
36711 void *argp1 = 0 ;
36712 int res1 = 0 ;
36713 bool val2 ;
36714 int ecode2 = 0 ;
36715 PyObject * obj0 = 0 ;
36716 PyObject * obj1 = 0 ;
36717 char * kwnames[] = {
36718 (char *) "self",(char *) "enableTheme", NULL
36719 };
36720
36721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36723 if (!SWIG_IsOK(res1)) {
36724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36725 }
36726 arg1 = reinterpret_cast< wxWindow * >(argp1);
36727 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36728 if (!SWIG_IsOK(ecode2)) {
36729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36730 }
36731 arg2 = static_cast< bool >(val2);
36732 {
36733 PyThreadState* __tstate = wxPyBeginAllowThreads();
36734 (arg1)->SetThemeEnabled(arg2);
36735 wxPyEndAllowThreads(__tstate);
36736 if (PyErr_Occurred()) SWIG_fail;
36737 }
36738 resultobj = SWIG_Py_Void();
36739 return resultobj;
36740 fail:
36741 return NULL;
36742 }
36743
36744
36745 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36746 PyObject *resultobj = 0;
36747 wxWindow *arg1 = (wxWindow *) 0 ;
36748 bool result;
36749 void *argp1 = 0 ;
36750 int res1 = 0 ;
36751 PyObject *swig_obj[1] ;
36752
36753 if (!args) SWIG_fail;
36754 swig_obj[0] = args;
36755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36756 if (!SWIG_IsOK(res1)) {
36757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36758 }
36759 arg1 = reinterpret_cast< wxWindow * >(argp1);
36760 {
36761 PyThreadState* __tstate = wxPyBeginAllowThreads();
36762 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36763 wxPyEndAllowThreads(__tstate);
36764 if (PyErr_Occurred()) SWIG_fail;
36765 }
36766 {
36767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36768 }
36769 return resultobj;
36770 fail:
36771 return NULL;
36772 }
36773
36774
36775 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36776 PyObject *resultobj = 0;
36777 wxWindow *arg1 = (wxWindow *) 0 ;
36778 void *argp1 = 0 ;
36779 int res1 = 0 ;
36780 PyObject *swig_obj[1] ;
36781
36782 if (!args) SWIG_fail;
36783 swig_obj[0] = args;
36784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36785 if (!SWIG_IsOK(res1)) {
36786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36787 }
36788 arg1 = reinterpret_cast< wxWindow * >(argp1);
36789 {
36790 PyThreadState* __tstate = wxPyBeginAllowThreads();
36791 (arg1)->SetFocus();
36792 wxPyEndAllowThreads(__tstate);
36793 if (PyErr_Occurred()) SWIG_fail;
36794 }
36795 resultobj = SWIG_Py_Void();
36796 return resultobj;
36797 fail:
36798 return NULL;
36799 }
36800
36801
36802 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36803 PyObject *resultobj = 0;
36804 wxWindow *arg1 = (wxWindow *) 0 ;
36805 void *argp1 = 0 ;
36806 int res1 = 0 ;
36807 PyObject *swig_obj[1] ;
36808
36809 if (!args) SWIG_fail;
36810 swig_obj[0] = args;
36811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36812 if (!SWIG_IsOK(res1)) {
36813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36814 }
36815 arg1 = reinterpret_cast< wxWindow * >(argp1);
36816 {
36817 PyThreadState* __tstate = wxPyBeginAllowThreads();
36818 (arg1)->SetFocusFromKbd();
36819 wxPyEndAllowThreads(__tstate);
36820 if (PyErr_Occurred()) SWIG_fail;
36821 }
36822 resultobj = SWIG_Py_Void();
36823 return resultobj;
36824 fail:
36825 return NULL;
36826 }
36827
36828
36829 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36830 PyObject *resultobj = 0;
36831 wxWindow *result = 0 ;
36832
36833 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36834 {
36835 if (!wxPyCheckForApp()) SWIG_fail;
36836 PyThreadState* __tstate = wxPyBeginAllowThreads();
36837 result = (wxWindow *)wxWindow::FindFocus();
36838 wxPyEndAllowThreads(__tstate);
36839 if (PyErr_Occurred()) SWIG_fail;
36840 }
36841 {
36842 resultobj = wxPyMake_wxObject(result, 0);
36843 }
36844 return resultobj;
36845 fail:
36846 return NULL;
36847 }
36848
36849
36850 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36851 PyObject *resultobj = 0;
36852 wxWindow *arg1 = (wxWindow *) 0 ;
36853 bool result;
36854 void *argp1 = 0 ;
36855 int res1 = 0 ;
36856 PyObject *swig_obj[1] ;
36857
36858 if (!args) SWIG_fail;
36859 swig_obj[0] = args;
36860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36861 if (!SWIG_IsOK(res1)) {
36862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36863 }
36864 arg1 = reinterpret_cast< wxWindow * >(argp1);
36865 {
36866 PyThreadState* __tstate = wxPyBeginAllowThreads();
36867 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36868 wxPyEndAllowThreads(__tstate);
36869 if (PyErr_Occurred()) SWIG_fail;
36870 }
36871 {
36872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36873 }
36874 return resultobj;
36875 fail:
36876 return NULL;
36877 }
36878
36879
36880 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36881 PyObject *resultobj = 0;
36882 wxWindow *arg1 = (wxWindow *) 0 ;
36883 bool result;
36884 void *argp1 = 0 ;
36885 int res1 = 0 ;
36886 PyObject *swig_obj[1] ;
36887
36888 if (!args) SWIG_fail;
36889 swig_obj[0] = args;
36890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36891 if (!SWIG_IsOK(res1)) {
36892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36893 }
36894 arg1 = reinterpret_cast< wxWindow * >(argp1);
36895 {
36896 PyThreadState* __tstate = wxPyBeginAllowThreads();
36897 result = (bool)((wxWindow const *)arg1)->CanAcceptFocus();
36898 wxPyEndAllowThreads(__tstate);
36899 if (PyErr_Occurred()) SWIG_fail;
36900 }
36901 {
36902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36903 }
36904 return resultobj;
36905 fail:
36906 return NULL;
36907 }
36908
36909
36910 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36911 PyObject *resultobj = 0;
36912 wxWindow *arg1 = (wxWindow *) 0 ;
36913 bool result;
36914 void *argp1 = 0 ;
36915 int res1 = 0 ;
36916 PyObject *swig_obj[1] ;
36917
36918 if (!args) SWIG_fail;
36919 swig_obj[0] = args;
36920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36921 if (!SWIG_IsOK(res1)) {
36922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36923 }
36924 arg1 = reinterpret_cast< wxWindow * >(argp1);
36925 {
36926 PyThreadState* __tstate = wxPyBeginAllowThreads();
36927 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36928 wxPyEndAllowThreads(__tstate);
36929 if (PyErr_Occurred()) SWIG_fail;
36930 }
36931 {
36932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36933 }
36934 return resultobj;
36935 fail:
36936 return NULL;
36937 }
36938
36939
36940 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36941 PyObject *resultobj = 0;
36942 wxWindow *arg1 = (wxWindow *) 0 ;
36943 bool result;
36944 void *argp1 = 0 ;
36945 int res1 = 0 ;
36946 PyObject *swig_obj[1] ;
36947
36948 if (!args) SWIG_fail;
36949 swig_obj[0] = args;
36950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36951 if (!SWIG_IsOK(res1)) {
36952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36953 }
36954 arg1 = reinterpret_cast< wxWindow * >(argp1);
36955 {
36956 PyThreadState* __tstate = wxPyBeginAllowThreads();
36957 result = (bool)((wxWindow const *)arg1)->CanAcceptFocusFromKeyboard();
36958 wxPyEndAllowThreads(__tstate);
36959 if (PyErr_Occurred()) SWIG_fail;
36960 }
36961 {
36962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36963 }
36964 return resultobj;
36965 fail:
36966 return NULL;
36967 }
36968
36969
36970 SWIGINTERN PyObject *_wrap_Window_SetCanFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36971 PyObject *resultobj = 0;
36972 wxWindow *arg1 = (wxWindow *) 0 ;
36973 bool arg2 ;
36974 void *argp1 = 0 ;
36975 int res1 = 0 ;
36976 bool val2 ;
36977 int ecode2 = 0 ;
36978 PyObject * obj0 = 0 ;
36979 PyObject * obj1 = 0 ;
36980 char * kwnames[] = {
36981 (char *) "self",(char *) "canFocus", NULL
36982 };
36983
36984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCanFocus",kwnames,&obj0,&obj1)) SWIG_fail;
36985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36986 if (!SWIG_IsOK(res1)) {
36987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCanFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36988 }
36989 arg1 = reinterpret_cast< wxWindow * >(argp1);
36990 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36991 if (!SWIG_IsOK(ecode2)) {
36992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetCanFocus" "', expected argument " "2"" of type '" "bool""'");
36993 }
36994 arg2 = static_cast< bool >(val2);
36995 {
36996 PyThreadState* __tstate = wxPyBeginAllowThreads();
36997 (arg1)->SetCanFocus(arg2);
36998 wxPyEndAllowThreads(__tstate);
36999 if (PyErr_Occurred()) SWIG_fail;
37000 }
37001 resultobj = SWIG_Py_Void();
37002 return resultobj;
37003 fail:
37004 return NULL;
37005 }
37006
37007
37008 SWIGINTERN PyObject *_wrap_Window_NavigateIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37009 PyObject *resultobj = 0;
37010 wxWindow *arg1 = (wxWindow *) 0 ;
37011 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
37012 bool result;
37013 void *argp1 = 0 ;
37014 int res1 = 0 ;
37015 int val2 ;
37016 int ecode2 = 0 ;
37017 PyObject * obj0 = 0 ;
37018 PyObject * obj1 = 0 ;
37019 char * kwnames[] = {
37020 (char *) "self",(char *) "flags", NULL
37021 };
37022
37023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_NavigateIn",kwnames,&obj0,&obj1)) SWIG_fail;
37024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37025 if (!SWIG_IsOK(res1)) {
37026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_NavigateIn" "', expected argument " "1"" of type '" "wxWindow *""'");
37027 }
37028 arg1 = reinterpret_cast< wxWindow * >(argp1);
37029 if (obj1) {
37030 ecode2 = SWIG_AsVal_int(obj1, &val2);
37031 if (!SWIG_IsOK(ecode2)) {
37032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_NavigateIn" "', expected argument " "2"" of type '" "int""'");
37033 }
37034 arg2 = static_cast< int >(val2);
37035 }
37036 {
37037 PyThreadState* __tstate = wxPyBeginAllowThreads();
37038 result = (bool)(arg1)->NavigateIn(arg2);
37039 wxPyEndAllowThreads(__tstate);
37040 if (PyErr_Occurred()) SWIG_fail;
37041 }
37042 {
37043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37044 }
37045 return resultobj;
37046 fail:
37047 return NULL;
37048 }
37049
37050
37051 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37052 PyObject *resultobj = 0;
37053 wxWindow *arg1 = (wxWindow *) 0 ;
37054 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
37055 bool result;
37056 void *argp1 = 0 ;
37057 int res1 = 0 ;
37058 int val2 ;
37059 int ecode2 = 0 ;
37060 PyObject * obj0 = 0 ;
37061 PyObject * obj1 = 0 ;
37062 char * kwnames[] = {
37063 (char *) "self",(char *) "flags", NULL
37064 };
37065
37066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
37067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37068 if (!SWIG_IsOK(res1)) {
37069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
37070 }
37071 arg1 = reinterpret_cast< wxWindow * >(argp1);
37072 if (obj1) {
37073 ecode2 = SWIG_AsVal_int(obj1, &val2);
37074 if (!SWIG_IsOK(ecode2)) {
37075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
37076 }
37077 arg2 = static_cast< int >(val2);
37078 }
37079 {
37080 PyThreadState* __tstate = wxPyBeginAllowThreads();
37081 result = (bool)(arg1)->Navigate(arg2);
37082 wxPyEndAllowThreads(__tstate);
37083 if (PyErr_Occurred()) SWIG_fail;
37084 }
37085 {
37086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37087 }
37088 return resultobj;
37089 fail:
37090 return NULL;
37091 }
37092
37093
37094 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37095 PyObject *resultobj = 0;
37096 wxWindow *arg1 = (wxWindow *) 0 ;
37097 wxWindow *arg2 = (wxWindow *) 0 ;
37098 void *argp1 = 0 ;
37099 int res1 = 0 ;
37100 void *argp2 = 0 ;
37101 int res2 = 0 ;
37102 PyObject * obj0 = 0 ;
37103 PyObject * obj1 = 0 ;
37104 char * kwnames[] = {
37105 (char *) "self",(char *) "win", NULL
37106 };
37107
37108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
37109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37110 if (!SWIG_IsOK(res1)) {
37111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
37112 }
37113 arg1 = reinterpret_cast< wxWindow * >(argp1);
37114 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37115 if (!SWIG_IsOK(res2)) {
37116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
37117 }
37118 arg2 = reinterpret_cast< wxWindow * >(argp2);
37119 {
37120 PyThreadState* __tstate = wxPyBeginAllowThreads();
37121 (arg1)->MoveAfterInTabOrder(arg2);
37122 wxPyEndAllowThreads(__tstate);
37123 if (PyErr_Occurred()) SWIG_fail;
37124 }
37125 resultobj = SWIG_Py_Void();
37126 return resultobj;
37127 fail:
37128 return NULL;
37129 }
37130
37131
37132 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37133 PyObject *resultobj = 0;
37134 wxWindow *arg1 = (wxWindow *) 0 ;
37135 wxWindow *arg2 = (wxWindow *) 0 ;
37136 void *argp1 = 0 ;
37137 int res1 = 0 ;
37138 void *argp2 = 0 ;
37139 int res2 = 0 ;
37140 PyObject * obj0 = 0 ;
37141 PyObject * obj1 = 0 ;
37142 char * kwnames[] = {
37143 (char *) "self",(char *) "win", NULL
37144 };
37145
37146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
37147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37148 if (!SWIG_IsOK(res1)) {
37149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
37150 }
37151 arg1 = reinterpret_cast< wxWindow * >(argp1);
37152 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37153 if (!SWIG_IsOK(res2)) {
37154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
37155 }
37156 arg2 = reinterpret_cast< wxWindow * >(argp2);
37157 {
37158 PyThreadState* __tstate = wxPyBeginAllowThreads();
37159 (arg1)->MoveBeforeInTabOrder(arg2);
37160 wxPyEndAllowThreads(__tstate);
37161 if (PyErr_Occurred()) SWIG_fail;
37162 }
37163 resultobj = SWIG_Py_Void();
37164 return resultobj;
37165 fail:
37166 return NULL;
37167 }
37168
37169
37170 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37171 PyObject *resultobj = 0;
37172 wxWindow *arg1 = (wxWindow *) 0 ;
37173 PyObject *result = 0 ;
37174 void *argp1 = 0 ;
37175 int res1 = 0 ;
37176 PyObject *swig_obj[1] ;
37177
37178 if (!args) SWIG_fail;
37179 swig_obj[0] = args;
37180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37181 if (!SWIG_IsOK(res1)) {
37182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
37183 }
37184 arg1 = reinterpret_cast< wxWindow * >(argp1);
37185 {
37186 PyThreadState* __tstate = wxPyBeginAllowThreads();
37187 result = (PyObject *)wxWindow_GetChildren(arg1);
37188 wxPyEndAllowThreads(__tstate);
37189 if (PyErr_Occurred()) SWIG_fail;
37190 }
37191 resultobj = result;
37192 return resultobj;
37193 fail:
37194 return NULL;
37195 }
37196
37197
37198 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37199 PyObject *resultobj = 0;
37200 wxWindow *arg1 = (wxWindow *) 0 ;
37201 wxWindow *result = 0 ;
37202 void *argp1 = 0 ;
37203 int res1 = 0 ;
37204 PyObject *swig_obj[1] ;
37205
37206 if (!args) SWIG_fail;
37207 swig_obj[0] = args;
37208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37209 if (!SWIG_IsOK(res1)) {
37210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
37211 }
37212 arg1 = reinterpret_cast< wxWindow * >(argp1);
37213 {
37214 PyThreadState* __tstate = wxPyBeginAllowThreads();
37215 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
37216 wxPyEndAllowThreads(__tstate);
37217 if (PyErr_Occurred()) SWIG_fail;
37218 }
37219 {
37220 resultobj = wxPyMake_wxObject(result, 0);
37221 }
37222 return resultobj;
37223 fail:
37224 return NULL;
37225 }
37226
37227
37228 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37229 PyObject *resultobj = 0;
37230 wxWindow *arg1 = (wxWindow *) 0 ;
37231 wxWindow *result = 0 ;
37232 void *argp1 = 0 ;
37233 int res1 = 0 ;
37234 PyObject *swig_obj[1] ;
37235
37236 if (!args) SWIG_fail;
37237 swig_obj[0] = args;
37238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37239 if (!SWIG_IsOK(res1)) {
37240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
37241 }
37242 arg1 = reinterpret_cast< wxWindow * >(argp1);
37243 {
37244 PyThreadState* __tstate = wxPyBeginAllowThreads();
37245 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
37246 wxPyEndAllowThreads(__tstate);
37247 if (PyErr_Occurred()) SWIG_fail;
37248 }
37249 {
37250 resultobj = wxPyMake_wxObject(result, 0);
37251 }
37252 return resultobj;
37253 fail:
37254 return NULL;
37255 }
37256
37257
37258 SWIGINTERN PyObject *_wrap_Window_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37259 PyObject *resultobj = 0;
37260 wxWindow *arg1 = (wxWindow *) 0 ;
37261 wxWindow *result = 0 ;
37262 void *argp1 = 0 ;
37263 int res1 = 0 ;
37264 PyObject *swig_obj[1] ;
37265
37266 if (!args) SWIG_fail;
37267 swig_obj[0] = args;
37268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37269 if (!SWIG_IsOK(res1)) {
37270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
37271 }
37272 arg1 = reinterpret_cast< wxWindow * >(argp1);
37273 {
37274 PyThreadState* __tstate = wxPyBeginAllowThreads();
37275 result = (wxWindow *)wxWindow_GetTopLevelParent(arg1);
37276 wxPyEndAllowThreads(__tstate);
37277 if (PyErr_Occurred()) SWIG_fail;
37278 }
37279 {
37280 resultobj = wxPyMake_wxObject(result, 0);
37281 }
37282 return resultobj;
37283 fail:
37284 return NULL;
37285 }
37286
37287
37288 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37289 PyObject *resultobj = 0;
37290 wxWindow *arg1 = (wxWindow *) 0 ;
37291 bool result;
37292 void *argp1 = 0 ;
37293 int res1 = 0 ;
37294 PyObject *swig_obj[1] ;
37295
37296 if (!args) SWIG_fail;
37297 swig_obj[0] = args;
37298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37299 if (!SWIG_IsOK(res1)) {
37300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
37301 }
37302 arg1 = reinterpret_cast< wxWindow * >(argp1);
37303 {
37304 PyThreadState* __tstate = wxPyBeginAllowThreads();
37305 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
37306 wxPyEndAllowThreads(__tstate);
37307 if (PyErr_Occurred()) SWIG_fail;
37308 }
37309 {
37310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37311 }
37312 return resultobj;
37313 fail:
37314 return NULL;
37315 }
37316
37317
37318 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37319 PyObject *resultobj = 0;
37320 wxWindow *arg1 = (wxWindow *) 0 ;
37321 wxWindow *arg2 = (wxWindow *) 0 ;
37322 bool result;
37323 void *argp1 = 0 ;
37324 int res1 = 0 ;
37325 void *argp2 = 0 ;
37326 int res2 = 0 ;
37327 PyObject * obj0 = 0 ;
37328 PyObject * obj1 = 0 ;
37329 char * kwnames[] = {
37330 (char *) "self",(char *) "newParent", NULL
37331 };
37332
37333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
37334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37335 if (!SWIG_IsOK(res1)) {
37336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37337 }
37338 arg1 = reinterpret_cast< wxWindow * >(argp1);
37339 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37340 if (!SWIG_IsOK(res2)) {
37341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
37342 }
37343 arg2 = reinterpret_cast< wxWindow * >(argp2);
37344 {
37345 PyThreadState* __tstate = wxPyBeginAllowThreads();
37346 result = (bool)(arg1)->Reparent(arg2);
37347 wxPyEndAllowThreads(__tstate);
37348 if (PyErr_Occurred()) SWIG_fail;
37349 }
37350 {
37351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37352 }
37353 return resultobj;
37354 fail:
37355 return NULL;
37356 }
37357
37358
37359 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37360 PyObject *resultobj = 0;
37361 wxWindow *arg1 = (wxWindow *) 0 ;
37362 wxWindow *arg2 = (wxWindow *) 0 ;
37363 void *argp1 = 0 ;
37364 int res1 = 0 ;
37365 void *argp2 = 0 ;
37366 int res2 = 0 ;
37367 PyObject * obj0 = 0 ;
37368 PyObject * obj1 = 0 ;
37369 char * kwnames[] = {
37370 (char *) "self",(char *) "child", NULL
37371 };
37372
37373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
37374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37375 if (!SWIG_IsOK(res1)) {
37376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
37377 }
37378 arg1 = reinterpret_cast< wxWindow * >(argp1);
37379 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37380 if (!SWIG_IsOK(res2)) {
37381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
37382 }
37383 arg2 = reinterpret_cast< wxWindow * >(argp2);
37384 {
37385 PyThreadState* __tstate = wxPyBeginAllowThreads();
37386 (arg1)->AddChild(arg2);
37387 wxPyEndAllowThreads(__tstate);
37388 if (PyErr_Occurred()) SWIG_fail;
37389 }
37390 resultobj = SWIG_Py_Void();
37391 return resultobj;
37392 fail:
37393 return NULL;
37394 }
37395
37396
37397 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37398 PyObject *resultobj = 0;
37399 wxWindow *arg1 = (wxWindow *) 0 ;
37400 wxWindow *arg2 = (wxWindow *) 0 ;
37401 void *argp1 = 0 ;
37402 int res1 = 0 ;
37403 void *argp2 = 0 ;
37404 int res2 = 0 ;
37405 PyObject * obj0 = 0 ;
37406 PyObject * obj1 = 0 ;
37407 char * kwnames[] = {
37408 (char *) "self",(char *) "child", NULL
37409 };
37410
37411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
37412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37413 if (!SWIG_IsOK(res1)) {
37414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
37415 }
37416 arg1 = reinterpret_cast< wxWindow * >(argp1);
37417 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37418 if (!SWIG_IsOK(res2)) {
37419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
37420 }
37421 arg2 = reinterpret_cast< wxWindow * >(argp2);
37422 {
37423 PyThreadState* __tstate = wxPyBeginAllowThreads();
37424 (arg1)->RemoveChild(arg2);
37425 wxPyEndAllowThreads(__tstate);
37426 if (PyErr_Occurred()) SWIG_fail;
37427 }
37428 resultobj = SWIG_Py_Void();
37429 return resultobj;
37430 fail:
37431 return NULL;
37432 }
37433
37434
37435 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37436 PyObject *resultobj = 0;
37437 wxWindow *arg1 = (wxWindow *) 0 ;
37438 bool arg2 ;
37439 void *argp1 = 0 ;
37440 int res1 = 0 ;
37441 bool val2 ;
37442 int ecode2 = 0 ;
37443 PyObject * obj0 = 0 ;
37444 PyObject * obj1 = 0 ;
37445 char * kwnames[] = {
37446 (char *) "self",(char *) "on", NULL
37447 };
37448
37449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
37450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37451 if (!SWIG_IsOK(res1)) {
37452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
37453 }
37454 arg1 = reinterpret_cast< wxWindow * >(argp1);
37455 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37456 if (!SWIG_IsOK(ecode2)) {
37457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
37458 }
37459 arg2 = static_cast< bool >(val2);
37460 {
37461 PyThreadState* __tstate = wxPyBeginAllowThreads();
37462 (arg1)->SetDoubleBuffered(arg2);
37463 wxPyEndAllowThreads(__tstate);
37464 if (PyErr_Occurred()) SWIG_fail;
37465 }
37466 resultobj = SWIG_Py_Void();
37467 return resultobj;
37468 fail:
37469 return NULL;
37470 }
37471
37472
37473 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37474 PyObject *resultobj = 0;
37475 wxWindow *arg1 = (wxWindow *) 0 ;
37476 long arg2 ;
37477 wxWindow *result = 0 ;
37478 void *argp1 = 0 ;
37479 int res1 = 0 ;
37480 long val2 ;
37481 int ecode2 = 0 ;
37482 PyObject * obj0 = 0 ;
37483 PyObject * obj1 = 0 ;
37484 char * kwnames[] = {
37485 (char *) "self",(char *) "winid", NULL
37486 };
37487
37488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37490 if (!SWIG_IsOK(res1)) {
37491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
37492 }
37493 arg1 = reinterpret_cast< wxWindow * >(argp1);
37494 ecode2 = SWIG_AsVal_long(obj1, &val2);
37495 if (!SWIG_IsOK(ecode2)) {
37496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
37497 }
37498 arg2 = static_cast< long >(val2);
37499 {
37500 PyThreadState* __tstate = wxPyBeginAllowThreads();
37501 result = (wxWindow *)(arg1)->FindWindow(arg2);
37502 wxPyEndAllowThreads(__tstate);
37503 if (PyErr_Occurred()) SWIG_fail;
37504 }
37505 {
37506 resultobj = wxPyMake_wxObject(result, 0);
37507 }
37508 return resultobj;
37509 fail:
37510 return NULL;
37511 }
37512
37513
37514 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37515 PyObject *resultobj = 0;
37516 wxWindow *arg1 = (wxWindow *) 0 ;
37517 wxString *arg2 = 0 ;
37518 wxWindow *result = 0 ;
37519 void *argp1 = 0 ;
37520 int res1 = 0 ;
37521 bool temp2 = false ;
37522 PyObject * obj0 = 0 ;
37523 PyObject * obj1 = 0 ;
37524 char * kwnames[] = {
37525 (char *) "self",(char *) "name", NULL
37526 };
37527
37528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37530 if (!SWIG_IsOK(res1)) {
37531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
37532 }
37533 arg1 = reinterpret_cast< wxWindow * >(argp1);
37534 {
37535 arg2 = wxString_in_helper(obj1);
37536 if (arg2 == NULL) SWIG_fail;
37537 temp2 = true;
37538 }
37539 {
37540 PyThreadState* __tstate = wxPyBeginAllowThreads();
37541 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
37542 wxPyEndAllowThreads(__tstate);
37543 if (PyErr_Occurred()) SWIG_fail;
37544 }
37545 {
37546 resultobj = wxPyMake_wxObject(result, 0);
37547 }
37548 {
37549 if (temp2)
37550 delete arg2;
37551 }
37552 return resultobj;
37553 fail:
37554 {
37555 if (temp2)
37556 delete arg2;
37557 }
37558 return NULL;
37559 }
37560
37561
37562 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37563 PyObject *resultobj = 0;
37564 wxWindow *arg1 = (wxWindow *) 0 ;
37565 wxEvtHandler *result = 0 ;
37566 void *argp1 = 0 ;
37567 int res1 = 0 ;
37568 PyObject *swig_obj[1] ;
37569
37570 if (!args) SWIG_fail;
37571 swig_obj[0] = args;
37572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37573 if (!SWIG_IsOK(res1)) {
37574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
37575 }
37576 arg1 = reinterpret_cast< wxWindow * >(argp1);
37577 {
37578 PyThreadState* __tstate = wxPyBeginAllowThreads();
37579 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
37580 wxPyEndAllowThreads(__tstate);
37581 if (PyErr_Occurred()) SWIG_fail;
37582 }
37583 {
37584 resultobj = wxPyMake_wxObject(result, 0);
37585 }
37586 return resultobj;
37587 fail:
37588 return NULL;
37589 }
37590
37591
37592 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37593 PyObject *resultobj = 0;
37594 wxWindow *arg1 = (wxWindow *) 0 ;
37595 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37596 void *argp1 = 0 ;
37597 int res1 = 0 ;
37598 void *argp2 = 0 ;
37599 int res2 = 0 ;
37600 PyObject * obj0 = 0 ;
37601 PyObject * obj1 = 0 ;
37602 char * kwnames[] = {
37603 (char *) "self",(char *) "handler", NULL
37604 };
37605
37606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37608 if (!SWIG_IsOK(res1)) {
37609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37610 }
37611 arg1 = reinterpret_cast< wxWindow * >(argp1);
37612 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37613 if (!SWIG_IsOK(res2)) {
37614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37615 }
37616 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37617 {
37618 PyThreadState* __tstate = wxPyBeginAllowThreads();
37619 (arg1)->SetEventHandler(arg2);
37620 wxPyEndAllowThreads(__tstate);
37621 if (PyErr_Occurred()) SWIG_fail;
37622 }
37623 resultobj = SWIG_Py_Void();
37624 return resultobj;
37625 fail:
37626 return NULL;
37627 }
37628
37629
37630 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37631 PyObject *resultobj = 0;
37632 wxWindow *arg1 = (wxWindow *) 0 ;
37633 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37634 void *argp1 = 0 ;
37635 int res1 = 0 ;
37636 void *argp2 = 0 ;
37637 int res2 = 0 ;
37638 PyObject * obj0 = 0 ;
37639 PyObject * obj1 = 0 ;
37640 char * kwnames[] = {
37641 (char *) "self",(char *) "handler", NULL
37642 };
37643
37644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37646 if (!SWIG_IsOK(res1)) {
37647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37648 }
37649 arg1 = reinterpret_cast< wxWindow * >(argp1);
37650 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37651 if (!SWIG_IsOK(res2)) {
37652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37653 }
37654 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37655 {
37656 PyThreadState* __tstate = wxPyBeginAllowThreads();
37657 (arg1)->PushEventHandler(arg2);
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_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37669 PyObject *resultobj = 0;
37670 wxWindow *arg1 = (wxWindow *) 0 ;
37671 bool arg2 = (bool) false ;
37672 wxEvtHandler *result = 0 ;
37673 void *argp1 = 0 ;
37674 int res1 = 0 ;
37675 bool val2 ;
37676 int ecode2 = 0 ;
37677 PyObject * obj0 = 0 ;
37678 PyObject * obj1 = 0 ;
37679 char * kwnames[] = {
37680 (char *) "self",(char *) "deleteHandler", NULL
37681 };
37682
37683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37685 if (!SWIG_IsOK(res1)) {
37686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37687 }
37688 arg1 = reinterpret_cast< wxWindow * >(argp1);
37689 if (obj1) {
37690 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37691 if (!SWIG_IsOK(ecode2)) {
37692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
37693 }
37694 arg2 = static_cast< bool >(val2);
37695 }
37696 {
37697 PyThreadState* __tstate = wxPyBeginAllowThreads();
37698 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
37699 wxPyEndAllowThreads(__tstate);
37700 if (PyErr_Occurred()) SWIG_fail;
37701 }
37702 {
37703 resultobj = wxPyMake_wxObject(result, 0);
37704 }
37705 return resultobj;
37706 fail:
37707 return NULL;
37708 }
37709
37710
37711 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37712 PyObject *resultobj = 0;
37713 wxWindow *arg1 = (wxWindow *) 0 ;
37714 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37715 bool result;
37716 void *argp1 = 0 ;
37717 int res1 = 0 ;
37718 void *argp2 = 0 ;
37719 int res2 = 0 ;
37720 PyObject * obj0 = 0 ;
37721 PyObject * obj1 = 0 ;
37722 char * kwnames[] = {
37723 (char *) "self",(char *) "handler", NULL
37724 };
37725
37726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37728 if (!SWIG_IsOK(res1)) {
37729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37730 }
37731 arg1 = reinterpret_cast< wxWindow * >(argp1);
37732 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37733 if (!SWIG_IsOK(res2)) {
37734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37735 }
37736 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37737 {
37738 PyThreadState* __tstate = wxPyBeginAllowThreads();
37739 result = (bool)(arg1)->RemoveEventHandler(arg2);
37740 wxPyEndAllowThreads(__tstate);
37741 if (PyErr_Occurred()) SWIG_fail;
37742 }
37743 {
37744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37745 }
37746 return resultobj;
37747 fail:
37748 return NULL;
37749 }
37750
37751
37752 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37753 PyObject *resultobj = 0;
37754 wxWindow *arg1 = (wxWindow *) 0 ;
37755 wxValidator *arg2 = 0 ;
37756 void *argp1 = 0 ;
37757 int res1 = 0 ;
37758 void *argp2 = 0 ;
37759 int res2 = 0 ;
37760 PyObject * obj0 = 0 ;
37761 PyObject * obj1 = 0 ;
37762 char * kwnames[] = {
37763 (char *) "self",(char *) "validator", NULL
37764 };
37765
37766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
37767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37768 if (!SWIG_IsOK(res1)) {
37769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37770 }
37771 arg1 = reinterpret_cast< wxWindow * >(argp1);
37772 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
37773 if (!SWIG_IsOK(res2)) {
37774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37775 }
37776 if (!argp2) {
37777 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37778 }
37779 arg2 = reinterpret_cast< wxValidator * >(argp2);
37780 {
37781 PyThreadState* __tstate = wxPyBeginAllowThreads();
37782 (arg1)->SetValidator((wxValidator const &)*arg2);
37783 wxPyEndAllowThreads(__tstate);
37784 if (PyErr_Occurred()) SWIG_fail;
37785 }
37786 resultobj = SWIG_Py_Void();
37787 return resultobj;
37788 fail:
37789 return NULL;
37790 }
37791
37792
37793 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37794 PyObject *resultobj = 0;
37795 wxWindow *arg1 = (wxWindow *) 0 ;
37796 wxValidator *result = 0 ;
37797 void *argp1 = 0 ;
37798 int res1 = 0 ;
37799 PyObject *swig_obj[1] ;
37800
37801 if (!args) SWIG_fail;
37802 swig_obj[0] = args;
37803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37804 if (!SWIG_IsOK(res1)) {
37805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37806 }
37807 arg1 = reinterpret_cast< wxWindow * >(argp1);
37808 {
37809 PyThreadState* __tstate = wxPyBeginAllowThreads();
37810 result = (wxValidator *)(arg1)->GetValidator();
37811 wxPyEndAllowThreads(__tstate);
37812 if (PyErr_Occurred()) SWIG_fail;
37813 }
37814 {
37815 resultobj = wxPyMake_wxObject(result, (bool)0);
37816 }
37817 return resultobj;
37818 fail:
37819 return NULL;
37820 }
37821
37822
37823 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37824 PyObject *resultobj = 0;
37825 wxWindow *arg1 = (wxWindow *) 0 ;
37826 bool result;
37827 void *argp1 = 0 ;
37828 int res1 = 0 ;
37829 PyObject *swig_obj[1] ;
37830
37831 if (!args) SWIG_fail;
37832 swig_obj[0] = args;
37833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37834 if (!SWIG_IsOK(res1)) {
37835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
37836 }
37837 arg1 = reinterpret_cast< wxWindow * >(argp1);
37838 {
37839 PyThreadState* __tstate = wxPyBeginAllowThreads();
37840 result = (bool)(arg1)->Validate();
37841 wxPyEndAllowThreads(__tstate);
37842 if (PyErr_Occurred()) SWIG_fail;
37843 }
37844 {
37845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37846 }
37847 return resultobj;
37848 fail:
37849 return NULL;
37850 }
37851
37852
37853 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37854 PyObject *resultobj = 0;
37855 wxWindow *arg1 = (wxWindow *) 0 ;
37856 bool result;
37857 void *argp1 = 0 ;
37858 int res1 = 0 ;
37859 PyObject *swig_obj[1] ;
37860
37861 if (!args) SWIG_fail;
37862 swig_obj[0] = args;
37863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37864 if (!SWIG_IsOK(res1)) {
37865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37866 }
37867 arg1 = reinterpret_cast< wxWindow * >(argp1);
37868 {
37869 PyThreadState* __tstate = wxPyBeginAllowThreads();
37870 result = (bool)(arg1)->TransferDataToWindow();
37871 wxPyEndAllowThreads(__tstate);
37872 if (PyErr_Occurred()) SWIG_fail;
37873 }
37874 {
37875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37876 }
37877 return resultobj;
37878 fail:
37879 return NULL;
37880 }
37881
37882
37883 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37884 PyObject *resultobj = 0;
37885 wxWindow *arg1 = (wxWindow *) 0 ;
37886 bool result;
37887 void *argp1 = 0 ;
37888 int res1 = 0 ;
37889 PyObject *swig_obj[1] ;
37890
37891 if (!args) SWIG_fail;
37892 swig_obj[0] = args;
37893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37894 if (!SWIG_IsOK(res1)) {
37895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37896 }
37897 arg1 = reinterpret_cast< wxWindow * >(argp1);
37898 {
37899 PyThreadState* __tstate = wxPyBeginAllowThreads();
37900 result = (bool)(arg1)->TransferDataFromWindow();
37901 wxPyEndAllowThreads(__tstate);
37902 if (PyErr_Occurred()) SWIG_fail;
37903 }
37904 {
37905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37906 }
37907 return resultobj;
37908 fail:
37909 return NULL;
37910 }
37911
37912
37913 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37914 PyObject *resultobj = 0;
37915 wxWindow *arg1 = (wxWindow *) 0 ;
37916 void *argp1 = 0 ;
37917 int res1 = 0 ;
37918 PyObject *swig_obj[1] ;
37919
37920 if (!args) SWIG_fail;
37921 swig_obj[0] = args;
37922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37923 if (!SWIG_IsOK(res1)) {
37924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37925 }
37926 arg1 = reinterpret_cast< wxWindow * >(argp1);
37927 {
37928 PyThreadState* __tstate = wxPyBeginAllowThreads();
37929 (arg1)->InitDialog();
37930 wxPyEndAllowThreads(__tstate);
37931 if (PyErr_Occurred()) SWIG_fail;
37932 }
37933 resultobj = SWIG_Py_Void();
37934 return resultobj;
37935 fail:
37936 return NULL;
37937 }
37938
37939
37940 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37941 PyObject *resultobj = 0;
37942 wxWindow *arg1 = (wxWindow *) 0 ;
37943 wxAcceleratorTable *arg2 = 0 ;
37944 void *argp1 = 0 ;
37945 int res1 = 0 ;
37946 void *argp2 = 0 ;
37947 int res2 = 0 ;
37948 PyObject * obj0 = 0 ;
37949 PyObject * obj1 = 0 ;
37950 char * kwnames[] = {
37951 (char *) "self",(char *) "accel", NULL
37952 };
37953
37954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37956 if (!SWIG_IsOK(res1)) {
37957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37958 }
37959 arg1 = reinterpret_cast< wxWindow * >(argp1);
37960 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37961 if (!SWIG_IsOK(res2)) {
37962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37963 }
37964 if (!argp2) {
37965 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37966 }
37967 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37968 {
37969 PyThreadState* __tstate = wxPyBeginAllowThreads();
37970 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37971 wxPyEndAllowThreads(__tstate);
37972 if (PyErr_Occurred()) SWIG_fail;
37973 }
37974 resultobj = SWIG_Py_Void();
37975 return resultobj;
37976 fail:
37977 return NULL;
37978 }
37979
37980
37981 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37982 PyObject *resultobj = 0;
37983 wxWindow *arg1 = (wxWindow *) 0 ;
37984 wxAcceleratorTable *result = 0 ;
37985 void *argp1 = 0 ;
37986 int res1 = 0 ;
37987 PyObject *swig_obj[1] ;
37988
37989 if (!args) SWIG_fail;
37990 swig_obj[0] = args;
37991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37992 if (!SWIG_IsOK(res1)) {
37993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37994 }
37995 arg1 = reinterpret_cast< wxWindow * >(argp1);
37996 {
37997 PyThreadState* __tstate = wxPyBeginAllowThreads();
37998 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37999 wxPyEndAllowThreads(__tstate);
38000 if (PyErr_Occurred()) SWIG_fail;
38001 }
38002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
38003 return resultobj;
38004 fail:
38005 return NULL;
38006 }
38007
38008
38009 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38010 PyObject *resultobj = 0;
38011 wxWindow *arg1 = (wxWindow *) 0 ;
38012 int arg2 ;
38013 int arg3 ;
38014 int arg4 ;
38015 bool result;
38016 void *argp1 = 0 ;
38017 int res1 = 0 ;
38018 int val2 ;
38019 int ecode2 = 0 ;
38020 int val3 ;
38021 int ecode3 = 0 ;
38022 int val4 ;
38023 int ecode4 = 0 ;
38024 PyObject * obj0 = 0 ;
38025 PyObject * obj1 = 0 ;
38026 PyObject * obj2 = 0 ;
38027 PyObject * obj3 = 0 ;
38028 char * kwnames[] = {
38029 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
38030 };
38031
38032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38034 if (!SWIG_IsOK(res1)) {
38035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
38036 }
38037 arg1 = reinterpret_cast< wxWindow * >(argp1);
38038 ecode2 = SWIG_AsVal_int(obj1, &val2);
38039 if (!SWIG_IsOK(ecode2)) {
38040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
38041 }
38042 arg2 = static_cast< int >(val2);
38043 ecode3 = SWIG_AsVal_int(obj2, &val3);
38044 if (!SWIG_IsOK(ecode3)) {
38045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
38046 }
38047 arg3 = static_cast< int >(val3);
38048 ecode4 = SWIG_AsVal_int(obj3, &val4);
38049 if (!SWIG_IsOK(ecode4)) {
38050 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
38051 }
38052 arg4 = static_cast< int >(val4);
38053 {
38054 PyThreadState* __tstate = wxPyBeginAllowThreads();
38055 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
38056 wxPyEndAllowThreads(__tstate);
38057 if (PyErr_Occurred()) SWIG_fail;
38058 }
38059 {
38060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38061 }
38062 return resultobj;
38063 fail:
38064 return NULL;
38065 }
38066
38067
38068 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38069 PyObject *resultobj = 0;
38070 wxWindow *arg1 = (wxWindow *) 0 ;
38071 int arg2 ;
38072 bool result;
38073 void *argp1 = 0 ;
38074 int res1 = 0 ;
38075 int val2 ;
38076 int ecode2 = 0 ;
38077 PyObject * obj0 = 0 ;
38078 PyObject * obj1 = 0 ;
38079 char * kwnames[] = {
38080 (char *) "self",(char *) "hotkeyId", NULL
38081 };
38082
38083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
38084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38085 if (!SWIG_IsOK(res1)) {
38086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
38087 }
38088 arg1 = reinterpret_cast< wxWindow * >(argp1);
38089 ecode2 = SWIG_AsVal_int(obj1, &val2);
38090 if (!SWIG_IsOK(ecode2)) {
38091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
38092 }
38093 arg2 = static_cast< int >(val2);
38094 {
38095 PyThreadState* __tstate = wxPyBeginAllowThreads();
38096 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
38097 wxPyEndAllowThreads(__tstate);
38098 if (PyErr_Occurred()) SWIG_fail;
38099 }
38100 {
38101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38102 }
38103 return resultobj;
38104 fail:
38105 return NULL;
38106 }
38107
38108
38109 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38110 PyObject *resultobj = 0;
38111 wxWindow *arg1 = (wxWindow *) 0 ;
38112 wxPoint *arg2 = 0 ;
38113 wxPoint result;
38114 void *argp1 = 0 ;
38115 int res1 = 0 ;
38116 wxPoint temp2 ;
38117 PyObject * obj0 = 0 ;
38118 PyObject * obj1 = 0 ;
38119 char * kwnames[] = {
38120 (char *) "self",(char *) "pt", NULL
38121 };
38122
38123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
38124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38125 if (!SWIG_IsOK(res1)) {
38126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
38127 }
38128 arg1 = reinterpret_cast< wxWindow * >(argp1);
38129 {
38130 arg2 = &temp2;
38131 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38132 }
38133 {
38134 PyThreadState* __tstate = wxPyBeginAllowThreads();
38135 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
38136 wxPyEndAllowThreads(__tstate);
38137 if (PyErr_Occurred()) SWIG_fail;
38138 }
38139 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
38140 return resultobj;
38141 fail:
38142 return NULL;
38143 }
38144
38145
38146 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38147 PyObject *resultobj = 0;
38148 wxWindow *arg1 = (wxWindow *) 0 ;
38149 wxSize *arg2 = 0 ;
38150 wxSize result;
38151 void *argp1 = 0 ;
38152 int res1 = 0 ;
38153 wxSize temp2 ;
38154 PyObject * obj0 = 0 ;
38155 PyObject * obj1 = 0 ;
38156 char * kwnames[] = {
38157 (char *) "self",(char *) "sz", NULL
38158 };
38159
38160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
38161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38162 if (!SWIG_IsOK(res1)) {
38163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
38164 }
38165 arg1 = reinterpret_cast< wxWindow * >(argp1);
38166 {
38167 arg2 = &temp2;
38168 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38169 }
38170 {
38171 PyThreadState* __tstate = wxPyBeginAllowThreads();
38172 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
38173 wxPyEndAllowThreads(__tstate);
38174 if (PyErr_Occurred()) SWIG_fail;
38175 }
38176 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
38177 return resultobj;
38178 fail:
38179 return NULL;
38180 }
38181
38182
38183 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38184 PyObject *resultobj = 0;
38185 wxWindow *arg1 = (wxWindow *) 0 ;
38186 wxPoint *arg2 = 0 ;
38187 wxPoint result;
38188 void *argp1 = 0 ;
38189 int res1 = 0 ;
38190 wxPoint temp2 ;
38191 PyObject * obj0 = 0 ;
38192 PyObject * obj1 = 0 ;
38193 char * kwnames[] = {
38194 (char *) "self",(char *) "pt", NULL
38195 };
38196
38197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
38198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38199 if (!SWIG_IsOK(res1)) {
38200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
38201 }
38202 arg1 = reinterpret_cast< wxWindow * >(argp1);
38203 {
38204 arg2 = &temp2;
38205 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38206 }
38207 {
38208 PyThreadState* __tstate = wxPyBeginAllowThreads();
38209 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
38210 wxPyEndAllowThreads(__tstate);
38211 if (PyErr_Occurred()) SWIG_fail;
38212 }
38213 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
38214 return resultobj;
38215 fail:
38216 return NULL;
38217 }
38218
38219
38220 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38221 PyObject *resultobj = 0;
38222 wxWindow *arg1 = (wxWindow *) 0 ;
38223 wxSize *arg2 = 0 ;
38224 wxSize result;
38225 void *argp1 = 0 ;
38226 int res1 = 0 ;
38227 wxSize temp2 ;
38228 PyObject * obj0 = 0 ;
38229 PyObject * obj1 = 0 ;
38230 char * kwnames[] = {
38231 (char *) "self",(char *) "sz", NULL
38232 };
38233
38234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
38235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38236 if (!SWIG_IsOK(res1)) {
38237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
38238 }
38239 arg1 = reinterpret_cast< wxWindow * >(argp1);
38240 {
38241 arg2 = &temp2;
38242 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38243 }
38244 {
38245 PyThreadState* __tstate = wxPyBeginAllowThreads();
38246 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
38247 wxPyEndAllowThreads(__tstate);
38248 if (PyErr_Occurred()) SWIG_fail;
38249 }
38250 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
38251 return resultobj;
38252 fail:
38253 return NULL;
38254 }
38255
38256
38257 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38258 PyObject *resultobj = 0;
38259 wxWindow *arg1 = (wxWindow *) 0 ;
38260 wxPoint *arg2 = 0 ;
38261 wxPoint result;
38262 void *argp1 = 0 ;
38263 int res1 = 0 ;
38264 wxPoint temp2 ;
38265 PyObject * obj0 = 0 ;
38266 PyObject * obj1 = 0 ;
38267 char * kwnames[] = {
38268 (char *) "self",(char *) "pt", NULL
38269 };
38270
38271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
38272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38273 if (!SWIG_IsOK(res1)) {
38274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
38275 }
38276 arg1 = reinterpret_cast< wxWindow * >(argp1);
38277 {
38278 arg2 = &temp2;
38279 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38280 }
38281 {
38282 PyThreadState* __tstate = wxPyBeginAllowThreads();
38283 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
38284 wxPyEndAllowThreads(__tstate);
38285 if (PyErr_Occurred()) SWIG_fail;
38286 }
38287 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
38288 return resultobj;
38289 fail:
38290 return NULL;
38291 }
38292
38293
38294 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38295 PyObject *resultobj = 0;
38296 wxWindow *arg1 = (wxWindow *) 0 ;
38297 wxSize *arg2 = 0 ;
38298 wxSize result;
38299 void *argp1 = 0 ;
38300 int res1 = 0 ;
38301 wxSize temp2 ;
38302 PyObject * obj0 = 0 ;
38303 PyObject * obj1 = 0 ;
38304 char * kwnames[] = {
38305 (char *) "self",(char *) "sz", NULL
38306 };
38307
38308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
38309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38310 if (!SWIG_IsOK(res1)) {
38311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
38312 }
38313 arg1 = reinterpret_cast< wxWindow * >(argp1);
38314 {
38315 arg2 = &temp2;
38316 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38317 }
38318 {
38319 PyThreadState* __tstate = wxPyBeginAllowThreads();
38320 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
38321 wxPyEndAllowThreads(__tstate);
38322 if (PyErr_Occurred()) SWIG_fail;
38323 }
38324 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
38325 return resultobj;
38326 fail:
38327 return NULL;
38328 }
38329
38330
38331 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38332 PyObject *resultobj = 0;
38333 wxWindow *arg1 = (wxWindow *) 0 ;
38334 int arg2 ;
38335 int arg3 ;
38336 void *argp1 = 0 ;
38337 int res1 = 0 ;
38338 int val2 ;
38339 int ecode2 = 0 ;
38340 int val3 ;
38341 int ecode3 = 0 ;
38342 PyObject * obj0 = 0 ;
38343 PyObject * obj1 = 0 ;
38344 PyObject * obj2 = 0 ;
38345 char * kwnames[] = {
38346 (char *) "self",(char *) "x",(char *) "y", NULL
38347 };
38348
38349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38351 if (!SWIG_IsOK(res1)) {
38352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
38353 }
38354 arg1 = reinterpret_cast< wxWindow * >(argp1);
38355 ecode2 = SWIG_AsVal_int(obj1, &val2);
38356 if (!SWIG_IsOK(ecode2)) {
38357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
38358 }
38359 arg2 = static_cast< int >(val2);
38360 ecode3 = SWIG_AsVal_int(obj2, &val3);
38361 if (!SWIG_IsOK(ecode3)) {
38362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
38363 }
38364 arg3 = static_cast< int >(val3);
38365 {
38366 PyThreadState* __tstate = wxPyBeginAllowThreads();
38367 (arg1)->WarpPointer(arg2,arg3);
38368 wxPyEndAllowThreads(__tstate);
38369 if (PyErr_Occurred()) SWIG_fail;
38370 }
38371 resultobj = SWIG_Py_Void();
38372 return resultobj;
38373 fail:
38374 return NULL;
38375 }
38376
38377
38378 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38379 PyObject *resultobj = 0;
38380 wxWindow *arg1 = (wxWindow *) 0 ;
38381 void *argp1 = 0 ;
38382 int res1 = 0 ;
38383 PyObject *swig_obj[1] ;
38384
38385 if (!args) SWIG_fail;
38386 swig_obj[0] = args;
38387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38388 if (!SWIG_IsOK(res1)) {
38389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
38390 }
38391 arg1 = reinterpret_cast< wxWindow * >(argp1);
38392 {
38393 PyThreadState* __tstate = wxPyBeginAllowThreads();
38394 (arg1)->CaptureMouse();
38395 wxPyEndAllowThreads(__tstate);
38396 if (PyErr_Occurred()) SWIG_fail;
38397 }
38398 resultobj = SWIG_Py_Void();
38399 return resultobj;
38400 fail:
38401 return NULL;
38402 }
38403
38404
38405 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38406 PyObject *resultobj = 0;
38407 wxWindow *arg1 = (wxWindow *) 0 ;
38408 void *argp1 = 0 ;
38409 int res1 = 0 ;
38410 PyObject *swig_obj[1] ;
38411
38412 if (!args) SWIG_fail;
38413 swig_obj[0] = args;
38414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38415 if (!SWIG_IsOK(res1)) {
38416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
38417 }
38418 arg1 = reinterpret_cast< wxWindow * >(argp1);
38419 {
38420 PyThreadState* __tstate = wxPyBeginAllowThreads();
38421 (arg1)->ReleaseMouse();
38422 wxPyEndAllowThreads(__tstate);
38423 if (PyErr_Occurred()) SWIG_fail;
38424 }
38425 resultobj = SWIG_Py_Void();
38426 return resultobj;
38427 fail:
38428 return NULL;
38429 }
38430
38431
38432 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38433 PyObject *resultobj = 0;
38434 wxWindow *result = 0 ;
38435
38436 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
38437 {
38438 if (!wxPyCheckForApp()) SWIG_fail;
38439 PyThreadState* __tstate = wxPyBeginAllowThreads();
38440 result = (wxWindow *)wxWindow::GetCapture();
38441 wxPyEndAllowThreads(__tstate);
38442 if (PyErr_Occurred()) SWIG_fail;
38443 }
38444 {
38445 resultobj = wxPyMake_wxObject(result, 0);
38446 }
38447 return resultobj;
38448 fail:
38449 return NULL;
38450 }
38451
38452
38453 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38454 PyObject *resultobj = 0;
38455 wxWindow *arg1 = (wxWindow *) 0 ;
38456 bool result;
38457 void *argp1 = 0 ;
38458 int res1 = 0 ;
38459 PyObject *swig_obj[1] ;
38460
38461 if (!args) SWIG_fail;
38462 swig_obj[0] = args;
38463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38464 if (!SWIG_IsOK(res1)) {
38465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
38466 }
38467 arg1 = reinterpret_cast< wxWindow * >(argp1);
38468 {
38469 PyThreadState* __tstate = wxPyBeginAllowThreads();
38470 result = (bool)((wxWindow const *)arg1)->HasCapture();
38471 wxPyEndAllowThreads(__tstate);
38472 if (PyErr_Occurred()) SWIG_fail;
38473 }
38474 {
38475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38476 }
38477 return resultobj;
38478 fail:
38479 return NULL;
38480 }
38481
38482
38483 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38484 PyObject *resultobj = 0;
38485 wxWindow *arg1 = (wxWindow *) 0 ;
38486 bool arg2 = (bool) true ;
38487 wxRect *arg3 = (wxRect *) NULL ;
38488 void *argp1 = 0 ;
38489 int res1 = 0 ;
38490 bool val2 ;
38491 int ecode2 = 0 ;
38492 void *argp3 = 0 ;
38493 int res3 = 0 ;
38494 PyObject * obj0 = 0 ;
38495 PyObject * obj1 = 0 ;
38496 PyObject * obj2 = 0 ;
38497 char * kwnames[] = {
38498 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
38499 };
38500
38501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38503 if (!SWIG_IsOK(res1)) {
38504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
38505 }
38506 arg1 = reinterpret_cast< wxWindow * >(argp1);
38507 if (obj1) {
38508 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38509 if (!SWIG_IsOK(ecode2)) {
38510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
38511 }
38512 arg2 = static_cast< bool >(val2);
38513 }
38514 if (obj2) {
38515 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
38516 if (!SWIG_IsOK(res3)) {
38517 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
38518 }
38519 arg3 = reinterpret_cast< wxRect * >(argp3);
38520 }
38521 {
38522 PyThreadState* __tstate = wxPyBeginAllowThreads();
38523 (arg1)->Refresh(arg2,(wxRect const *)arg3);
38524 wxPyEndAllowThreads(__tstate);
38525 if (PyErr_Occurred()) SWIG_fail;
38526 }
38527 resultobj = SWIG_Py_Void();
38528 return resultobj;
38529 fail:
38530 return NULL;
38531 }
38532
38533
38534 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38535 PyObject *resultobj = 0;
38536 wxWindow *arg1 = (wxWindow *) 0 ;
38537 wxRect *arg2 = 0 ;
38538 bool arg3 = (bool) true ;
38539 void *argp1 = 0 ;
38540 int res1 = 0 ;
38541 wxRect temp2 ;
38542 bool val3 ;
38543 int ecode3 = 0 ;
38544 PyObject * obj0 = 0 ;
38545 PyObject * obj1 = 0 ;
38546 PyObject * obj2 = 0 ;
38547 char * kwnames[] = {
38548 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
38549 };
38550
38551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38553 if (!SWIG_IsOK(res1)) {
38554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
38555 }
38556 arg1 = reinterpret_cast< wxWindow * >(argp1);
38557 {
38558 arg2 = &temp2;
38559 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38560 }
38561 if (obj2) {
38562 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38563 if (!SWIG_IsOK(ecode3)) {
38564 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
38565 }
38566 arg3 = static_cast< bool >(val3);
38567 }
38568 {
38569 PyThreadState* __tstate = wxPyBeginAllowThreads();
38570 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
38571 wxPyEndAllowThreads(__tstate);
38572 if (PyErr_Occurred()) SWIG_fail;
38573 }
38574 resultobj = SWIG_Py_Void();
38575 return resultobj;
38576 fail:
38577 return NULL;
38578 }
38579
38580
38581 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38582 PyObject *resultobj = 0;
38583 wxWindow *arg1 = (wxWindow *) 0 ;
38584 void *argp1 = 0 ;
38585 int res1 = 0 ;
38586 PyObject *swig_obj[1] ;
38587
38588 if (!args) SWIG_fail;
38589 swig_obj[0] = args;
38590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38591 if (!SWIG_IsOK(res1)) {
38592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
38593 }
38594 arg1 = reinterpret_cast< wxWindow * >(argp1);
38595 {
38596 PyThreadState* __tstate = wxPyBeginAllowThreads();
38597 (arg1)->Update();
38598 wxPyEndAllowThreads(__tstate);
38599 if (PyErr_Occurred()) SWIG_fail;
38600 }
38601 resultobj = SWIG_Py_Void();
38602 return resultobj;
38603 fail:
38604 return NULL;
38605 }
38606
38607
38608 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38609 PyObject *resultobj = 0;
38610 wxWindow *arg1 = (wxWindow *) 0 ;
38611 void *argp1 = 0 ;
38612 int res1 = 0 ;
38613 PyObject *swig_obj[1] ;
38614
38615 if (!args) SWIG_fail;
38616 swig_obj[0] = args;
38617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38618 if (!SWIG_IsOK(res1)) {
38619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38620 }
38621 arg1 = reinterpret_cast< wxWindow * >(argp1);
38622 {
38623 PyThreadState* __tstate = wxPyBeginAllowThreads();
38624 (arg1)->ClearBackground();
38625 wxPyEndAllowThreads(__tstate);
38626 if (PyErr_Occurred()) SWIG_fail;
38627 }
38628 resultobj = SWIG_Py_Void();
38629 return resultobj;
38630 fail:
38631 return NULL;
38632 }
38633
38634
38635 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38636 PyObject *resultobj = 0;
38637 wxWindow *arg1 = (wxWindow *) 0 ;
38638 void *argp1 = 0 ;
38639 int res1 = 0 ;
38640 PyObject *swig_obj[1] ;
38641
38642 if (!args) SWIG_fail;
38643 swig_obj[0] = args;
38644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38645 if (!SWIG_IsOK(res1)) {
38646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
38647 }
38648 arg1 = reinterpret_cast< wxWindow * >(argp1);
38649 {
38650 PyThreadState* __tstate = wxPyBeginAllowThreads();
38651 (arg1)->Freeze();
38652 wxPyEndAllowThreads(__tstate);
38653 if (PyErr_Occurred()) SWIG_fail;
38654 }
38655 resultobj = SWIG_Py_Void();
38656 return resultobj;
38657 fail:
38658 return NULL;
38659 }
38660
38661
38662 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38663 PyObject *resultobj = 0;
38664 wxWindow *arg1 = (wxWindow *) 0 ;
38665 bool result;
38666 void *argp1 = 0 ;
38667 int res1 = 0 ;
38668 PyObject *swig_obj[1] ;
38669
38670 if (!args) SWIG_fail;
38671 swig_obj[0] = args;
38672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38673 if (!SWIG_IsOK(res1)) {
38674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
38675 }
38676 arg1 = reinterpret_cast< wxWindow * >(argp1);
38677 {
38678 PyThreadState* __tstate = wxPyBeginAllowThreads();
38679 result = (bool)((wxWindow const *)arg1)->IsFrozen();
38680 wxPyEndAllowThreads(__tstate);
38681 if (PyErr_Occurred()) SWIG_fail;
38682 }
38683 {
38684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38685 }
38686 return resultobj;
38687 fail:
38688 return NULL;
38689 }
38690
38691
38692 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38693 PyObject *resultobj = 0;
38694 wxWindow *arg1 = (wxWindow *) 0 ;
38695 void *argp1 = 0 ;
38696 int res1 = 0 ;
38697 PyObject *swig_obj[1] ;
38698
38699 if (!args) SWIG_fail;
38700 swig_obj[0] = args;
38701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38702 if (!SWIG_IsOK(res1)) {
38703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
38704 }
38705 arg1 = reinterpret_cast< wxWindow * >(argp1);
38706 {
38707 PyThreadState* __tstate = wxPyBeginAllowThreads();
38708 (arg1)->Thaw();
38709 wxPyEndAllowThreads(__tstate);
38710 if (PyErr_Occurred()) SWIG_fail;
38711 }
38712 resultobj = SWIG_Py_Void();
38713 return resultobj;
38714 fail:
38715 return NULL;
38716 }
38717
38718
38719 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38720 PyObject *resultobj = 0;
38721 wxWindow *arg1 = (wxWindow *) 0 ;
38722 wxDC *arg2 = 0 ;
38723 void *argp1 = 0 ;
38724 int res1 = 0 ;
38725 void *argp2 = 0 ;
38726 int res2 = 0 ;
38727 PyObject * obj0 = 0 ;
38728 PyObject * obj1 = 0 ;
38729 char * kwnames[] = {
38730 (char *) "self",(char *) "dc", NULL
38731 };
38732
38733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
38734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38735 if (!SWIG_IsOK(res1)) {
38736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
38737 }
38738 arg1 = reinterpret_cast< wxWindow * >(argp1);
38739 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
38740 if (!SWIG_IsOK(res2)) {
38741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38742 }
38743 if (!argp2) {
38744 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38745 }
38746 arg2 = reinterpret_cast< wxDC * >(argp2);
38747 {
38748 PyThreadState* __tstate = wxPyBeginAllowThreads();
38749 (arg1)->PrepareDC(*arg2);
38750 wxPyEndAllowThreads(__tstate);
38751 if (PyErr_Occurred()) SWIG_fail;
38752 }
38753 resultobj = SWIG_Py_Void();
38754 return resultobj;
38755 fail:
38756 return NULL;
38757 }
38758
38759
38760 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38761 PyObject *resultobj = 0;
38762 wxWindow *arg1 = (wxWindow *) 0 ;
38763 bool result;
38764 void *argp1 = 0 ;
38765 int res1 = 0 ;
38766 PyObject *swig_obj[1] ;
38767
38768 if (!args) SWIG_fail;
38769 swig_obj[0] = args;
38770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38771 if (!SWIG_IsOK(res1)) {
38772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
38773 }
38774 arg1 = reinterpret_cast< wxWindow * >(argp1);
38775 {
38776 PyThreadState* __tstate = wxPyBeginAllowThreads();
38777 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
38778 wxPyEndAllowThreads(__tstate);
38779 if (PyErr_Occurred()) SWIG_fail;
38780 }
38781 {
38782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38783 }
38784 return resultobj;
38785 fail:
38786 return NULL;
38787 }
38788
38789
38790 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38791 PyObject *resultobj = 0;
38792 wxWindow *arg1 = (wxWindow *) 0 ;
38793 wxRegion *result = 0 ;
38794 void *argp1 = 0 ;
38795 int res1 = 0 ;
38796 PyObject *swig_obj[1] ;
38797
38798 if (!args) SWIG_fail;
38799 swig_obj[0] = args;
38800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38801 if (!SWIG_IsOK(res1)) {
38802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
38803 }
38804 arg1 = reinterpret_cast< wxWindow * >(argp1);
38805 {
38806 PyThreadState* __tstate = wxPyBeginAllowThreads();
38807 {
38808 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
38809 result = (wxRegion *) &_result_ref;
38810 }
38811 wxPyEndAllowThreads(__tstate);
38812 if (PyErr_Occurred()) SWIG_fail;
38813 }
38814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
38815 return resultobj;
38816 fail:
38817 return NULL;
38818 }
38819
38820
38821 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38822 PyObject *resultobj = 0;
38823 wxWindow *arg1 = (wxWindow *) 0 ;
38824 wxRect result;
38825 void *argp1 = 0 ;
38826 int res1 = 0 ;
38827 PyObject *swig_obj[1] ;
38828
38829 if (!args) SWIG_fail;
38830 swig_obj[0] = args;
38831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38832 if (!SWIG_IsOK(res1)) {
38833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38834 }
38835 arg1 = reinterpret_cast< wxWindow * >(argp1);
38836 {
38837 PyThreadState* __tstate = wxPyBeginAllowThreads();
38838 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
38839 wxPyEndAllowThreads(__tstate);
38840 if (PyErr_Occurred()) SWIG_fail;
38841 }
38842 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
38843 return resultobj;
38844 fail:
38845 return NULL;
38846 }
38847
38848
38849 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38850 PyObject *resultobj = 0;
38851 wxWindow *arg1 = (wxWindow *) 0 ;
38852 int arg2 ;
38853 int arg3 ;
38854 int arg4 = (int) 1 ;
38855 int arg5 = (int) 1 ;
38856 bool result;
38857 void *argp1 = 0 ;
38858 int res1 = 0 ;
38859 int val2 ;
38860 int ecode2 = 0 ;
38861 int val3 ;
38862 int ecode3 = 0 ;
38863 int val4 ;
38864 int ecode4 = 0 ;
38865 int val5 ;
38866 int ecode5 = 0 ;
38867 PyObject * obj0 = 0 ;
38868 PyObject * obj1 = 0 ;
38869 PyObject * obj2 = 0 ;
38870 PyObject * obj3 = 0 ;
38871 PyObject * obj4 = 0 ;
38872 char * kwnames[] = {
38873 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
38874 };
38875
38876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38878 if (!SWIG_IsOK(res1)) {
38879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
38880 }
38881 arg1 = reinterpret_cast< wxWindow * >(argp1);
38882 ecode2 = SWIG_AsVal_int(obj1, &val2);
38883 if (!SWIG_IsOK(ecode2)) {
38884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38885 }
38886 arg2 = static_cast< int >(val2);
38887 ecode3 = SWIG_AsVal_int(obj2, &val3);
38888 if (!SWIG_IsOK(ecode3)) {
38889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38890 }
38891 arg3 = static_cast< int >(val3);
38892 if (obj3) {
38893 ecode4 = SWIG_AsVal_int(obj3, &val4);
38894 if (!SWIG_IsOK(ecode4)) {
38895 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38896 }
38897 arg4 = static_cast< int >(val4);
38898 }
38899 if (obj4) {
38900 ecode5 = SWIG_AsVal_int(obj4, &val5);
38901 if (!SWIG_IsOK(ecode5)) {
38902 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38903 }
38904 arg5 = static_cast< int >(val5);
38905 }
38906 {
38907 PyThreadState* __tstate = wxPyBeginAllowThreads();
38908 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38909 wxPyEndAllowThreads(__tstate);
38910 if (PyErr_Occurred()) SWIG_fail;
38911 }
38912 {
38913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38914 }
38915 return resultobj;
38916 fail:
38917 return NULL;
38918 }
38919
38920
38921 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38922 PyObject *resultobj = 0;
38923 wxWindow *arg1 = (wxWindow *) 0 ;
38924 wxPoint *arg2 = 0 ;
38925 bool result;
38926 void *argp1 = 0 ;
38927 int res1 = 0 ;
38928 wxPoint temp2 ;
38929 PyObject * obj0 = 0 ;
38930 PyObject * obj1 = 0 ;
38931 char * kwnames[] = {
38932 (char *) "self",(char *) "pt", NULL
38933 };
38934
38935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38937 if (!SWIG_IsOK(res1)) {
38938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38939 }
38940 arg1 = reinterpret_cast< wxWindow * >(argp1);
38941 {
38942 arg2 = &temp2;
38943 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38944 }
38945 {
38946 PyThreadState* __tstate = wxPyBeginAllowThreads();
38947 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38948 wxPyEndAllowThreads(__tstate);
38949 if (PyErr_Occurred()) SWIG_fail;
38950 }
38951 {
38952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38953 }
38954 return resultobj;
38955 fail:
38956 return NULL;
38957 }
38958
38959
38960 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38961 PyObject *resultobj = 0;
38962 wxWindow *arg1 = (wxWindow *) 0 ;
38963 wxRect *arg2 = 0 ;
38964 bool result;
38965 void *argp1 = 0 ;
38966 int res1 = 0 ;
38967 wxRect temp2 ;
38968 PyObject * obj0 = 0 ;
38969 PyObject * obj1 = 0 ;
38970 char * kwnames[] = {
38971 (char *) "self",(char *) "rect", NULL
38972 };
38973
38974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38976 if (!SWIG_IsOK(res1)) {
38977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38978 }
38979 arg1 = reinterpret_cast< wxWindow * >(argp1);
38980 {
38981 arg2 = &temp2;
38982 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38983 }
38984 {
38985 PyThreadState* __tstate = wxPyBeginAllowThreads();
38986 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38987 wxPyEndAllowThreads(__tstate);
38988 if (PyErr_Occurred()) SWIG_fail;
38989 }
38990 {
38991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38992 }
38993 return resultobj;
38994 fail:
38995 return NULL;
38996 }
38997
38998
38999 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39000 PyObject *resultobj = 0;
39001 wxWindow *arg1 = (wxWindow *) 0 ;
39002 SwigValueWrapper<wxVisualAttributes > result;
39003 void *argp1 = 0 ;
39004 int res1 = 0 ;
39005 PyObject *swig_obj[1] ;
39006
39007 if (!args) SWIG_fail;
39008 swig_obj[0] = args;
39009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39010 if (!SWIG_IsOK(res1)) {
39011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
39012 }
39013 arg1 = reinterpret_cast< wxWindow * >(argp1);
39014 {
39015 PyThreadState* __tstate = wxPyBeginAllowThreads();
39016 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
39017 wxPyEndAllowThreads(__tstate);
39018 if (PyErr_Occurred()) SWIG_fail;
39019 }
39020 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
39021 return resultobj;
39022 fail:
39023 return NULL;
39024 }
39025
39026
39027 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39028 PyObject *resultobj = 0;
39029 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
39030 SwigValueWrapper<wxVisualAttributes > result;
39031 int val1 ;
39032 int ecode1 = 0 ;
39033 PyObject * obj0 = 0 ;
39034 char * kwnames[] = {
39035 (char *) "variant", NULL
39036 };
39037
39038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
39039 if (obj0) {
39040 ecode1 = SWIG_AsVal_int(obj0, &val1);
39041 if (!SWIG_IsOK(ecode1)) {
39042 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
39043 }
39044 arg1 = static_cast< wxWindowVariant >(val1);
39045 }
39046 {
39047 if (!wxPyCheckForApp()) SWIG_fail;
39048 PyThreadState* __tstate = wxPyBeginAllowThreads();
39049 result = wxWindow::GetClassDefaultAttributes(arg1);
39050 wxPyEndAllowThreads(__tstate);
39051 if (PyErr_Occurred()) SWIG_fail;
39052 }
39053 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
39054 return resultobj;
39055 fail:
39056 return NULL;
39057 }
39058
39059
39060 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39061 PyObject *resultobj = 0;
39062 wxWindow *arg1 = (wxWindow *) 0 ;
39063 wxColour *arg2 = 0 ;
39064 bool result;
39065 void *argp1 = 0 ;
39066 int res1 = 0 ;
39067 wxColour temp2 ;
39068 PyObject * obj0 = 0 ;
39069 PyObject * obj1 = 0 ;
39070 char * kwnames[] = {
39071 (char *) "self",(char *) "colour", NULL
39072 };
39073
39074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39076 if (!SWIG_IsOK(res1)) {
39077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39078 }
39079 arg1 = reinterpret_cast< wxWindow * >(argp1);
39080 {
39081 arg2 = &temp2;
39082 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39083 }
39084 {
39085 PyThreadState* __tstate = wxPyBeginAllowThreads();
39086 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
39087 wxPyEndAllowThreads(__tstate);
39088 if (PyErr_Occurred()) SWIG_fail;
39089 }
39090 {
39091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39092 }
39093 return resultobj;
39094 fail:
39095 return NULL;
39096 }
39097
39098
39099 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39100 PyObject *resultobj = 0;
39101 wxWindow *arg1 = (wxWindow *) 0 ;
39102 wxColour *arg2 = 0 ;
39103 void *argp1 = 0 ;
39104 int res1 = 0 ;
39105 wxColour temp2 ;
39106 PyObject * obj0 = 0 ;
39107 PyObject * obj1 = 0 ;
39108 char * kwnames[] = {
39109 (char *) "self",(char *) "colour", NULL
39110 };
39111
39112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39114 if (!SWIG_IsOK(res1)) {
39115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39116 }
39117 arg1 = reinterpret_cast< wxWindow * >(argp1);
39118 {
39119 arg2 = &temp2;
39120 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39121 }
39122 {
39123 PyThreadState* __tstate = wxPyBeginAllowThreads();
39124 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
39125 wxPyEndAllowThreads(__tstate);
39126 if (PyErr_Occurred()) SWIG_fail;
39127 }
39128 resultobj = SWIG_Py_Void();
39129 return resultobj;
39130 fail:
39131 return NULL;
39132 }
39133
39134
39135 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39136 PyObject *resultobj = 0;
39137 wxWindow *arg1 = (wxWindow *) 0 ;
39138 wxColour *arg2 = 0 ;
39139 bool result;
39140 void *argp1 = 0 ;
39141 int res1 = 0 ;
39142 wxColour temp2 ;
39143 PyObject * obj0 = 0 ;
39144 PyObject * obj1 = 0 ;
39145 char * kwnames[] = {
39146 (char *) "self",(char *) "colour", NULL
39147 };
39148
39149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39151 if (!SWIG_IsOK(res1)) {
39152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39153 }
39154 arg1 = reinterpret_cast< wxWindow * >(argp1);
39155 {
39156 arg2 = &temp2;
39157 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39158 }
39159 {
39160 PyThreadState* __tstate = wxPyBeginAllowThreads();
39161 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
39162 wxPyEndAllowThreads(__tstate);
39163 if (PyErr_Occurred()) SWIG_fail;
39164 }
39165 {
39166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39167 }
39168 return resultobj;
39169 fail:
39170 return NULL;
39171 }
39172
39173
39174 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39175 PyObject *resultobj = 0;
39176 wxWindow *arg1 = (wxWindow *) 0 ;
39177 wxColour *arg2 = 0 ;
39178 void *argp1 = 0 ;
39179 int res1 = 0 ;
39180 wxColour temp2 ;
39181 PyObject * obj0 = 0 ;
39182 PyObject * obj1 = 0 ;
39183 char * kwnames[] = {
39184 (char *) "self",(char *) "colour", NULL
39185 };
39186
39187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39189 if (!SWIG_IsOK(res1)) {
39190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39191 }
39192 arg1 = reinterpret_cast< wxWindow * >(argp1);
39193 {
39194 arg2 = &temp2;
39195 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39196 }
39197 {
39198 PyThreadState* __tstate = wxPyBeginAllowThreads();
39199 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
39200 wxPyEndAllowThreads(__tstate);
39201 if (PyErr_Occurred()) SWIG_fail;
39202 }
39203 resultobj = SWIG_Py_Void();
39204 return resultobj;
39205 fail:
39206 return NULL;
39207 }
39208
39209
39210 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39211 PyObject *resultobj = 0;
39212 wxWindow *arg1 = (wxWindow *) 0 ;
39213 wxColour result;
39214 void *argp1 = 0 ;
39215 int res1 = 0 ;
39216 PyObject *swig_obj[1] ;
39217
39218 if (!args) SWIG_fail;
39219 swig_obj[0] = args;
39220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39221 if (!SWIG_IsOK(res1)) {
39222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
39223 }
39224 arg1 = reinterpret_cast< wxWindow * >(argp1);
39225 {
39226 PyThreadState* __tstate = wxPyBeginAllowThreads();
39227 result = ((wxWindow const *)arg1)->GetBackgroundColour();
39228 wxPyEndAllowThreads(__tstate);
39229 if (PyErr_Occurred()) SWIG_fail;
39230 }
39231 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
39232 return resultobj;
39233 fail:
39234 return NULL;
39235 }
39236
39237
39238 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39239 PyObject *resultobj = 0;
39240 wxWindow *arg1 = (wxWindow *) 0 ;
39241 wxColour result;
39242 void *argp1 = 0 ;
39243 int res1 = 0 ;
39244 PyObject *swig_obj[1] ;
39245
39246 if (!args) SWIG_fail;
39247 swig_obj[0] = args;
39248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39249 if (!SWIG_IsOK(res1)) {
39250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
39251 }
39252 arg1 = reinterpret_cast< wxWindow * >(argp1);
39253 {
39254 PyThreadState* __tstate = wxPyBeginAllowThreads();
39255 result = ((wxWindow const *)arg1)->GetForegroundColour();
39256 wxPyEndAllowThreads(__tstate);
39257 if (PyErr_Occurred()) SWIG_fail;
39258 }
39259 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
39260 return resultobj;
39261 fail:
39262 return NULL;
39263 }
39264
39265
39266 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39267 PyObject *resultobj = 0;
39268 wxWindow *arg1 = (wxWindow *) 0 ;
39269 bool result;
39270 void *argp1 = 0 ;
39271 int res1 = 0 ;
39272 PyObject *swig_obj[1] ;
39273
39274 if (!args) SWIG_fail;
39275 swig_obj[0] = args;
39276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39277 if (!SWIG_IsOK(res1)) {
39278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
39279 }
39280 arg1 = reinterpret_cast< wxWindow * >(argp1);
39281 {
39282 PyThreadState* __tstate = wxPyBeginAllowThreads();
39283 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
39284 wxPyEndAllowThreads(__tstate);
39285 if (PyErr_Occurred()) SWIG_fail;
39286 }
39287 {
39288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39289 }
39290 return resultobj;
39291 fail:
39292 return NULL;
39293 }
39294
39295
39296 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39297 PyObject *resultobj = 0;
39298 wxWindow *arg1 = (wxWindow *) 0 ;
39299 bool result;
39300 void *argp1 = 0 ;
39301 int res1 = 0 ;
39302 PyObject *swig_obj[1] ;
39303
39304 if (!args) SWIG_fail;
39305 swig_obj[0] = args;
39306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39307 if (!SWIG_IsOK(res1)) {
39308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
39309 }
39310 arg1 = reinterpret_cast< wxWindow * >(argp1);
39311 {
39312 PyThreadState* __tstate = wxPyBeginAllowThreads();
39313 result = (bool)((wxWindow const *)arg1)->UseBgCol();
39314 wxPyEndAllowThreads(__tstate);
39315 if (PyErr_Occurred()) SWIG_fail;
39316 }
39317 {
39318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39319 }
39320 return resultobj;
39321 fail:
39322 return NULL;
39323 }
39324
39325
39326 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39327 PyObject *resultobj = 0;
39328 wxWindow *arg1 = (wxWindow *) 0 ;
39329 wxBackgroundStyle arg2 ;
39330 bool result;
39331 void *argp1 = 0 ;
39332 int res1 = 0 ;
39333 int val2 ;
39334 int ecode2 = 0 ;
39335 PyObject * obj0 = 0 ;
39336 PyObject * obj1 = 0 ;
39337 char * kwnames[] = {
39338 (char *) "self",(char *) "style", NULL
39339 };
39340
39341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
39342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39343 if (!SWIG_IsOK(res1)) {
39344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
39345 }
39346 arg1 = reinterpret_cast< wxWindow * >(argp1);
39347 ecode2 = SWIG_AsVal_int(obj1, &val2);
39348 if (!SWIG_IsOK(ecode2)) {
39349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
39350 }
39351 arg2 = static_cast< wxBackgroundStyle >(val2);
39352 {
39353 PyThreadState* __tstate = wxPyBeginAllowThreads();
39354 result = (bool)(arg1)->SetBackgroundStyle(arg2);
39355 wxPyEndAllowThreads(__tstate);
39356 if (PyErr_Occurred()) SWIG_fail;
39357 }
39358 {
39359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39360 }
39361 return resultobj;
39362 fail:
39363 return NULL;
39364 }
39365
39366
39367 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39368 PyObject *resultobj = 0;
39369 wxWindow *arg1 = (wxWindow *) 0 ;
39370 wxBackgroundStyle result;
39371 void *argp1 = 0 ;
39372 int res1 = 0 ;
39373 PyObject *swig_obj[1] ;
39374
39375 if (!args) SWIG_fail;
39376 swig_obj[0] = args;
39377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39378 if (!SWIG_IsOK(res1)) {
39379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
39380 }
39381 arg1 = reinterpret_cast< wxWindow * >(argp1);
39382 {
39383 PyThreadState* __tstate = wxPyBeginAllowThreads();
39384 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
39385 wxPyEndAllowThreads(__tstate);
39386 if (PyErr_Occurred()) SWIG_fail;
39387 }
39388 resultobj = SWIG_From_int(static_cast< int >(result));
39389 return resultobj;
39390 fail:
39391 return NULL;
39392 }
39393
39394
39395 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39396 PyObject *resultobj = 0;
39397 wxWindow *arg1 = (wxWindow *) 0 ;
39398 bool result;
39399 void *argp1 = 0 ;
39400 int res1 = 0 ;
39401 PyObject *swig_obj[1] ;
39402
39403 if (!args) SWIG_fail;
39404 swig_obj[0] = args;
39405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39406 if (!SWIG_IsOK(res1)) {
39407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
39408 }
39409 arg1 = reinterpret_cast< wxWindow * >(argp1);
39410 {
39411 PyThreadState* __tstate = wxPyBeginAllowThreads();
39412 result = (bool)(arg1)->HasTransparentBackground();
39413 wxPyEndAllowThreads(__tstate);
39414 if (PyErr_Occurred()) SWIG_fail;
39415 }
39416 {
39417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39418 }
39419 return resultobj;
39420 fail:
39421 return NULL;
39422 }
39423
39424
39425 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39426 PyObject *resultobj = 0;
39427 wxWindow *arg1 = (wxWindow *) 0 ;
39428 wxCursor *arg2 = 0 ;
39429 bool result;
39430 void *argp1 = 0 ;
39431 int res1 = 0 ;
39432 void *argp2 = 0 ;
39433 int res2 = 0 ;
39434 PyObject * obj0 = 0 ;
39435 PyObject * obj1 = 0 ;
39436 char * kwnames[] = {
39437 (char *) "self",(char *) "cursor", NULL
39438 };
39439
39440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
39441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39442 if (!SWIG_IsOK(res1)) {
39443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
39444 }
39445 arg1 = reinterpret_cast< wxWindow * >(argp1);
39446 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
39447 if (!SWIG_IsOK(res2)) {
39448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
39449 }
39450 if (!argp2) {
39451 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
39452 }
39453 arg2 = reinterpret_cast< wxCursor * >(argp2);
39454 {
39455 PyThreadState* __tstate = wxPyBeginAllowThreads();
39456 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
39457 wxPyEndAllowThreads(__tstate);
39458 if (PyErr_Occurred()) SWIG_fail;
39459 }
39460 {
39461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39462 }
39463 return resultobj;
39464 fail:
39465 return NULL;
39466 }
39467
39468
39469 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39470 PyObject *resultobj = 0;
39471 wxWindow *arg1 = (wxWindow *) 0 ;
39472 wxCursor result;
39473 void *argp1 = 0 ;
39474 int res1 = 0 ;
39475 PyObject *swig_obj[1] ;
39476
39477 if (!args) SWIG_fail;
39478 swig_obj[0] = args;
39479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39480 if (!SWIG_IsOK(res1)) {
39481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
39482 }
39483 arg1 = reinterpret_cast< wxWindow * >(argp1);
39484 {
39485 PyThreadState* __tstate = wxPyBeginAllowThreads();
39486 result = (arg1)->GetCursor();
39487 wxPyEndAllowThreads(__tstate);
39488 if (PyErr_Occurred()) SWIG_fail;
39489 }
39490 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
39491 return resultobj;
39492 fail:
39493 return NULL;
39494 }
39495
39496
39497 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39498 PyObject *resultobj = 0;
39499 wxWindow *arg1 = (wxWindow *) 0 ;
39500 wxFont *arg2 = 0 ;
39501 bool result;
39502 void *argp1 = 0 ;
39503 int res1 = 0 ;
39504 void *argp2 = 0 ;
39505 int res2 = 0 ;
39506 PyObject * obj0 = 0 ;
39507 PyObject * obj1 = 0 ;
39508 char * kwnames[] = {
39509 (char *) "self",(char *) "font", NULL
39510 };
39511
39512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
39513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39514 if (!SWIG_IsOK(res1)) {
39515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39516 }
39517 arg1 = reinterpret_cast< wxWindow * >(argp1);
39518 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
39519 if (!SWIG_IsOK(res2)) {
39520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39521 }
39522 if (!argp2) {
39523 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39524 }
39525 arg2 = reinterpret_cast< wxFont * >(argp2);
39526 {
39527 PyThreadState* __tstate = wxPyBeginAllowThreads();
39528 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
39529 wxPyEndAllowThreads(__tstate);
39530 if (PyErr_Occurred()) SWIG_fail;
39531 }
39532 {
39533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39534 }
39535 return resultobj;
39536 fail:
39537 return NULL;
39538 }
39539
39540
39541 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39542 PyObject *resultobj = 0;
39543 wxWindow *arg1 = (wxWindow *) 0 ;
39544 wxFont *arg2 = 0 ;
39545 void *argp1 = 0 ;
39546 int res1 = 0 ;
39547 void *argp2 = 0 ;
39548 int res2 = 0 ;
39549 PyObject * obj0 = 0 ;
39550 PyObject * obj1 = 0 ;
39551 char * kwnames[] = {
39552 (char *) "self",(char *) "font", NULL
39553 };
39554
39555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
39556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39557 if (!SWIG_IsOK(res1)) {
39558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39559 }
39560 arg1 = reinterpret_cast< wxWindow * >(argp1);
39561 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
39562 if (!SWIG_IsOK(res2)) {
39563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39564 }
39565 if (!argp2) {
39566 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39567 }
39568 arg2 = reinterpret_cast< wxFont * >(argp2);
39569 {
39570 PyThreadState* __tstate = wxPyBeginAllowThreads();
39571 (arg1)->SetOwnFont((wxFont const &)*arg2);
39572 wxPyEndAllowThreads(__tstate);
39573 if (PyErr_Occurred()) SWIG_fail;
39574 }
39575 resultobj = SWIG_Py_Void();
39576 return resultobj;
39577 fail:
39578 return NULL;
39579 }
39580
39581
39582 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39583 PyObject *resultobj = 0;
39584 wxWindow *arg1 = (wxWindow *) 0 ;
39585 wxFont result;
39586 void *argp1 = 0 ;
39587 int res1 = 0 ;
39588 PyObject *swig_obj[1] ;
39589
39590 if (!args) SWIG_fail;
39591 swig_obj[0] = args;
39592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39593 if (!SWIG_IsOK(res1)) {
39594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39595 }
39596 arg1 = reinterpret_cast< wxWindow * >(argp1);
39597 {
39598 PyThreadState* __tstate = wxPyBeginAllowThreads();
39599 result = (arg1)->GetFont();
39600 wxPyEndAllowThreads(__tstate);
39601 if (PyErr_Occurred()) SWIG_fail;
39602 }
39603 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
39604 return resultobj;
39605 fail:
39606 return NULL;
39607 }
39608
39609
39610 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39611 PyObject *resultobj = 0;
39612 wxWindow *arg1 = (wxWindow *) 0 ;
39613 wxCaret *arg2 = (wxCaret *) 0 ;
39614 void *argp1 = 0 ;
39615 int res1 = 0 ;
39616 int res2 = 0 ;
39617 PyObject * obj0 = 0 ;
39618 PyObject * obj1 = 0 ;
39619 char * kwnames[] = {
39620 (char *) "self",(char *) "caret", NULL
39621 };
39622
39623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
39624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39625 if (!SWIG_IsOK(res1)) {
39626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
39627 }
39628 arg1 = reinterpret_cast< wxWindow * >(argp1);
39629 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
39630 if (!SWIG_IsOK(res2)) {
39631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
39632 }
39633 {
39634 PyThreadState* __tstate = wxPyBeginAllowThreads();
39635 (arg1)->SetCaret(arg2);
39636 wxPyEndAllowThreads(__tstate);
39637 if (PyErr_Occurred()) SWIG_fail;
39638 }
39639 resultobj = SWIG_Py_Void();
39640 return resultobj;
39641 fail:
39642 return NULL;
39643 }
39644
39645
39646 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39647 PyObject *resultobj = 0;
39648 wxWindow *arg1 = (wxWindow *) 0 ;
39649 wxCaret *result = 0 ;
39650 void *argp1 = 0 ;
39651 int res1 = 0 ;
39652 PyObject *swig_obj[1] ;
39653
39654 if (!args) SWIG_fail;
39655 swig_obj[0] = args;
39656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39657 if (!SWIG_IsOK(res1)) {
39658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
39659 }
39660 arg1 = reinterpret_cast< wxWindow * >(argp1);
39661 {
39662 PyThreadState* __tstate = wxPyBeginAllowThreads();
39663 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
39664 wxPyEndAllowThreads(__tstate);
39665 if (PyErr_Occurred()) SWIG_fail;
39666 }
39667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
39668 return resultobj;
39669 fail:
39670 return NULL;
39671 }
39672
39673
39674 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39675 PyObject *resultobj = 0;
39676 wxWindow *arg1 = (wxWindow *) 0 ;
39677 int result;
39678 void *argp1 = 0 ;
39679 int res1 = 0 ;
39680 PyObject *swig_obj[1] ;
39681
39682 if (!args) SWIG_fail;
39683 swig_obj[0] = args;
39684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39685 if (!SWIG_IsOK(res1)) {
39686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
39687 }
39688 arg1 = reinterpret_cast< wxWindow * >(argp1);
39689 {
39690 PyThreadState* __tstate = wxPyBeginAllowThreads();
39691 result = (int)((wxWindow const *)arg1)->GetCharHeight();
39692 wxPyEndAllowThreads(__tstate);
39693 if (PyErr_Occurred()) SWIG_fail;
39694 }
39695 resultobj = SWIG_From_int(static_cast< int >(result));
39696 return resultobj;
39697 fail:
39698 return NULL;
39699 }
39700
39701
39702 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39703 PyObject *resultobj = 0;
39704 wxWindow *arg1 = (wxWindow *) 0 ;
39705 int result;
39706 void *argp1 = 0 ;
39707 int res1 = 0 ;
39708 PyObject *swig_obj[1] ;
39709
39710 if (!args) SWIG_fail;
39711 swig_obj[0] = args;
39712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39713 if (!SWIG_IsOK(res1)) {
39714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
39715 }
39716 arg1 = reinterpret_cast< wxWindow * >(argp1);
39717 {
39718 PyThreadState* __tstate = wxPyBeginAllowThreads();
39719 result = (int)((wxWindow const *)arg1)->GetCharWidth();
39720 wxPyEndAllowThreads(__tstate);
39721 if (PyErr_Occurred()) SWIG_fail;
39722 }
39723 resultobj = SWIG_From_int(static_cast< int >(result));
39724 return resultobj;
39725 fail:
39726 return NULL;
39727 }
39728
39729
39730 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39731 PyObject *resultobj = 0;
39732 wxWindow *arg1 = (wxWindow *) 0 ;
39733 wxString *arg2 = 0 ;
39734 int *arg3 = (int *) 0 ;
39735 int *arg4 = (int *) 0 ;
39736 void *argp1 = 0 ;
39737 int res1 = 0 ;
39738 bool temp2 = false ;
39739 int temp3 ;
39740 int res3 = SWIG_TMPOBJ ;
39741 int temp4 ;
39742 int res4 = SWIG_TMPOBJ ;
39743 PyObject * obj0 = 0 ;
39744 PyObject * obj1 = 0 ;
39745 char * kwnames[] = {
39746 (char *) "self",(char *) "string", NULL
39747 };
39748
39749 arg3 = &temp3;
39750 arg4 = &temp4;
39751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
39752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39753 if (!SWIG_IsOK(res1)) {
39754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39755 }
39756 arg1 = reinterpret_cast< wxWindow * >(argp1);
39757 {
39758 arg2 = wxString_in_helper(obj1);
39759 if (arg2 == NULL) SWIG_fail;
39760 temp2 = true;
39761 }
39762 {
39763 PyThreadState* __tstate = wxPyBeginAllowThreads();
39764 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
39765 wxPyEndAllowThreads(__tstate);
39766 if (PyErr_Occurred()) SWIG_fail;
39767 }
39768 resultobj = SWIG_Py_Void();
39769 if (SWIG_IsTmpObj(res3)) {
39770 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39771 } else {
39772 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39773 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39774 }
39775 if (SWIG_IsTmpObj(res4)) {
39776 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39777 } else {
39778 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39779 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39780 }
39781 {
39782 if (temp2)
39783 delete arg2;
39784 }
39785 return resultobj;
39786 fail:
39787 {
39788 if (temp2)
39789 delete arg2;
39790 }
39791 return NULL;
39792 }
39793
39794
39795 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39796 PyObject *resultobj = 0;
39797 wxWindow *arg1 = (wxWindow *) 0 ;
39798 wxString *arg2 = 0 ;
39799 int *arg3 = (int *) 0 ;
39800 int *arg4 = (int *) 0 ;
39801 int *arg5 = (int *) 0 ;
39802 int *arg6 = (int *) 0 ;
39803 wxFont *arg7 = (wxFont *) NULL ;
39804 void *argp1 = 0 ;
39805 int res1 = 0 ;
39806 bool temp2 = false ;
39807 int temp3 ;
39808 int res3 = SWIG_TMPOBJ ;
39809 int temp4 ;
39810 int res4 = SWIG_TMPOBJ ;
39811 int temp5 ;
39812 int res5 = SWIG_TMPOBJ ;
39813 int temp6 ;
39814 int res6 = SWIG_TMPOBJ ;
39815 void *argp7 = 0 ;
39816 int res7 = 0 ;
39817 PyObject * obj0 = 0 ;
39818 PyObject * obj1 = 0 ;
39819 PyObject * obj2 = 0 ;
39820 char * kwnames[] = {
39821 (char *) "self",(char *) "string",(char *) "font", NULL
39822 };
39823
39824 arg3 = &temp3;
39825 arg4 = &temp4;
39826 arg5 = &temp5;
39827 arg6 = &temp6;
39828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39830 if (!SWIG_IsOK(res1)) {
39831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39832 }
39833 arg1 = reinterpret_cast< wxWindow * >(argp1);
39834 {
39835 arg2 = wxString_in_helper(obj1);
39836 if (arg2 == NULL) SWIG_fail;
39837 temp2 = true;
39838 }
39839 if (obj2) {
39840 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
39841 if (!SWIG_IsOK(res7)) {
39842 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
39843 }
39844 arg7 = reinterpret_cast< wxFont * >(argp7);
39845 }
39846 {
39847 PyThreadState* __tstate = wxPyBeginAllowThreads();
39848 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
39849 wxPyEndAllowThreads(__tstate);
39850 if (PyErr_Occurred()) SWIG_fail;
39851 }
39852 resultobj = SWIG_Py_Void();
39853 if (SWIG_IsTmpObj(res3)) {
39854 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39855 } else {
39856 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39857 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39858 }
39859 if (SWIG_IsTmpObj(res4)) {
39860 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39861 } else {
39862 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39863 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39864 }
39865 if (SWIG_IsTmpObj(res5)) {
39866 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
39867 } else {
39868 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39869 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
39870 }
39871 if (SWIG_IsTmpObj(res6)) {
39872 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
39873 } else {
39874 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39875 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
39876 }
39877 {
39878 if (temp2)
39879 delete arg2;
39880 }
39881 return resultobj;
39882 fail:
39883 {
39884 if (temp2)
39885 delete arg2;
39886 }
39887 return NULL;
39888 }
39889
39890
39891 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39892 PyObject *resultobj = 0;
39893 wxWindow *arg1 = (wxWindow *) 0 ;
39894 int *arg2 = (int *) 0 ;
39895 int *arg3 = (int *) 0 ;
39896 void *argp1 = 0 ;
39897 int res1 = 0 ;
39898 int temp2 ;
39899 int res2 = 0 ;
39900 int temp3 ;
39901 int res3 = 0 ;
39902 PyObject * obj0 = 0 ;
39903 PyObject * obj1 = 0 ;
39904 PyObject * obj2 = 0 ;
39905 char * kwnames[] = {
39906 (char *) "self",(char *) "x",(char *) "y", NULL
39907 };
39908
39909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39911 if (!SWIG_IsOK(res1)) {
39912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39913 }
39914 arg1 = reinterpret_cast< wxWindow * >(argp1);
39915 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39916 int val;
39917 int ecode = SWIG_AsVal_int(obj1, &val);
39918 if (!SWIG_IsOK(ecode)) {
39919 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39920 }
39921 temp2 = static_cast< int >(val);
39922 arg2 = &temp2;
39923 res2 = SWIG_AddTmpMask(ecode);
39924 }
39925 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39926 int val;
39927 int ecode = SWIG_AsVal_int(obj2, &val);
39928 if (!SWIG_IsOK(ecode)) {
39929 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39930 }
39931 temp3 = static_cast< int >(val);
39932 arg3 = &temp3;
39933 res3 = SWIG_AddTmpMask(ecode);
39934 }
39935 {
39936 PyThreadState* __tstate = wxPyBeginAllowThreads();
39937 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39938 wxPyEndAllowThreads(__tstate);
39939 if (PyErr_Occurred()) SWIG_fail;
39940 }
39941 resultobj = SWIG_Py_Void();
39942 if (SWIG_IsTmpObj(res2)) {
39943 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39944 } else {
39945 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39946 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39947 }
39948 if (SWIG_IsTmpObj(res3)) {
39949 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39950 } else {
39951 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39952 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39953 }
39954 return resultobj;
39955 fail:
39956 return NULL;
39957 }
39958
39959
39960 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39961 PyObject *resultobj = 0;
39962 wxWindow *arg1 = (wxWindow *) 0 ;
39963 int *arg2 = (int *) 0 ;
39964 int *arg3 = (int *) 0 ;
39965 void *argp1 = 0 ;
39966 int res1 = 0 ;
39967 int temp2 ;
39968 int res2 = 0 ;
39969 int temp3 ;
39970 int res3 = 0 ;
39971 PyObject * obj0 = 0 ;
39972 PyObject * obj1 = 0 ;
39973 PyObject * obj2 = 0 ;
39974 char * kwnames[] = {
39975 (char *) "self",(char *) "x",(char *) "y", NULL
39976 };
39977
39978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39980 if (!SWIG_IsOK(res1)) {
39981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39982 }
39983 arg1 = reinterpret_cast< wxWindow * >(argp1);
39984 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39985 int val;
39986 int ecode = SWIG_AsVal_int(obj1, &val);
39987 if (!SWIG_IsOK(ecode)) {
39988 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39989 }
39990 temp2 = static_cast< int >(val);
39991 arg2 = &temp2;
39992 res2 = SWIG_AddTmpMask(ecode);
39993 }
39994 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39995 int val;
39996 int ecode = SWIG_AsVal_int(obj2, &val);
39997 if (!SWIG_IsOK(ecode)) {
39998 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39999 }
40000 temp3 = static_cast< int >(val);
40001 arg3 = &temp3;
40002 res3 = SWIG_AddTmpMask(ecode);
40003 }
40004 {
40005 PyThreadState* __tstate = wxPyBeginAllowThreads();
40006 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
40007 wxPyEndAllowThreads(__tstate);
40008 if (PyErr_Occurred()) SWIG_fail;
40009 }
40010 resultobj = SWIG_Py_Void();
40011 if (SWIG_IsTmpObj(res2)) {
40012 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
40013 } else {
40014 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
40015 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
40016 }
40017 if (SWIG_IsTmpObj(res3)) {
40018 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
40019 } else {
40020 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
40021 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
40022 }
40023 return resultobj;
40024 fail:
40025 return NULL;
40026 }
40027
40028
40029 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40030 PyObject *resultobj = 0;
40031 wxWindow *arg1 = (wxWindow *) 0 ;
40032 wxPoint *arg2 = 0 ;
40033 wxPoint result;
40034 void *argp1 = 0 ;
40035 int res1 = 0 ;
40036 wxPoint temp2 ;
40037 PyObject * obj0 = 0 ;
40038 PyObject * obj1 = 0 ;
40039 char * kwnames[] = {
40040 (char *) "self",(char *) "pt", NULL
40041 };
40042
40043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
40044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40045 if (!SWIG_IsOK(res1)) {
40046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
40047 }
40048 arg1 = reinterpret_cast< wxWindow * >(argp1);
40049 {
40050 arg2 = &temp2;
40051 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40052 }
40053 {
40054 PyThreadState* __tstate = wxPyBeginAllowThreads();
40055 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
40056 wxPyEndAllowThreads(__tstate);
40057 if (PyErr_Occurred()) SWIG_fail;
40058 }
40059 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
40060 return resultobj;
40061 fail:
40062 return NULL;
40063 }
40064
40065
40066 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40067 PyObject *resultobj = 0;
40068 wxWindow *arg1 = (wxWindow *) 0 ;
40069 wxPoint *arg2 = 0 ;
40070 wxPoint result;
40071 void *argp1 = 0 ;
40072 int res1 = 0 ;
40073 wxPoint temp2 ;
40074 PyObject * obj0 = 0 ;
40075 PyObject * obj1 = 0 ;
40076 char * kwnames[] = {
40077 (char *) "self",(char *) "pt", NULL
40078 };
40079
40080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
40081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40082 if (!SWIG_IsOK(res1)) {
40083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
40084 }
40085 arg1 = reinterpret_cast< wxWindow * >(argp1);
40086 {
40087 arg2 = &temp2;
40088 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40089 }
40090 {
40091 PyThreadState* __tstate = wxPyBeginAllowThreads();
40092 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
40093 wxPyEndAllowThreads(__tstate);
40094 if (PyErr_Occurred()) SWIG_fail;
40095 }
40096 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
40097 return resultobj;
40098 fail:
40099 return NULL;
40100 }
40101
40102
40103 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40104 PyObject *resultobj = 0;
40105 wxWindow *arg1 = (wxWindow *) 0 ;
40106 int arg2 ;
40107 int arg3 ;
40108 wxHitTest result;
40109 void *argp1 = 0 ;
40110 int res1 = 0 ;
40111 int val2 ;
40112 int ecode2 = 0 ;
40113 int val3 ;
40114 int ecode3 = 0 ;
40115 PyObject * obj0 = 0 ;
40116 PyObject * obj1 = 0 ;
40117 PyObject * obj2 = 0 ;
40118 char * kwnames[] = {
40119 (char *) "self",(char *) "x",(char *) "y", NULL
40120 };
40121
40122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40124 if (!SWIG_IsOK(res1)) {
40125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
40126 }
40127 arg1 = reinterpret_cast< wxWindow * >(argp1);
40128 ecode2 = SWIG_AsVal_int(obj1, &val2);
40129 if (!SWIG_IsOK(ecode2)) {
40130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
40131 }
40132 arg2 = static_cast< int >(val2);
40133 ecode3 = SWIG_AsVal_int(obj2, &val3);
40134 if (!SWIG_IsOK(ecode3)) {
40135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
40136 }
40137 arg3 = static_cast< int >(val3);
40138 {
40139 PyThreadState* __tstate = wxPyBeginAllowThreads();
40140 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
40141 wxPyEndAllowThreads(__tstate);
40142 if (PyErr_Occurred()) SWIG_fail;
40143 }
40144 resultobj = SWIG_From_int(static_cast< int >(result));
40145 return resultobj;
40146 fail:
40147 return NULL;
40148 }
40149
40150
40151 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40152 PyObject *resultobj = 0;
40153 wxWindow *arg1 = (wxWindow *) 0 ;
40154 wxPoint *arg2 = 0 ;
40155 wxHitTest result;
40156 void *argp1 = 0 ;
40157 int res1 = 0 ;
40158 wxPoint temp2 ;
40159 PyObject * obj0 = 0 ;
40160 PyObject * obj1 = 0 ;
40161 char * kwnames[] = {
40162 (char *) "self",(char *) "pt", NULL
40163 };
40164
40165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
40166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40167 if (!SWIG_IsOK(res1)) {
40168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
40169 }
40170 arg1 = reinterpret_cast< wxWindow * >(argp1);
40171 {
40172 arg2 = &temp2;
40173 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40174 }
40175 {
40176 PyThreadState* __tstate = wxPyBeginAllowThreads();
40177 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
40178 wxPyEndAllowThreads(__tstate);
40179 if (PyErr_Occurred()) SWIG_fail;
40180 }
40181 resultobj = SWIG_From_int(static_cast< int >(result));
40182 return resultobj;
40183 fail:
40184 return NULL;
40185 }
40186
40187
40188 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
40189 PyObject *resultobj = 0;
40190 wxWindow *arg1 = (wxWindow *) 0 ;
40191 long arg2 ;
40192 wxBorder result;
40193 void *argp1 = 0 ;
40194 int res1 = 0 ;
40195 long val2 ;
40196 int ecode2 = 0 ;
40197
40198 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
40199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40200 if (!SWIG_IsOK(res1)) {
40201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
40202 }
40203 arg1 = reinterpret_cast< wxWindow * >(argp1);
40204 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
40205 if (!SWIG_IsOK(ecode2)) {
40206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
40207 }
40208 arg2 = static_cast< long >(val2);
40209 {
40210 PyThreadState* __tstate = wxPyBeginAllowThreads();
40211 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
40212 wxPyEndAllowThreads(__tstate);
40213 if (PyErr_Occurred()) SWIG_fail;
40214 }
40215 resultobj = SWIG_From_int(static_cast< int >(result));
40216 return resultobj;
40217 fail:
40218 return NULL;
40219 }
40220
40221
40222 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
40223 PyObject *resultobj = 0;
40224 wxWindow *arg1 = (wxWindow *) 0 ;
40225 wxBorder result;
40226 void *argp1 = 0 ;
40227 int res1 = 0 ;
40228
40229 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
40230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40231 if (!SWIG_IsOK(res1)) {
40232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
40233 }
40234 arg1 = reinterpret_cast< wxWindow * >(argp1);
40235 {
40236 PyThreadState* __tstate = wxPyBeginAllowThreads();
40237 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
40238 wxPyEndAllowThreads(__tstate);
40239 if (PyErr_Occurred()) SWIG_fail;
40240 }
40241 resultobj = SWIG_From_int(static_cast< int >(result));
40242 return resultobj;
40243 fail:
40244 return NULL;
40245 }
40246
40247
40248 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
40249 int argc;
40250 PyObject *argv[3];
40251
40252 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
40253 --argc;
40254 if (argc == 1) {
40255 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
40256 }
40257 if (argc == 2) {
40258 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
40259 }
40260
40261 fail:
40262 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
40263 return NULL;
40264 }
40265
40266
40267 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40268 PyObject *resultobj = 0;
40269 wxWindow *arg1 = (wxWindow *) 0 ;
40270 long arg2 = (long) wxUPDATE_UI_NONE ;
40271 void *argp1 = 0 ;
40272 int res1 = 0 ;
40273 long val2 ;
40274 int ecode2 = 0 ;
40275 PyObject * obj0 = 0 ;
40276 PyObject * obj1 = 0 ;
40277 char * kwnames[] = {
40278 (char *) "self",(char *) "flags", NULL
40279 };
40280
40281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
40282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40283 if (!SWIG_IsOK(res1)) {
40284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
40285 }
40286 arg1 = reinterpret_cast< wxWindow * >(argp1);
40287 if (obj1) {
40288 ecode2 = SWIG_AsVal_long(obj1, &val2);
40289 if (!SWIG_IsOK(ecode2)) {
40290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
40291 }
40292 arg2 = static_cast< long >(val2);
40293 }
40294 {
40295 PyThreadState* __tstate = wxPyBeginAllowThreads();
40296 (arg1)->UpdateWindowUI(arg2);
40297 wxPyEndAllowThreads(__tstate);
40298 if (PyErr_Occurred()) SWIG_fail;
40299 }
40300 resultobj = SWIG_Py_Void();
40301 return resultobj;
40302 fail:
40303 return NULL;
40304 }
40305
40306
40307 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40308 PyObject *resultobj = 0;
40309 wxWindow *arg1 = (wxWindow *) 0 ;
40310 wxMenu *arg2 = (wxMenu *) 0 ;
40311 int arg3 = (int) -1 ;
40312 int arg4 = (int) -1 ;
40313 bool result;
40314 void *argp1 = 0 ;
40315 int res1 = 0 ;
40316 void *argp2 = 0 ;
40317 int res2 = 0 ;
40318 int val3 ;
40319 int ecode3 = 0 ;
40320 int val4 ;
40321 int ecode4 = 0 ;
40322 PyObject * obj0 = 0 ;
40323 PyObject * obj1 = 0 ;
40324 PyObject * obj2 = 0 ;
40325 PyObject * obj3 = 0 ;
40326 char * kwnames[] = {
40327 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
40328 };
40329
40330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40332 if (!SWIG_IsOK(res1)) {
40333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
40334 }
40335 arg1 = reinterpret_cast< wxWindow * >(argp1);
40336 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40337 if (!SWIG_IsOK(res2)) {
40338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
40339 }
40340 arg2 = reinterpret_cast< wxMenu * >(argp2);
40341 if (obj2) {
40342 ecode3 = SWIG_AsVal_int(obj2, &val3);
40343 if (!SWIG_IsOK(ecode3)) {
40344 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
40345 }
40346 arg3 = static_cast< int >(val3);
40347 }
40348 if (obj3) {
40349 ecode4 = SWIG_AsVal_int(obj3, &val4);
40350 if (!SWIG_IsOK(ecode4)) {
40351 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
40352 }
40353 arg4 = static_cast< int >(val4);
40354 }
40355 {
40356 PyThreadState* __tstate = wxPyBeginAllowThreads();
40357 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
40358 wxPyEndAllowThreads(__tstate);
40359 if (PyErr_Occurred()) SWIG_fail;
40360 }
40361 {
40362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40363 }
40364 return resultobj;
40365 fail:
40366 return NULL;
40367 }
40368
40369
40370 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40371 PyObject *resultobj = 0;
40372 wxWindow *arg1 = (wxWindow *) 0 ;
40373 wxMenu *arg2 = (wxMenu *) 0 ;
40374 wxPoint const &arg3_defvalue = wxDefaultPosition ;
40375 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
40376 bool result;
40377 void *argp1 = 0 ;
40378 int res1 = 0 ;
40379 void *argp2 = 0 ;
40380 int res2 = 0 ;
40381 wxPoint temp3 ;
40382 PyObject * obj0 = 0 ;
40383 PyObject * obj1 = 0 ;
40384 PyObject * obj2 = 0 ;
40385 char * kwnames[] = {
40386 (char *) "self",(char *) "menu",(char *) "pos", NULL
40387 };
40388
40389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40391 if (!SWIG_IsOK(res1)) {
40392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
40393 }
40394 arg1 = reinterpret_cast< wxWindow * >(argp1);
40395 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40396 if (!SWIG_IsOK(res2)) {
40397 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
40398 }
40399 arg2 = reinterpret_cast< wxMenu * >(argp2);
40400 if (obj2) {
40401 {
40402 arg3 = &temp3;
40403 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
40404 }
40405 }
40406 {
40407 PyThreadState* __tstate = wxPyBeginAllowThreads();
40408 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
40409 wxPyEndAllowThreads(__tstate);
40410 if (PyErr_Occurred()) SWIG_fail;
40411 }
40412 {
40413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40414 }
40415 return resultobj;
40416 fail:
40417 return NULL;
40418 }
40419
40420
40421 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40422 PyObject *resultobj = 0;
40423 wxWindow *arg1 = (wxWindow *) 0 ;
40424 bool result;
40425 void *argp1 = 0 ;
40426 int res1 = 0 ;
40427 PyObject *swig_obj[1] ;
40428
40429 if (!args) SWIG_fail;
40430 swig_obj[0] = args;
40431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40432 if (!SWIG_IsOK(res1)) {
40433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
40434 }
40435 arg1 = reinterpret_cast< wxWindow * >(argp1);
40436 {
40437 PyThreadState* __tstate = wxPyBeginAllowThreads();
40438 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
40439 wxPyEndAllowThreads(__tstate);
40440 if (PyErr_Occurred()) SWIG_fail;
40441 }
40442 {
40443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40444 }
40445 return resultobj;
40446 fail:
40447 return NULL;
40448 }
40449
40450
40451 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40452 PyObject *resultobj = 0;
40453 wxWindow *arg1 = (wxWindow *) 0 ;
40454 long result;
40455 void *argp1 = 0 ;
40456 int res1 = 0 ;
40457 PyObject *swig_obj[1] ;
40458
40459 if (!args) SWIG_fail;
40460 swig_obj[0] = args;
40461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40462 if (!SWIG_IsOK(res1)) {
40463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
40464 }
40465 arg1 = reinterpret_cast< wxWindow * >(argp1);
40466 {
40467 PyThreadState* __tstate = wxPyBeginAllowThreads();
40468 result = (long)wxWindow_GetHandle(arg1);
40469 wxPyEndAllowThreads(__tstate);
40470 if (PyErr_Occurred()) SWIG_fail;
40471 }
40472 resultobj = SWIG_From_long(static_cast< long >(result));
40473 return resultobj;
40474 fail:
40475 return NULL;
40476 }
40477
40478
40479 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40480 PyObject *resultobj = 0;
40481 wxWindow *arg1 = (wxWindow *) 0 ;
40482 long arg2 ;
40483 void *argp1 = 0 ;
40484 int res1 = 0 ;
40485 long val2 ;
40486 int ecode2 = 0 ;
40487 PyObject * obj0 = 0 ;
40488 PyObject * obj1 = 0 ;
40489 char * kwnames[] = {
40490 (char *) "self",(char *) "handle", NULL
40491 };
40492
40493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
40494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40495 if (!SWIG_IsOK(res1)) {
40496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
40497 }
40498 arg1 = reinterpret_cast< wxWindow * >(argp1);
40499 ecode2 = SWIG_AsVal_long(obj1, &val2);
40500 if (!SWIG_IsOK(ecode2)) {
40501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
40502 }
40503 arg2 = static_cast< long >(val2);
40504 {
40505 PyThreadState* __tstate = wxPyBeginAllowThreads();
40506 wxWindow_AssociateHandle(arg1,arg2);
40507 wxPyEndAllowThreads(__tstate);
40508 if (PyErr_Occurred()) SWIG_fail;
40509 }
40510 resultobj = SWIG_Py_Void();
40511 return resultobj;
40512 fail:
40513 return NULL;
40514 }
40515
40516
40517 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40518 PyObject *resultobj = 0;
40519 wxWindow *arg1 = (wxWindow *) 0 ;
40520 void *argp1 = 0 ;
40521 int res1 = 0 ;
40522 PyObject *swig_obj[1] ;
40523
40524 if (!args) SWIG_fail;
40525 swig_obj[0] = args;
40526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40527 if (!SWIG_IsOK(res1)) {
40528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
40529 }
40530 arg1 = reinterpret_cast< wxWindow * >(argp1);
40531 {
40532 PyThreadState* __tstate = wxPyBeginAllowThreads();
40533 (arg1)->DissociateHandle();
40534 wxPyEndAllowThreads(__tstate);
40535 if (PyErr_Occurred()) SWIG_fail;
40536 }
40537 resultobj = SWIG_Py_Void();
40538 return resultobj;
40539 fail:
40540 return NULL;
40541 }
40542
40543
40544 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40545 PyObject *resultobj = 0;
40546 wxWindow *arg1 = (wxWindow *) 0 ;
40547 int arg2 ;
40548 bool result;
40549 void *argp1 = 0 ;
40550 int res1 = 0 ;
40551 int val2 ;
40552 int ecode2 = 0 ;
40553 PyObject * obj0 = 0 ;
40554 PyObject * obj1 = 0 ;
40555 char * kwnames[] = {
40556 (char *) "self",(char *) "orient", NULL
40557 };
40558
40559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
40560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40561 if (!SWIG_IsOK(res1)) {
40562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
40563 }
40564 arg1 = reinterpret_cast< wxWindow * >(argp1);
40565 ecode2 = SWIG_AsVal_int(obj1, &val2);
40566 if (!SWIG_IsOK(ecode2)) {
40567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
40568 }
40569 arg2 = static_cast< int >(val2);
40570 {
40571 PyThreadState* __tstate = wxPyBeginAllowThreads();
40572 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
40573 wxPyEndAllowThreads(__tstate);
40574 if (PyErr_Occurred()) SWIG_fail;
40575 }
40576 {
40577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40578 }
40579 return resultobj;
40580 fail:
40581 return NULL;
40582 }
40583
40584
40585 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40586 PyObject *resultobj = 0;
40587 wxWindow *arg1 = (wxWindow *) 0 ;
40588 int arg2 ;
40589 int arg3 ;
40590 int arg4 ;
40591 int arg5 ;
40592 bool arg6 = (bool) true ;
40593 void *argp1 = 0 ;
40594 int res1 = 0 ;
40595 int val2 ;
40596 int ecode2 = 0 ;
40597 int val3 ;
40598 int ecode3 = 0 ;
40599 int val4 ;
40600 int ecode4 = 0 ;
40601 int val5 ;
40602 int ecode5 = 0 ;
40603 bool val6 ;
40604 int ecode6 = 0 ;
40605 PyObject * obj0 = 0 ;
40606 PyObject * obj1 = 0 ;
40607 PyObject * obj2 = 0 ;
40608 PyObject * obj3 = 0 ;
40609 PyObject * obj4 = 0 ;
40610 PyObject * obj5 = 0 ;
40611 char * kwnames[] = {
40612 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
40613 };
40614
40615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40617 if (!SWIG_IsOK(res1)) {
40618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
40619 }
40620 arg1 = reinterpret_cast< wxWindow * >(argp1);
40621 ecode2 = SWIG_AsVal_int(obj1, &val2);
40622 if (!SWIG_IsOK(ecode2)) {
40623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
40624 }
40625 arg2 = static_cast< int >(val2);
40626 ecode3 = SWIG_AsVal_int(obj2, &val3);
40627 if (!SWIG_IsOK(ecode3)) {
40628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
40629 }
40630 arg3 = static_cast< int >(val3);
40631 ecode4 = SWIG_AsVal_int(obj3, &val4);
40632 if (!SWIG_IsOK(ecode4)) {
40633 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
40634 }
40635 arg4 = static_cast< int >(val4);
40636 ecode5 = SWIG_AsVal_int(obj4, &val5);
40637 if (!SWIG_IsOK(ecode5)) {
40638 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
40639 }
40640 arg5 = static_cast< int >(val5);
40641 if (obj5) {
40642 ecode6 = SWIG_AsVal_bool(obj5, &val6);
40643 if (!SWIG_IsOK(ecode6)) {
40644 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
40645 }
40646 arg6 = static_cast< bool >(val6);
40647 }
40648 {
40649 PyThreadState* __tstate = wxPyBeginAllowThreads();
40650 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
40651 wxPyEndAllowThreads(__tstate);
40652 if (PyErr_Occurred()) SWIG_fail;
40653 }
40654 resultobj = SWIG_Py_Void();
40655 return resultobj;
40656 fail:
40657 return NULL;
40658 }
40659
40660
40661 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40662 PyObject *resultobj = 0;
40663 wxWindow *arg1 = (wxWindow *) 0 ;
40664 int arg2 ;
40665 int arg3 ;
40666 bool arg4 = (bool) true ;
40667 void *argp1 = 0 ;
40668 int res1 = 0 ;
40669 int val2 ;
40670 int ecode2 = 0 ;
40671 int val3 ;
40672 int ecode3 = 0 ;
40673 bool val4 ;
40674 int ecode4 = 0 ;
40675 PyObject * obj0 = 0 ;
40676 PyObject * obj1 = 0 ;
40677 PyObject * obj2 = 0 ;
40678 PyObject * obj3 = 0 ;
40679 char * kwnames[] = {
40680 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
40681 };
40682
40683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40685 if (!SWIG_IsOK(res1)) {
40686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
40687 }
40688 arg1 = reinterpret_cast< wxWindow * >(argp1);
40689 ecode2 = SWIG_AsVal_int(obj1, &val2);
40690 if (!SWIG_IsOK(ecode2)) {
40691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
40692 }
40693 arg2 = static_cast< int >(val2);
40694 ecode3 = SWIG_AsVal_int(obj2, &val3);
40695 if (!SWIG_IsOK(ecode3)) {
40696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
40697 }
40698 arg3 = static_cast< int >(val3);
40699 if (obj3) {
40700 ecode4 = SWIG_AsVal_bool(obj3, &val4);
40701 if (!SWIG_IsOK(ecode4)) {
40702 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
40703 }
40704 arg4 = static_cast< bool >(val4);
40705 }
40706 {
40707 PyThreadState* __tstate = wxPyBeginAllowThreads();
40708 (arg1)->SetScrollPos(arg2,arg3,arg4);
40709 wxPyEndAllowThreads(__tstate);
40710 if (PyErr_Occurred()) SWIG_fail;
40711 }
40712 resultobj = SWIG_Py_Void();
40713 return resultobj;
40714 fail:
40715 return NULL;
40716 }
40717
40718
40719 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40720 PyObject *resultobj = 0;
40721 wxWindow *arg1 = (wxWindow *) 0 ;
40722 int arg2 ;
40723 int result;
40724 void *argp1 = 0 ;
40725 int res1 = 0 ;
40726 int val2 ;
40727 int ecode2 = 0 ;
40728 PyObject * obj0 = 0 ;
40729 PyObject * obj1 = 0 ;
40730 char * kwnames[] = {
40731 (char *) "self",(char *) "orientation", NULL
40732 };
40733
40734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
40735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40736 if (!SWIG_IsOK(res1)) {
40737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
40738 }
40739 arg1 = reinterpret_cast< wxWindow * >(argp1);
40740 ecode2 = SWIG_AsVal_int(obj1, &val2);
40741 if (!SWIG_IsOK(ecode2)) {
40742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
40743 }
40744 arg2 = static_cast< int >(val2);
40745 {
40746 PyThreadState* __tstate = wxPyBeginAllowThreads();
40747 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
40748 wxPyEndAllowThreads(__tstate);
40749 if (PyErr_Occurred()) SWIG_fail;
40750 }
40751 resultobj = SWIG_From_int(static_cast< int >(result));
40752 return resultobj;
40753 fail:
40754 return NULL;
40755 }
40756
40757
40758 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40759 PyObject *resultobj = 0;
40760 wxWindow *arg1 = (wxWindow *) 0 ;
40761 int arg2 ;
40762 int result;
40763 void *argp1 = 0 ;
40764 int res1 = 0 ;
40765 int val2 ;
40766 int ecode2 = 0 ;
40767 PyObject * obj0 = 0 ;
40768 PyObject * obj1 = 0 ;
40769 char * kwnames[] = {
40770 (char *) "self",(char *) "orientation", NULL
40771 };
40772
40773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
40774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40775 if (!SWIG_IsOK(res1)) {
40776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
40777 }
40778 arg1 = reinterpret_cast< wxWindow * >(argp1);
40779 ecode2 = SWIG_AsVal_int(obj1, &val2);
40780 if (!SWIG_IsOK(ecode2)) {
40781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
40782 }
40783 arg2 = static_cast< int >(val2);
40784 {
40785 PyThreadState* __tstate = wxPyBeginAllowThreads();
40786 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
40787 wxPyEndAllowThreads(__tstate);
40788 if (PyErr_Occurred()) SWIG_fail;
40789 }
40790 resultobj = SWIG_From_int(static_cast< int >(result));
40791 return resultobj;
40792 fail:
40793 return NULL;
40794 }
40795
40796
40797 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40798 PyObject *resultobj = 0;
40799 wxWindow *arg1 = (wxWindow *) 0 ;
40800 int arg2 ;
40801 int result;
40802 void *argp1 = 0 ;
40803 int res1 = 0 ;
40804 int val2 ;
40805 int ecode2 = 0 ;
40806 PyObject * obj0 = 0 ;
40807 PyObject * obj1 = 0 ;
40808 char * kwnames[] = {
40809 (char *) "self",(char *) "orientation", NULL
40810 };
40811
40812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
40813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40814 if (!SWIG_IsOK(res1)) {
40815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
40816 }
40817 arg1 = reinterpret_cast< wxWindow * >(argp1);
40818 ecode2 = SWIG_AsVal_int(obj1, &val2);
40819 if (!SWIG_IsOK(ecode2)) {
40820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
40821 }
40822 arg2 = static_cast< int >(val2);
40823 {
40824 PyThreadState* __tstate = wxPyBeginAllowThreads();
40825 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
40826 wxPyEndAllowThreads(__tstate);
40827 if (PyErr_Occurred()) SWIG_fail;
40828 }
40829 resultobj = SWIG_From_int(static_cast< int >(result));
40830 return resultobj;
40831 fail:
40832 return NULL;
40833 }
40834
40835
40836 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40837 PyObject *resultobj = 0;
40838 wxWindow *arg1 = (wxWindow *) 0 ;
40839 int arg2 ;
40840 int arg3 ;
40841 wxRect *arg4 = (wxRect *) NULL ;
40842 void *argp1 = 0 ;
40843 int res1 = 0 ;
40844 int val2 ;
40845 int ecode2 = 0 ;
40846 int val3 ;
40847 int ecode3 = 0 ;
40848 void *argp4 = 0 ;
40849 int res4 = 0 ;
40850 PyObject * obj0 = 0 ;
40851 PyObject * obj1 = 0 ;
40852 PyObject * obj2 = 0 ;
40853 PyObject * obj3 = 0 ;
40854 char * kwnames[] = {
40855 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
40856 };
40857
40858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40860 if (!SWIG_IsOK(res1)) {
40861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
40862 }
40863 arg1 = reinterpret_cast< wxWindow * >(argp1);
40864 ecode2 = SWIG_AsVal_int(obj1, &val2);
40865 if (!SWIG_IsOK(ecode2)) {
40866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40867 }
40868 arg2 = static_cast< int >(val2);
40869 ecode3 = SWIG_AsVal_int(obj2, &val3);
40870 if (!SWIG_IsOK(ecode3)) {
40871 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40872 }
40873 arg3 = static_cast< int >(val3);
40874 if (obj3) {
40875 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40876 if (!SWIG_IsOK(res4)) {
40877 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40878 }
40879 arg4 = reinterpret_cast< wxRect * >(argp4);
40880 }
40881 {
40882 PyThreadState* __tstate = wxPyBeginAllowThreads();
40883 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40884 wxPyEndAllowThreads(__tstate);
40885 if (PyErr_Occurred()) SWIG_fail;
40886 }
40887 resultobj = SWIG_Py_Void();
40888 return resultobj;
40889 fail:
40890 return NULL;
40891 }
40892
40893
40894 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40895 PyObject *resultobj = 0;
40896 wxWindow *arg1 = (wxWindow *) 0 ;
40897 int arg2 ;
40898 bool result;
40899 void *argp1 = 0 ;
40900 int res1 = 0 ;
40901 int val2 ;
40902 int ecode2 = 0 ;
40903 PyObject * obj0 = 0 ;
40904 PyObject * obj1 = 0 ;
40905 char * kwnames[] = {
40906 (char *) "self",(char *) "lines", NULL
40907 };
40908
40909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40911 if (!SWIG_IsOK(res1)) {
40912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40913 }
40914 arg1 = reinterpret_cast< wxWindow * >(argp1);
40915 ecode2 = SWIG_AsVal_int(obj1, &val2);
40916 if (!SWIG_IsOK(ecode2)) {
40917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40918 }
40919 arg2 = static_cast< int >(val2);
40920 {
40921 PyThreadState* __tstate = wxPyBeginAllowThreads();
40922 result = (bool)(arg1)->ScrollLines(arg2);
40923 wxPyEndAllowThreads(__tstate);
40924 if (PyErr_Occurred()) SWIG_fail;
40925 }
40926 {
40927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40928 }
40929 return resultobj;
40930 fail:
40931 return NULL;
40932 }
40933
40934
40935 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40936 PyObject *resultobj = 0;
40937 wxWindow *arg1 = (wxWindow *) 0 ;
40938 int arg2 ;
40939 bool result;
40940 void *argp1 = 0 ;
40941 int res1 = 0 ;
40942 int val2 ;
40943 int ecode2 = 0 ;
40944 PyObject * obj0 = 0 ;
40945 PyObject * obj1 = 0 ;
40946 char * kwnames[] = {
40947 (char *) "self",(char *) "pages", NULL
40948 };
40949
40950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40952 if (!SWIG_IsOK(res1)) {
40953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40954 }
40955 arg1 = reinterpret_cast< wxWindow * >(argp1);
40956 ecode2 = SWIG_AsVal_int(obj1, &val2);
40957 if (!SWIG_IsOK(ecode2)) {
40958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40959 }
40960 arg2 = static_cast< int >(val2);
40961 {
40962 PyThreadState* __tstate = wxPyBeginAllowThreads();
40963 result = (bool)(arg1)->ScrollPages(arg2);
40964 wxPyEndAllowThreads(__tstate);
40965 if (PyErr_Occurred()) SWIG_fail;
40966 }
40967 {
40968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40969 }
40970 return resultobj;
40971 fail:
40972 return NULL;
40973 }
40974
40975
40976 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40977 PyObject *resultobj = 0;
40978 wxWindow *arg1 = (wxWindow *) 0 ;
40979 bool result;
40980 void *argp1 = 0 ;
40981 int res1 = 0 ;
40982 PyObject *swig_obj[1] ;
40983
40984 if (!args) SWIG_fail;
40985 swig_obj[0] = args;
40986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40987 if (!SWIG_IsOK(res1)) {
40988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40989 }
40990 arg1 = reinterpret_cast< wxWindow * >(argp1);
40991 {
40992 PyThreadState* __tstate = wxPyBeginAllowThreads();
40993 result = (bool)(arg1)->LineUp();
40994 wxPyEndAllowThreads(__tstate);
40995 if (PyErr_Occurred()) SWIG_fail;
40996 }
40997 {
40998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40999 }
41000 return resultobj;
41001 fail:
41002 return NULL;
41003 }
41004
41005
41006 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41007 PyObject *resultobj = 0;
41008 wxWindow *arg1 = (wxWindow *) 0 ;
41009 bool result;
41010 void *argp1 = 0 ;
41011 int res1 = 0 ;
41012 PyObject *swig_obj[1] ;
41013
41014 if (!args) SWIG_fail;
41015 swig_obj[0] = args;
41016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41017 if (!SWIG_IsOK(res1)) {
41018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
41019 }
41020 arg1 = reinterpret_cast< wxWindow * >(argp1);
41021 {
41022 PyThreadState* __tstate = wxPyBeginAllowThreads();
41023 result = (bool)(arg1)->LineDown();
41024 wxPyEndAllowThreads(__tstate);
41025 if (PyErr_Occurred()) SWIG_fail;
41026 }
41027 {
41028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41029 }
41030 return resultobj;
41031 fail:
41032 return NULL;
41033 }
41034
41035
41036 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41037 PyObject *resultobj = 0;
41038 wxWindow *arg1 = (wxWindow *) 0 ;
41039 bool result;
41040 void *argp1 = 0 ;
41041 int res1 = 0 ;
41042 PyObject *swig_obj[1] ;
41043
41044 if (!args) SWIG_fail;
41045 swig_obj[0] = args;
41046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41047 if (!SWIG_IsOK(res1)) {
41048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
41049 }
41050 arg1 = reinterpret_cast< wxWindow * >(argp1);
41051 {
41052 PyThreadState* __tstate = wxPyBeginAllowThreads();
41053 result = (bool)(arg1)->PageUp();
41054 wxPyEndAllowThreads(__tstate);
41055 if (PyErr_Occurred()) SWIG_fail;
41056 }
41057 {
41058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41059 }
41060 return resultobj;
41061 fail:
41062 return NULL;
41063 }
41064
41065
41066 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41067 PyObject *resultobj = 0;
41068 wxWindow *arg1 = (wxWindow *) 0 ;
41069 bool result;
41070 void *argp1 = 0 ;
41071 int res1 = 0 ;
41072 PyObject *swig_obj[1] ;
41073
41074 if (!args) SWIG_fail;
41075 swig_obj[0] = args;
41076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41077 if (!SWIG_IsOK(res1)) {
41078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
41079 }
41080 arg1 = reinterpret_cast< wxWindow * >(argp1);
41081 {
41082 PyThreadState* __tstate = wxPyBeginAllowThreads();
41083 result = (bool)(arg1)->PageDown();
41084 wxPyEndAllowThreads(__tstate);
41085 if (PyErr_Occurred()) SWIG_fail;
41086 }
41087 {
41088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41089 }
41090 return resultobj;
41091 fail:
41092 return NULL;
41093 }
41094
41095
41096 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41097 PyObject *resultobj = 0;
41098 wxWindow *arg1 = (wxWindow *) 0 ;
41099 wxString *arg2 = 0 ;
41100 void *argp1 = 0 ;
41101 int res1 = 0 ;
41102 bool temp2 = false ;
41103 PyObject * obj0 = 0 ;
41104 PyObject * obj1 = 0 ;
41105 char * kwnames[] = {
41106 (char *) "self",(char *) "text", NULL
41107 };
41108
41109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
41110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41111 if (!SWIG_IsOK(res1)) {
41112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
41113 }
41114 arg1 = reinterpret_cast< wxWindow * >(argp1);
41115 {
41116 arg2 = wxString_in_helper(obj1);
41117 if (arg2 == NULL) SWIG_fail;
41118 temp2 = true;
41119 }
41120 {
41121 PyThreadState* __tstate = wxPyBeginAllowThreads();
41122 (arg1)->SetHelpText((wxString const &)*arg2);
41123 wxPyEndAllowThreads(__tstate);
41124 if (PyErr_Occurred()) SWIG_fail;
41125 }
41126 resultobj = SWIG_Py_Void();
41127 {
41128 if (temp2)
41129 delete arg2;
41130 }
41131 return resultobj;
41132 fail:
41133 {
41134 if (temp2)
41135 delete arg2;
41136 }
41137 return NULL;
41138 }
41139
41140
41141 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41142 PyObject *resultobj = 0;
41143 wxWindow *arg1 = (wxWindow *) 0 ;
41144 wxString *arg2 = 0 ;
41145 void *argp1 = 0 ;
41146 int res1 = 0 ;
41147 bool temp2 = false ;
41148 PyObject * obj0 = 0 ;
41149 PyObject * obj1 = 0 ;
41150 char * kwnames[] = {
41151 (char *) "self",(char *) "text", NULL
41152 };
41153
41154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
41155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41156 if (!SWIG_IsOK(res1)) {
41157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
41158 }
41159 arg1 = reinterpret_cast< wxWindow * >(argp1);
41160 {
41161 arg2 = wxString_in_helper(obj1);
41162 if (arg2 == NULL) SWIG_fail;
41163 temp2 = true;
41164 }
41165 {
41166 PyThreadState* __tstate = wxPyBeginAllowThreads();
41167 (arg1)->SetHelpTextForId((wxString const &)*arg2);
41168 wxPyEndAllowThreads(__tstate);
41169 if (PyErr_Occurred()) SWIG_fail;
41170 }
41171 resultobj = SWIG_Py_Void();
41172 {
41173 if (temp2)
41174 delete arg2;
41175 }
41176 return resultobj;
41177 fail:
41178 {
41179 if (temp2)
41180 delete arg2;
41181 }
41182 return NULL;
41183 }
41184
41185
41186 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41187 PyObject *resultobj = 0;
41188 wxWindow *arg1 = (wxWindow *) 0 ;
41189 wxPoint *arg2 = 0 ;
41190 wxHelpEvent::Origin arg3 ;
41191 wxString result;
41192 void *argp1 = 0 ;
41193 int res1 = 0 ;
41194 wxPoint temp2 ;
41195 void *argp3 ;
41196 int res3 = 0 ;
41197 PyObject * obj0 = 0 ;
41198 PyObject * obj1 = 0 ;
41199 PyObject * obj2 = 0 ;
41200 char * kwnames[] = {
41201 (char *) "self",(char *) "pt",(char *) "origin", NULL
41202 };
41203
41204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41206 if (!SWIG_IsOK(res1)) {
41207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
41208 }
41209 arg1 = reinterpret_cast< wxWindow * >(argp1);
41210 {
41211 arg2 = &temp2;
41212 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
41213 }
41214 {
41215 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
41216 if (!SWIG_IsOK(res3)) {
41217 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
41218 }
41219 if (!argp3) {
41220 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
41221 } else {
41222 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
41223 arg3 = *temp;
41224 if (SWIG_IsNewObj(res3)) delete temp;
41225 }
41226 }
41227 {
41228 PyThreadState* __tstate = wxPyBeginAllowThreads();
41229 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
41230 wxPyEndAllowThreads(__tstate);
41231 if (PyErr_Occurred()) SWIG_fail;
41232 }
41233 {
41234 #if wxUSE_UNICODE
41235 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41236 #else
41237 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41238 #endif
41239 }
41240 return resultobj;
41241 fail:
41242 return NULL;
41243 }
41244
41245
41246 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41247 PyObject *resultobj = 0;
41248 wxWindow *arg1 = (wxWindow *) 0 ;
41249 wxString result;
41250 void *argp1 = 0 ;
41251 int res1 = 0 ;
41252 PyObject *swig_obj[1] ;
41253
41254 if (!args) SWIG_fail;
41255 swig_obj[0] = args;
41256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41257 if (!SWIG_IsOK(res1)) {
41258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
41259 }
41260 arg1 = reinterpret_cast< wxWindow * >(argp1);
41261 {
41262 PyThreadState* __tstate = wxPyBeginAllowThreads();
41263 result = ((wxWindow const *)arg1)->GetHelpText();
41264 wxPyEndAllowThreads(__tstate);
41265 if (PyErr_Occurred()) SWIG_fail;
41266 }
41267 {
41268 #if wxUSE_UNICODE
41269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41270 #else
41271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41272 #endif
41273 }
41274 return resultobj;
41275 fail:
41276 return NULL;
41277 }
41278
41279
41280 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41281 PyObject *resultobj = 0;
41282 wxWindow *arg1 = (wxWindow *) 0 ;
41283 wxString *arg2 = 0 ;
41284 void *argp1 = 0 ;
41285 int res1 = 0 ;
41286 bool temp2 = false ;
41287 PyObject * obj0 = 0 ;
41288 PyObject * obj1 = 0 ;
41289 char * kwnames[] = {
41290 (char *) "self",(char *) "tip", NULL
41291 };
41292
41293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
41294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41295 if (!SWIG_IsOK(res1)) {
41296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
41297 }
41298 arg1 = reinterpret_cast< wxWindow * >(argp1);
41299 {
41300 arg2 = wxString_in_helper(obj1);
41301 if (arg2 == NULL) SWIG_fail;
41302 temp2 = true;
41303 }
41304 {
41305 PyThreadState* __tstate = wxPyBeginAllowThreads();
41306 (arg1)->SetToolTip((wxString const &)*arg2);
41307 wxPyEndAllowThreads(__tstate);
41308 if (PyErr_Occurred()) SWIG_fail;
41309 }
41310 resultobj = SWIG_Py_Void();
41311 {
41312 if (temp2)
41313 delete arg2;
41314 }
41315 return resultobj;
41316 fail:
41317 {
41318 if (temp2)
41319 delete arg2;
41320 }
41321 return NULL;
41322 }
41323
41324
41325 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41326 PyObject *resultobj = 0;
41327 wxWindow *arg1 = (wxWindow *) 0 ;
41328 wxToolTip *arg2 = (wxToolTip *) 0 ;
41329 void *argp1 = 0 ;
41330 int res1 = 0 ;
41331 int res2 = 0 ;
41332 PyObject * obj0 = 0 ;
41333 PyObject * obj1 = 0 ;
41334 char * kwnames[] = {
41335 (char *) "self",(char *) "tip", NULL
41336 };
41337
41338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
41339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41340 if (!SWIG_IsOK(res1)) {
41341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
41342 }
41343 arg1 = reinterpret_cast< wxWindow * >(argp1);
41344 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
41345 if (!SWIG_IsOK(res2)) {
41346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
41347 }
41348 {
41349 PyThreadState* __tstate = wxPyBeginAllowThreads();
41350 (arg1)->SetToolTip(arg2);
41351 wxPyEndAllowThreads(__tstate);
41352 if (PyErr_Occurred()) SWIG_fail;
41353 }
41354 resultobj = SWIG_Py_Void();
41355 return resultobj;
41356 fail:
41357 return NULL;
41358 }
41359
41360
41361 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41362 PyObject *resultobj = 0;
41363 wxWindow *arg1 = (wxWindow *) 0 ;
41364 wxToolTip *result = 0 ;
41365 void *argp1 = 0 ;
41366 int res1 = 0 ;
41367 PyObject *swig_obj[1] ;
41368
41369 if (!args) SWIG_fail;
41370 swig_obj[0] = args;
41371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41372 if (!SWIG_IsOK(res1)) {
41373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
41374 }
41375 arg1 = reinterpret_cast< wxWindow * >(argp1);
41376 {
41377 PyThreadState* __tstate = wxPyBeginAllowThreads();
41378 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
41379 wxPyEndAllowThreads(__tstate);
41380 if (PyErr_Occurred()) SWIG_fail;
41381 }
41382 {
41383 resultobj = wxPyMake_wxObject(result, (bool)0);
41384 }
41385 return resultobj;
41386 fail:
41387 return NULL;
41388 }
41389
41390
41391 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41392 PyObject *resultobj = 0;
41393 wxWindow *arg1 = (wxWindow *) 0 ;
41394 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
41395 void *argp1 = 0 ;
41396 int res1 = 0 ;
41397 int res2 = 0 ;
41398 PyObject * obj0 = 0 ;
41399 PyObject * obj1 = 0 ;
41400 char * kwnames[] = {
41401 (char *) "self",(char *) "dropTarget", NULL
41402 };
41403
41404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
41405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41406 if (!SWIG_IsOK(res1)) {
41407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
41408 }
41409 arg1 = reinterpret_cast< wxWindow * >(argp1);
41410 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
41411 if (!SWIG_IsOK(res2)) {
41412 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
41413 }
41414 {
41415 PyThreadState* __tstate = wxPyBeginAllowThreads();
41416 (arg1)->SetDropTarget(arg2);
41417 wxPyEndAllowThreads(__tstate);
41418 if (PyErr_Occurred()) SWIG_fail;
41419 }
41420 resultobj = SWIG_Py_Void();
41421 return resultobj;
41422 fail:
41423 return NULL;
41424 }
41425
41426
41427 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41428 PyObject *resultobj = 0;
41429 wxWindow *arg1 = (wxWindow *) 0 ;
41430 wxPyDropTarget *result = 0 ;
41431 void *argp1 = 0 ;
41432 int res1 = 0 ;
41433 PyObject *swig_obj[1] ;
41434
41435 if (!args) SWIG_fail;
41436 swig_obj[0] = args;
41437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41438 if (!SWIG_IsOK(res1)) {
41439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
41440 }
41441 arg1 = reinterpret_cast< wxWindow * >(argp1);
41442 {
41443 PyThreadState* __tstate = wxPyBeginAllowThreads();
41444 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
41445 wxPyEndAllowThreads(__tstate);
41446 if (PyErr_Occurred()) SWIG_fail;
41447 }
41448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
41449 return resultobj;
41450 fail:
41451 return NULL;
41452 }
41453
41454
41455 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41456 PyObject *resultobj = 0;
41457 wxWindow *arg1 = (wxWindow *) 0 ;
41458 bool arg2 ;
41459 void *argp1 = 0 ;
41460 int res1 = 0 ;
41461 bool val2 ;
41462 int ecode2 = 0 ;
41463 PyObject * obj0 = 0 ;
41464 PyObject * obj1 = 0 ;
41465 char * kwnames[] = {
41466 (char *) "self",(char *) "accept", NULL
41467 };
41468
41469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
41470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41471 if (!SWIG_IsOK(res1)) {
41472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
41473 }
41474 arg1 = reinterpret_cast< wxWindow * >(argp1);
41475 ecode2 = SWIG_AsVal_bool(obj1, &val2);
41476 if (!SWIG_IsOK(ecode2)) {
41477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
41478 }
41479 arg2 = static_cast< bool >(val2);
41480 {
41481 PyThreadState* __tstate = wxPyBeginAllowThreads();
41482 wxWindow_DragAcceptFiles(arg1,arg2);
41483 wxPyEndAllowThreads(__tstate);
41484 if (PyErr_Occurred()) SWIG_fail;
41485 }
41486 resultobj = SWIG_Py_Void();
41487 return resultobj;
41488 fail:
41489 return NULL;
41490 }
41491
41492
41493 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41494 PyObject *resultobj = 0;
41495 wxWindow *arg1 = (wxWindow *) 0 ;
41496 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
41497 void *argp1 = 0 ;
41498 int res1 = 0 ;
41499 int res2 = 0 ;
41500 PyObject * obj0 = 0 ;
41501 PyObject * obj1 = 0 ;
41502 char * kwnames[] = {
41503 (char *) "self",(char *) "constraints", NULL
41504 };
41505
41506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
41507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41508 if (!SWIG_IsOK(res1)) {
41509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
41510 }
41511 arg1 = reinterpret_cast< wxWindow * >(argp1);
41512 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
41513 if (!SWIG_IsOK(res2)) {
41514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
41515 }
41516 {
41517 PyThreadState* __tstate = wxPyBeginAllowThreads();
41518 (arg1)->SetConstraints(arg2);
41519 wxPyEndAllowThreads(__tstate);
41520 if (PyErr_Occurred()) SWIG_fail;
41521 }
41522 resultobj = SWIG_Py_Void();
41523 return resultobj;
41524 fail:
41525 return NULL;
41526 }
41527
41528
41529 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41530 PyObject *resultobj = 0;
41531 wxWindow *arg1 = (wxWindow *) 0 ;
41532 wxLayoutConstraints *result = 0 ;
41533 void *argp1 = 0 ;
41534 int res1 = 0 ;
41535 PyObject *swig_obj[1] ;
41536
41537 if (!args) SWIG_fail;
41538 swig_obj[0] = args;
41539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41540 if (!SWIG_IsOK(res1)) {
41541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
41542 }
41543 arg1 = reinterpret_cast< wxWindow * >(argp1);
41544 {
41545 PyThreadState* __tstate = wxPyBeginAllowThreads();
41546 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
41547 wxPyEndAllowThreads(__tstate);
41548 if (PyErr_Occurred()) SWIG_fail;
41549 }
41550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
41551 return resultobj;
41552 fail:
41553 return NULL;
41554 }
41555
41556
41557 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41558 PyObject *resultobj = 0;
41559 wxWindow *arg1 = (wxWindow *) 0 ;
41560 bool arg2 ;
41561 void *argp1 = 0 ;
41562 int res1 = 0 ;
41563 bool val2 ;
41564 int ecode2 = 0 ;
41565 PyObject * obj0 = 0 ;
41566 PyObject * obj1 = 0 ;
41567 char * kwnames[] = {
41568 (char *) "self",(char *) "autoLayout", NULL
41569 };
41570
41571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
41572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41573 if (!SWIG_IsOK(res1)) {
41574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
41575 }
41576 arg1 = reinterpret_cast< wxWindow * >(argp1);
41577 ecode2 = SWIG_AsVal_bool(obj1, &val2);
41578 if (!SWIG_IsOK(ecode2)) {
41579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
41580 }
41581 arg2 = static_cast< bool >(val2);
41582 {
41583 PyThreadState* __tstate = wxPyBeginAllowThreads();
41584 (arg1)->SetAutoLayout(arg2);
41585 wxPyEndAllowThreads(__tstate);
41586 if (PyErr_Occurred()) SWIG_fail;
41587 }
41588 resultobj = SWIG_Py_Void();
41589 return resultobj;
41590 fail:
41591 return NULL;
41592 }
41593
41594
41595 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41596 PyObject *resultobj = 0;
41597 wxWindow *arg1 = (wxWindow *) 0 ;
41598 bool result;
41599 void *argp1 = 0 ;
41600 int res1 = 0 ;
41601 PyObject *swig_obj[1] ;
41602
41603 if (!args) SWIG_fail;
41604 swig_obj[0] = args;
41605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41606 if (!SWIG_IsOK(res1)) {
41607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
41608 }
41609 arg1 = reinterpret_cast< wxWindow * >(argp1);
41610 {
41611 PyThreadState* __tstate = wxPyBeginAllowThreads();
41612 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
41613 wxPyEndAllowThreads(__tstate);
41614 if (PyErr_Occurred()) SWIG_fail;
41615 }
41616 {
41617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41618 }
41619 return resultobj;
41620 fail:
41621 return NULL;
41622 }
41623
41624
41625 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41626 PyObject *resultobj = 0;
41627 wxWindow *arg1 = (wxWindow *) 0 ;
41628 bool result;
41629 void *argp1 = 0 ;
41630 int res1 = 0 ;
41631 PyObject *swig_obj[1] ;
41632
41633 if (!args) SWIG_fail;
41634 swig_obj[0] = args;
41635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41636 if (!SWIG_IsOK(res1)) {
41637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
41638 }
41639 arg1 = reinterpret_cast< wxWindow * >(argp1);
41640 {
41641 PyThreadState* __tstate = wxPyBeginAllowThreads();
41642 result = (bool)(arg1)->Layout();
41643 wxPyEndAllowThreads(__tstate);
41644 if (PyErr_Occurred()) SWIG_fail;
41645 }
41646 {
41647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41648 }
41649 return resultobj;
41650 fail:
41651 return NULL;
41652 }
41653
41654
41655 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41656 PyObject *resultobj = 0;
41657 wxWindow *arg1 = (wxWindow *) 0 ;
41658 wxSizer *arg2 = (wxSizer *) 0 ;
41659 bool arg3 = (bool) true ;
41660 void *argp1 = 0 ;
41661 int res1 = 0 ;
41662 int res2 = 0 ;
41663 bool val3 ;
41664 int ecode3 = 0 ;
41665 PyObject * obj0 = 0 ;
41666 PyObject * obj1 = 0 ;
41667 PyObject * obj2 = 0 ;
41668 char * kwnames[] = {
41669 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41670 };
41671
41672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41674 if (!SWIG_IsOK(res1)) {
41675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41676 }
41677 arg1 = reinterpret_cast< wxWindow * >(argp1);
41678 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41679 if (!SWIG_IsOK(res2)) {
41680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41681 }
41682 if (obj2) {
41683 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41684 if (!SWIG_IsOK(ecode3)) {
41685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
41686 }
41687 arg3 = static_cast< bool >(val3);
41688 }
41689 {
41690 PyThreadState* __tstate = wxPyBeginAllowThreads();
41691 (arg1)->SetSizer(arg2,arg3);
41692 wxPyEndAllowThreads(__tstate);
41693 if (PyErr_Occurred()) SWIG_fail;
41694 }
41695 resultobj = SWIG_Py_Void();
41696 return resultobj;
41697 fail:
41698 return NULL;
41699 }
41700
41701
41702 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41703 PyObject *resultobj = 0;
41704 wxWindow *arg1 = (wxWindow *) 0 ;
41705 wxSizer *arg2 = (wxSizer *) 0 ;
41706 bool arg3 = (bool) true ;
41707 void *argp1 = 0 ;
41708 int res1 = 0 ;
41709 int res2 = 0 ;
41710 bool val3 ;
41711 int ecode3 = 0 ;
41712 PyObject * obj0 = 0 ;
41713 PyObject * obj1 = 0 ;
41714 PyObject * obj2 = 0 ;
41715 char * kwnames[] = {
41716 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41717 };
41718
41719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41721 if (!SWIG_IsOK(res1)) {
41722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
41723 }
41724 arg1 = reinterpret_cast< wxWindow * >(argp1);
41725 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41726 if (!SWIG_IsOK(res2)) {
41727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
41728 }
41729 if (obj2) {
41730 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41731 if (!SWIG_IsOK(ecode3)) {
41732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
41733 }
41734 arg3 = static_cast< bool >(val3);
41735 }
41736 {
41737 PyThreadState* __tstate = wxPyBeginAllowThreads();
41738 (arg1)->SetSizerAndFit(arg2,arg3);
41739 wxPyEndAllowThreads(__tstate);
41740 if (PyErr_Occurred()) SWIG_fail;
41741 }
41742 resultobj = SWIG_Py_Void();
41743 return resultobj;
41744 fail:
41745 return NULL;
41746 }
41747
41748
41749 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41750 PyObject *resultobj = 0;
41751 wxWindow *arg1 = (wxWindow *) 0 ;
41752 wxSizer *result = 0 ;
41753 void *argp1 = 0 ;
41754 int res1 = 0 ;
41755 PyObject *swig_obj[1] ;
41756
41757 if (!args) SWIG_fail;
41758 swig_obj[0] = args;
41759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41760 if (!SWIG_IsOK(res1)) {
41761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41762 }
41763 arg1 = reinterpret_cast< wxWindow * >(argp1);
41764 {
41765 PyThreadState* __tstate = wxPyBeginAllowThreads();
41766 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
41767 wxPyEndAllowThreads(__tstate);
41768 if (PyErr_Occurred()) SWIG_fail;
41769 }
41770 {
41771 resultobj = wxPyMake_wxObject(result, (bool)0);
41772 }
41773 return resultobj;
41774 fail:
41775 return NULL;
41776 }
41777
41778
41779 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41780 PyObject *resultobj = 0;
41781 wxWindow *arg1 = (wxWindow *) 0 ;
41782 wxSizer *arg2 = (wxSizer *) 0 ;
41783 void *argp1 = 0 ;
41784 int res1 = 0 ;
41785 void *argp2 = 0 ;
41786 int res2 = 0 ;
41787 PyObject * obj0 = 0 ;
41788 PyObject * obj1 = 0 ;
41789 char * kwnames[] = {
41790 (char *) "self",(char *) "sizer", NULL
41791 };
41792
41793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
41794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41795 if (!SWIG_IsOK(res1)) {
41796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41797 }
41798 arg1 = reinterpret_cast< wxWindow * >(argp1);
41799 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
41800 if (!SWIG_IsOK(res2)) {
41801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41802 }
41803 arg2 = reinterpret_cast< wxSizer * >(argp2);
41804 {
41805 PyThreadState* __tstate = wxPyBeginAllowThreads();
41806 (arg1)->SetContainingSizer(arg2);
41807 wxPyEndAllowThreads(__tstate);
41808 if (PyErr_Occurred()) SWIG_fail;
41809 }
41810 resultobj = SWIG_Py_Void();
41811 return resultobj;
41812 fail:
41813 return NULL;
41814 }
41815
41816
41817 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41818 PyObject *resultobj = 0;
41819 wxWindow *arg1 = (wxWindow *) 0 ;
41820 wxSizer *result = 0 ;
41821 void *argp1 = 0 ;
41822 int res1 = 0 ;
41823 PyObject *swig_obj[1] ;
41824
41825 if (!args) SWIG_fail;
41826 swig_obj[0] = args;
41827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41828 if (!SWIG_IsOK(res1)) {
41829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41830 }
41831 arg1 = reinterpret_cast< wxWindow * >(argp1);
41832 {
41833 PyThreadState* __tstate = wxPyBeginAllowThreads();
41834 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
41835 wxPyEndAllowThreads(__tstate);
41836 if (PyErr_Occurred()) SWIG_fail;
41837 }
41838 {
41839 resultobj = wxPyMake_wxObject(result, (bool)0);
41840 }
41841 return resultobj;
41842 fail:
41843 return NULL;
41844 }
41845
41846
41847 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41848 PyObject *resultobj = 0;
41849 wxWindow *arg1 = (wxWindow *) 0 ;
41850 void *argp1 = 0 ;
41851 int res1 = 0 ;
41852 PyObject *swig_obj[1] ;
41853
41854 if (!args) SWIG_fail;
41855 swig_obj[0] = args;
41856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41857 if (!SWIG_IsOK(res1)) {
41858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
41859 }
41860 arg1 = reinterpret_cast< wxWindow * >(argp1);
41861 {
41862 PyThreadState* __tstate = wxPyBeginAllowThreads();
41863 (arg1)->InheritAttributes();
41864 wxPyEndAllowThreads(__tstate);
41865 if (PyErr_Occurred()) SWIG_fail;
41866 }
41867 resultobj = SWIG_Py_Void();
41868 return resultobj;
41869 fail:
41870 return NULL;
41871 }
41872
41873
41874 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41875 PyObject *resultobj = 0;
41876 wxWindow *arg1 = (wxWindow *) 0 ;
41877 bool result;
41878 void *argp1 = 0 ;
41879 int res1 = 0 ;
41880 PyObject *swig_obj[1] ;
41881
41882 if (!args) SWIG_fail;
41883 swig_obj[0] = args;
41884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41885 if (!SWIG_IsOK(res1)) {
41886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41887 }
41888 arg1 = reinterpret_cast< wxWindow * >(argp1);
41889 {
41890 PyThreadState* __tstate = wxPyBeginAllowThreads();
41891 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41892 wxPyEndAllowThreads(__tstate);
41893 if (PyErr_Occurred()) SWIG_fail;
41894 }
41895 {
41896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41897 }
41898 return resultobj;
41899 fail:
41900 return NULL;
41901 }
41902
41903
41904 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41905 PyObject *resultobj = 0;
41906 wxWindow *arg1 = (wxWindow *) 0 ;
41907 bool result;
41908 void *argp1 = 0 ;
41909 int res1 = 0 ;
41910 PyObject *swig_obj[1] ;
41911
41912 if (!args) SWIG_fail;
41913 swig_obj[0] = args;
41914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41915 if (!SWIG_IsOK(res1)) {
41916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41917 }
41918 arg1 = reinterpret_cast< wxWindow * >(argp1);
41919 {
41920 PyThreadState* __tstate = wxPyBeginAllowThreads();
41921 result = (bool)(arg1)->CanSetTransparent();
41922 wxPyEndAllowThreads(__tstate);
41923 if (PyErr_Occurred()) SWIG_fail;
41924 }
41925 {
41926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41927 }
41928 return resultobj;
41929 fail:
41930 return NULL;
41931 }
41932
41933
41934 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41935 PyObject *resultobj = 0;
41936 wxWindow *arg1 = (wxWindow *) 0 ;
41937 byte arg2 ;
41938 bool result;
41939 void *argp1 = 0 ;
41940 int res1 = 0 ;
41941 unsigned char val2 ;
41942 int ecode2 = 0 ;
41943 PyObject * obj0 = 0 ;
41944 PyObject * obj1 = 0 ;
41945 char * kwnames[] = {
41946 (char *) "self",(char *) "alpha", NULL
41947 };
41948
41949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41951 if (!SWIG_IsOK(res1)) {
41952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41953 }
41954 arg1 = reinterpret_cast< wxWindow * >(argp1);
41955 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41956 if (!SWIG_IsOK(ecode2)) {
41957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41958 }
41959 arg2 = static_cast< byte >(val2);
41960 {
41961 PyThreadState* __tstate = wxPyBeginAllowThreads();
41962 result = (bool)(arg1)->SetTransparent(arg2);
41963 wxPyEndAllowThreads(__tstate);
41964 if (PyErr_Occurred()) SWIG_fail;
41965 }
41966 {
41967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41968 }
41969 return resultobj;
41970 fail:
41971 return NULL;
41972 }
41973
41974
41975 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41976 PyObject *obj;
41977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41978 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41979 return SWIG_Py_Void();
41980 }
41981
41982 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41983 return SWIG_Python_InitShadowInstance(args);
41984 }
41985
41986 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41987 PyObject *resultobj = 0;
41988 long arg1 ;
41989 wxWindow *arg2 = (wxWindow *) NULL ;
41990 wxWindow *result = 0 ;
41991 long val1 ;
41992 int ecode1 = 0 ;
41993 void *argp2 = 0 ;
41994 int res2 = 0 ;
41995 PyObject * obj0 = 0 ;
41996 PyObject * obj1 = 0 ;
41997 char * kwnames[] = {
41998 (char *) "id",(char *) "parent", NULL
41999 };
42000
42001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
42002 ecode1 = SWIG_AsVal_long(obj0, &val1);
42003 if (!SWIG_IsOK(ecode1)) {
42004 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
42005 }
42006 arg1 = static_cast< long >(val1);
42007 if (obj1) {
42008 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42009 if (!SWIG_IsOK(res2)) {
42010 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
42011 }
42012 arg2 = reinterpret_cast< wxWindow * >(argp2);
42013 }
42014 {
42015 if (!wxPyCheckForApp()) SWIG_fail;
42016 PyThreadState* __tstate = wxPyBeginAllowThreads();
42017 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
42018 wxPyEndAllowThreads(__tstate);
42019 if (PyErr_Occurred()) SWIG_fail;
42020 }
42021 {
42022 resultobj = wxPyMake_wxObject(result, 0);
42023 }
42024 return resultobj;
42025 fail:
42026 return NULL;
42027 }
42028
42029
42030 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42031 PyObject *resultobj = 0;
42032 wxString *arg1 = 0 ;
42033 wxWindow *arg2 = (wxWindow *) NULL ;
42034 wxWindow *result = 0 ;
42035 bool temp1 = false ;
42036 void *argp2 = 0 ;
42037 int res2 = 0 ;
42038 PyObject * obj0 = 0 ;
42039 PyObject * obj1 = 0 ;
42040 char * kwnames[] = {
42041 (char *) "name",(char *) "parent", NULL
42042 };
42043
42044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
42045 {
42046 arg1 = wxString_in_helper(obj0);
42047 if (arg1 == NULL) SWIG_fail;
42048 temp1 = true;
42049 }
42050 if (obj1) {
42051 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42052 if (!SWIG_IsOK(res2)) {
42053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
42054 }
42055 arg2 = reinterpret_cast< wxWindow * >(argp2);
42056 }
42057 {
42058 if (!wxPyCheckForApp()) SWIG_fail;
42059 PyThreadState* __tstate = wxPyBeginAllowThreads();
42060 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
42061 wxPyEndAllowThreads(__tstate);
42062 if (PyErr_Occurred()) SWIG_fail;
42063 }
42064 {
42065 resultobj = wxPyMake_wxObject(result, 0);
42066 }
42067 {
42068 if (temp1)
42069 delete arg1;
42070 }
42071 return resultobj;
42072 fail:
42073 {
42074 if (temp1)
42075 delete arg1;
42076 }
42077 return NULL;
42078 }
42079
42080
42081 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42082 PyObject *resultobj = 0;
42083 wxString *arg1 = 0 ;
42084 wxWindow *arg2 = (wxWindow *) NULL ;
42085 wxWindow *result = 0 ;
42086 bool temp1 = false ;
42087 void *argp2 = 0 ;
42088 int res2 = 0 ;
42089 PyObject * obj0 = 0 ;
42090 PyObject * obj1 = 0 ;
42091 char * kwnames[] = {
42092 (char *) "label",(char *) "parent", NULL
42093 };
42094
42095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42096 {
42097 arg1 = wxString_in_helper(obj0);
42098 if (arg1 == NULL) SWIG_fail;
42099 temp1 = true;
42100 }
42101 if (obj1) {
42102 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42103 if (!SWIG_IsOK(res2)) {
42104 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
42105 }
42106 arg2 = reinterpret_cast< wxWindow * >(argp2);
42107 }
42108 {
42109 if (!wxPyCheckForApp()) SWIG_fail;
42110 PyThreadState* __tstate = wxPyBeginAllowThreads();
42111 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
42112 wxPyEndAllowThreads(__tstate);
42113 if (PyErr_Occurred()) SWIG_fail;
42114 }
42115 {
42116 resultobj = wxPyMake_wxObject(result, 0);
42117 }
42118 {
42119 if (temp1)
42120 delete arg1;
42121 }
42122 return resultobj;
42123 fail:
42124 {
42125 if (temp1)
42126 delete arg1;
42127 }
42128 return NULL;
42129 }
42130
42131
42132 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42133 PyObject *resultobj = 0;
42134 wxWindow *arg1 = (wxWindow *) 0 ;
42135 unsigned long arg2 ;
42136 wxWindow *result = 0 ;
42137 void *argp1 = 0 ;
42138 int res1 = 0 ;
42139 unsigned long val2 ;
42140 int ecode2 = 0 ;
42141 PyObject * obj0 = 0 ;
42142 PyObject * obj1 = 0 ;
42143 char * kwnames[] = {
42144 (char *) "parent",(char *) "_hWnd", NULL
42145 };
42146
42147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
42148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
42149 if (!SWIG_IsOK(res1)) {
42150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
42151 }
42152 arg1 = reinterpret_cast< wxWindow * >(argp1);
42153 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
42154 if (!SWIG_IsOK(ecode2)) {
42155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
42156 }
42157 arg2 = static_cast< unsigned long >(val2);
42158 {
42159 if (!wxPyCheckForApp()) SWIG_fail;
42160 PyThreadState* __tstate = wxPyBeginAllowThreads();
42161 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
42162 wxPyEndAllowThreads(__tstate);
42163 if (PyErr_Occurred()) SWIG_fail;
42164 }
42165 {
42166 resultobj = wxPyMake_wxObject(result, 0);
42167 }
42168 return resultobj;
42169 fail:
42170 return NULL;
42171 }
42172
42173
42174 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42175 PyObject *resultobj = 0;
42176 PyObject *result = 0 ;
42177
42178 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
42179 {
42180 PyThreadState* __tstate = wxPyBeginAllowThreads();
42181 result = (PyObject *)GetTopLevelWindows();
42182 wxPyEndAllowThreads(__tstate);
42183 if (PyErr_Occurred()) SWIG_fail;
42184 }
42185 resultobj = result;
42186 return resultobj;
42187 fail:
42188 return NULL;
42189 }
42190
42191
42192 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42193 PyObject *resultobj = 0;
42194 wxValidator *result = 0 ;
42195
42196 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
42197 {
42198 PyThreadState* __tstate = wxPyBeginAllowThreads();
42199 result = (wxValidator *)new wxValidator();
42200 wxPyEndAllowThreads(__tstate);
42201 if (PyErr_Occurred()) SWIG_fail;
42202 }
42203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
42204 return resultobj;
42205 fail:
42206 return NULL;
42207 }
42208
42209
42210 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42211 PyObject *resultobj = 0;
42212 wxValidator *arg1 = (wxValidator *) 0 ;
42213 wxValidator *result = 0 ;
42214 void *argp1 = 0 ;
42215 int res1 = 0 ;
42216 PyObject *swig_obj[1] ;
42217
42218 if (!args) SWIG_fail;
42219 swig_obj[0] = args;
42220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42221 if (!SWIG_IsOK(res1)) {
42222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
42223 }
42224 arg1 = reinterpret_cast< wxValidator * >(argp1);
42225 {
42226 PyThreadState* __tstate = wxPyBeginAllowThreads();
42227 result = (wxValidator *)(arg1)->Clone();
42228 wxPyEndAllowThreads(__tstate);
42229 if (PyErr_Occurred()) SWIG_fail;
42230 }
42231 {
42232 resultobj = wxPyMake_wxObject(result, 0);
42233 }
42234 return resultobj;
42235 fail:
42236 return NULL;
42237 }
42238
42239
42240 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42241 PyObject *resultobj = 0;
42242 wxValidator *arg1 = (wxValidator *) 0 ;
42243 wxWindow *arg2 = (wxWindow *) 0 ;
42244 bool result;
42245 void *argp1 = 0 ;
42246 int res1 = 0 ;
42247 void *argp2 = 0 ;
42248 int res2 = 0 ;
42249 PyObject * obj0 = 0 ;
42250 PyObject * obj1 = 0 ;
42251 char * kwnames[] = {
42252 (char *) "self",(char *) "parent", NULL
42253 };
42254
42255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
42256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42257 if (!SWIG_IsOK(res1)) {
42258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
42259 }
42260 arg1 = reinterpret_cast< wxValidator * >(argp1);
42261 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42262 if (!SWIG_IsOK(res2)) {
42263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
42264 }
42265 arg2 = reinterpret_cast< wxWindow * >(argp2);
42266 {
42267 PyThreadState* __tstate = wxPyBeginAllowThreads();
42268 result = (bool)(arg1)->Validate(arg2);
42269 wxPyEndAllowThreads(__tstate);
42270 if (PyErr_Occurred()) SWIG_fail;
42271 }
42272 {
42273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42274 }
42275 return resultobj;
42276 fail:
42277 return NULL;
42278 }
42279
42280
42281 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42282 PyObject *resultobj = 0;
42283 wxValidator *arg1 = (wxValidator *) 0 ;
42284 bool result;
42285 void *argp1 = 0 ;
42286 int res1 = 0 ;
42287 PyObject *swig_obj[1] ;
42288
42289 if (!args) SWIG_fail;
42290 swig_obj[0] = args;
42291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42292 if (!SWIG_IsOK(res1)) {
42293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42294 }
42295 arg1 = reinterpret_cast< wxValidator * >(argp1);
42296 {
42297 PyThreadState* __tstate = wxPyBeginAllowThreads();
42298 result = (bool)(arg1)->TransferToWindow();
42299 wxPyEndAllowThreads(__tstate);
42300 if (PyErr_Occurred()) SWIG_fail;
42301 }
42302 {
42303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42304 }
42305 return resultobj;
42306 fail:
42307 return NULL;
42308 }
42309
42310
42311 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42312 PyObject *resultobj = 0;
42313 wxValidator *arg1 = (wxValidator *) 0 ;
42314 bool result;
42315 void *argp1 = 0 ;
42316 int res1 = 0 ;
42317 PyObject *swig_obj[1] ;
42318
42319 if (!args) SWIG_fail;
42320 swig_obj[0] = args;
42321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42322 if (!SWIG_IsOK(res1)) {
42323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42324 }
42325 arg1 = reinterpret_cast< wxValidator * >(argp1);
42326 {
42327 PyThreadState* __tstate = wxPyBeginAllowThreads();
42328 result = (bool)(arg1)->TransferFromWindow();
42329 wxPyEndAllowThreads(__tstate);
42330 if (PyErr_Occurred()) SWIG_fail;
42331 }
42332 {
42333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42334 }
42335 return resultobj;
42336 fail:
42337 return NULL;
42338 }
42339
42340
42341 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42342 PyObject *resultobj = 0;
42343 wxValidator *arg1 = (wxValidator *) 0 ;
42344 wxWindow *result = 0 ;
42345 void *argp1 = 0 ;
42346 int res1 = 0 ;
42347 PyObject *swig_obj[1] ;
42348
42349 if (!args) SWIG_fail;
42350 swig_obj[0] = args;
42351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42352 if (!SWIG_IsOK(res1)) {
42353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42354 }
42355 arg1 = reinterpret_cast< wxValidator * >(argp1);
42356 {
42357 PyThreadState* __tstate = wxPyBeginAllowThreads();
42358 result = (wxWindow *)(arg1)->GetWindow();
42359 wxPyEndAllowThreads(__tstate);
42360 if (PyErr_Occurred()) SWIG_fail;
42361 }
42362 {
42363 resultobj = wxPyMake_wxObject(result, 0);
42364 }
42365 return resultobj;
42366 fail:
42367 return NULL;
42368 }
42369
42370
42371 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42372 PyObject *resultobj = 0;
42373 wxValidator *arg1 = (wxValidator *) 0 ;
42374 wxWindow *arg2 = (wxWindow *) 0 ;
42375 void *argp1 = 0 ;
42376 int res1 = 0 ;
42377 void *argp2 = 0 ;
42378 int res2 = 0 ;
42379 PyObject * obj0 = 0 ;
42380 PyObject * obj1 = 0 ;
42381 char * kwnames[] = {
42382 (char *) "self",(char *) "window", NULL
42383 };
42384
42385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
42386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42387 if (!SWIG_IsOK(res1)) {
42388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42389 }
42390 arg1 = reinterpret_cast< wxValidator * >(argp1);
42391 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42392 if (!SWIG_IsOK(res2)) {
42393 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
42394 }
42395 arg2 = reinterpret_cast< wxWindow * >(argp2);
42396 {
42397 PyThreadState* __tstate = wxPyBeginAllowThreads();
42398 (arg1)->SetWindow(arg2);
42399 wxPyEndAllowThreads(__tstate);
42400 if (PyErr_Occurred()) SWIG_fail;
42401 }
42402 resultobj = SWIG_Py_Void();
42403 return resultobj;
42404 fail:
42405 return NULL;
42406 }
42407
42408
42409 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42410 PyObject *resultobj = 0;
42411 bool result;
42412
42413 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
42414 {
42415 PyThreadState* __tstate = wxPyBeginAllowThreads();
42416 result = (bool)wxValidator::IsSilent();
42417 wxPyEndAllowThreads(__tstate);
42418 if (PyErr_Occurred()) SWIG_fail;
42419 }
42420 {
42421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42422 }
42423 return resultobj;
42424 fail:
42425 return NULL;
42426 }
42427
42428
42429 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42430 PyObject *resultobj = 0;
42431 int arg1 = (int) true ;
42432 int val1 ;
42433 int ecode1 = 0 ;
42434 PyObject * obj0 = 0 ;
42435 char * kwnames[] = {
42436 (char *) "doIt", NULL
42437 };
42438
42439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
42440 if (obj0) {
42441 ecode1 = SWIG_AsVal_int(obj0, &val1);
42442 if (!SWIG_IsOK(ecode1)) {
42443 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
42444 }
42445 arg1 = static_cast< int >(val1);
42446 }
42447 {
42448 PyThreadState* __tstate = wxPyBeginAllowThreads();
42449 wxValidator::SetBellOnError(arg1);
42450 wxPyEndAllowThreads(__tstate);
42451 if (PyErr_Occurred()) SWIG_fail;
42452 }
42453 resultobj = SWIG_Py_Void();
42454 return resultobj;
42455 fail:
42456 return NULL;
42457 }
42458
42459
42460 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42461 PyObject *obj;
42462 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42463 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
42464 return SWIG_Py_Void();
42465 }
42466
42467 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42468 return SWIG_Python_InitShadowInstance(args);
42469 }
42470
42471 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42472 PyObject *resultobj = 0;
42473 wxPyValidator *result = 0 ;
42474
42475 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
42476 {
42477 PyThreadState* __tstate = wxPyBeginAllowThreads();
42478 result = (wxPyValidator *)new wxPyValidator();
42479 wxPyEndAllowThreads(__tstate);
42480 if (PyErr_Occurred()) SWIG_fail;
42481 }
42482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
42483 return resultobj;
42484 fail:
42485 return NULL;
42486 }
42487
42488
42489 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42490 PyObject *resultobj = 0;
42491 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
42492 PyObject *arg2 = (PyObject *) 0 ;
42493 PyObject *arg3 = (PyObject *) 0 ;
42494 int arg4 = (int) 1 ;
42495 void *argp1 = 0 ;
42496 int res1 = 0 ;
42497 int val4 ;
42498 int ecode4 = 0 ;
42499 PyObject * obj0 = 0 ;
42500 PyObject * obj1 = 0 ;
42501 PyObject * obj2 = 0 ;
42502 PyObject * obj3 = 0 ;
42503 char * kwnames[] = {
42504 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
42505 };
42506
42507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
42509 if (!SWIG_IsOK(res1)) {
42510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
42511 }
42512 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
42513 arg2 = obj1;
42514 arg3 = obj2;
42515 if (obj3) {
42516 ecode4 = SWIG_AsVal_int(obj3, &val4);
42517 if (!SWIG_IsOK(ecode4)) {
42518 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
42519 }
42520 arg4 = static_cast< int >(val4);
42521 }
42522 {
42523 PyThreadState* __tstate = wxPyBeginAllowThreads();
42524 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
42525 wxPyEndAllowThreads(__tstate);
42526 if (PyErr_Occurred()) SWIG_fail;
42527 }
42528 resultobj = SWIG_Py_Void();
42529 return resultobj;
42530 fail:
42531 return NULL;
42532 }
42533
42534
42535 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42536 PyObject *obj;
42537 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42538 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
42539 return SWIG_Py_Void();
42540 }
42541
42542 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42543 return SWIG_Python_InitShadowInstance(args);
42544 }
42545
42546 SWIGINTERN int DefaultValidator_set(PyObject *) {
42547 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
42548 return 1;
42549 }
42550
42551
42552 SWIGINTERN PyObject *DefaultValidator_get(void) {
42553 PyObject *pyobj = 0;
42554
42555 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
42556 return pyobj;
42557 }
42558
42559
42560 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42561 PyObject *resultobj = 0;
42562 wxString const &arg1_defvalue = wxPyEmptyString ;
42563 wxString *arg1 = (wxString *) &arg1_defvalue ;
42564 long arg2 = (long) 0 ;
42565 wxMenu *result = 0 ;
42566 bool temp1 = false ;
42567 long val2 ;
42568 int ecode2 = 0 ;
42569 PyObject * obj0 = 0 ;
42570 PyObject * obj1 = 0 ;
42571 char * kwnames[] = {
42572 (char *) "title",(char *) "style", NULL
42573 };
42574
42575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
42576 if (obj0) {
42577 {
42578 arg1 = wxString_in_helper(obj0);
42579 if (arg1 == NULL) SWIG_fail;
42580 temp1 = true;
42581 }
42582 }
42583 if (obj1) {
42584 ecode2 = SWIG_AsVal_long(obj1, &val2);
42585 if (!SWIG_IsOK(ecode2)) {
42586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
42587 }
42588 arg2 = static_cast< long >(val2);
42589 }
42590 {
42591 if (!wxPyCheckForApp()) SWIG_fail;
42592 PyThreadState* __tstate = wxPyBeginAllowThreads();
42593 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
42594 wxPyEndAllowThreads(__tstate);
42595 if (PyErr_Occurred()) SWIG_fail;
42596 }
42597 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
42598 {
42599 if (temp1)
42600 delete arg1;
42601 }
42602 return resultobj;
42603 fail:
42604 {
42605 if (temp1)
42606 delete arg1;
42607 }
42608 return NULL;
42609 }
42610
42611
42612 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42613 PyObject *resultobj = 0;
42614 wxMenu *arg1 = (wxMenu *) 0 ;
42615 int arg2 ;
42616 wxString const &arg3_defvalue = wxPyEmptyString ;
42617 wxString *arg3 = (wxString *) &arg3_defvalue ;
42618 wxString const &arg4_defvalue = wxPyEmptyString ;
42619 wxString *arg4 = (wxString *) &arg4_defvalue ;
42620 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42621 wxMenuItem *result = 0 ;
42622 void *argp1 = 0 ;
42623 int res1 = 0 ;
42624 int val2 ;
42625 int ecode2 = 0 ;
42626 bool temp3 = false ;
42627 bool temp4 = false ;
42628 int val5 ;
42629 int ecode5 = 0 ;
42630 PyObject * obj0 = 0 ;
42631 PyObject * obj1 = 0 ;
42632 PyObject * obj2 = 0 ;
42633 PyObject * obj3 = 0 ;
42634 PyObject * obj4 = 0 ;
42635 char * kwnames[] = {
42636 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42637 };
42638
42639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42641 if (!SWIG_IsOK(res1)) {
42642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
42643 }
42644 arg1 = reinterpret_cast< wxMenu * >(argp1);
42645 ecode2 = SWIG_AsVal_int(obj1, &val2);
42646 if (!SWIG_IsOK(ecode2)) {
42647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
42648 }
42649 arg2 = static_cast< int >(val2);
42650 if (obj2) {
42651 {
42652 arg3 = wxString_in_helper(obj2);
42653 if (arg3 == NULL) SWIG_fail;
42654 temp3 = true;
42655 }
42656 }
42657 if (obj3) {
42658 {
42659 arg4 = wxString_in_helper(obj3);
42660 if (arg4 == NULL) SWIG_fail;
42661 temp4 = true;
42662 }
42663 }
42664 if (obj4) {
42665 ecode5 = SWIG_AsVal_int(obj4, &val5);
42666 if (!SWIG_IsOK(ecode5)) {
42667 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
42668 }
42669 arg5 = static_cast< wxItemKind >(val5);
42670 }
42671 {
42672 PyThreadState* __tstate = wxPyBeginAllowThreads();
42673 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42674 wxPyEndAllowThreads(__tstate);
42675 if (PyErr_Occurred()) SWIG_fail;
42676 }
42677 {
42678 resultobj = wxPyMake_wxObject(result, (bool)0);
42679 }
42680 {
42681 if (temp3)
42682 delete arg3;
42683 }
42684 {
42685 if (temp4)
42686 delete arg4;
42687 }
42688 return resultobj;
42689 fail:
42690 {
42691 if (temp3)
42692 delete arg3;
42693 }
42694 {
42695 if (temp4)
42696 delete arg4;
42697 }
42698 return NULL;
42699 }
42700
42701
42702 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42703 PyObject *resultobj = 0;
42704 wxMenu *arg1 = (wxMenu *) 0 ;
42705 wxMenuItem *result = 0 ;
42706 void *argp1 = 0 ;
42707 int res1 = 0 ;
42708 PyObject *swig_obj[1] ;
42709
42710 if (!args) SWIG_fail;
42711 swig_obj[0] = args;
42712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42713 if (!SWIG_IsOK(res1)) {
42714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42715 }
42716 arg1 = reinterpret_cast< wxMenu * >(argp1);
42717 {
42718 PyThreadState* __tstate = wxPyBeginAllowThreads();
42719 result = (wxMenuItem *)(arg1)->AppendSeparator();
42720 wxPyEndAllowThreads(__tstate);
42721 if (PyErr_Occurred()) SWIG_fail;
42722 }
42723 {
42724 resultobj = wxPyMake_wxObject(result, (bool)0);
42725 }
42726 return resultobj;
42727 fail:
42728 return NULL;
42729 }
42730
42731
42732 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42733 PyObject *resultobj = 0;
42734 wxMenu *arg1 = (wxMenu *) 0 ;
42735 int arg2 ;
42736 wxString *arg3 = 0 ;
42737 wxString const &arg4_defvalue = wxPyEmptyString ;
42738 wxString *arg4 = (wxString *) &arg4_defvalue ;
42739 wxMenuItem *result = 0 ;
42740 void *argp1 = 0 ;
42741 int res1 = 0 ;
42742 int val2 ;
42743 int ecode2 = 0 ;
42744 bool temp3 = false ;
42745 bool temp4 = false ;
42746 PyObject * obj0 = 0 ;
42747 PyObject * obj1 = 0 ;
42748 PyObject * obj2 = 0 ;
42749 PyObject * obj3 = 0 ;
42750 char * kwnames[] = {
42751 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42752 };
42753
42754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42756 if (!SWIG_IsOK(res1)) {
42757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42758 }
42759 arg1 = reinterpret_cast< wxMenu * >(argp1);
42760 ecode2 = SWIG_AsVal_int(obj1, &val2);
42761 if (!SWIG_IsOK(ecode2)) {
42762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
42763 }
42764 arg2 = static_cast< int >(val2);
42765 {
42766 arg3 = wxString_in_helper(obj2);
42767 if (arg3 == NULL) SWIG_fail;
42768 temp3 = true;
42769 }
42770 if (obj3) {
42771 {
42772 arg4 = wxString_in_helper(obj3);
42773 if (arg4 == NULL) SWIG_fail;
42774 temp4 = true;
42775 }
42776 }
42777 {
42778 PyThreadState* __tstate = wxPyBeginAllowThreads();
42779 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42780 wxPyEndAllowThreads(__tstate);
42781 if (PyErr_Occurred()) SWIG_fail;
42782 }
42783 {
42784 resultobj = wxPyMake_wxObject(result, (bool)0);
42785 }
42786 {
42787 if (temp3)
42788 delete arg3;
42789 }
42790 {
42791 if (temp4)
42792 delete arg4;
42793 }
42794 return resultobj;
42795 fail:
42796 {
42797 if (temp3)
42798 delete arg3;
42799 }
42800 {
42801 if (temp4)
42802 delete arg4;
42803 }
42804 return NULL;
42805 }
42806
42807
42808 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42809 PyObject *resultobj = 0;
42810 wxMenu *arg1 = (wxMenu *) 0 ;
42811 int arg2 ;
42812 wxString *arg3 = 0 ;
42813 wxString const &arg4_defvalue = wxPyEmptyString ;
42814 wxString *arg4 = (wxString *) &arg4_defvalue ;
42815 wxMenuItem *result = 0 ;
42816 void *argp1 = 0 ;
42817 int res1 = 0 ;
42818 int val2 ;
42819 int ecode2 = 0 ;
42820 bool temp3 = false ;
42821 bool temp4 = false ;
42822 PyObject * obj0 = 0 ;
42823 PyObject * obj1 = 0 ;
42824 PyObject * obj2 = 0 ;
42825 PyObject * obj3 = 0 ;
42826 char * kwnames[] = {
42827 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42828 };
42829
42830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42832 if (!SWIG_IsOK(res1)) {
42833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42834 }
42835 arg1 = reinterpret_cast< wxMenu * >(argp1);
42836 ecode2 = SWIG_AsVal_int(obj1, &val2);
42837 if (!SWIG_IsOK(ecode2)) {
42838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
42839 }
42840 arg2 = static_cast< int >(val2);
42841 {
42842 arg3 = wxString_in_helper(obj2);
42843 if (arg3 == NULL) SWIG_fail;
42844 temp3 = true;
42845 }
42846 if (obj3) {
42847 {
42848 arg4 = wxString_in_helper(obj3);
42849 if (arg4 == NULL) SWIG_fail;
42850 temp4 = true;
42851 }
42852 }
42853 {
42854 PyThreadState* __tstate = wxPyBeginAllowThreads();
42855 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42856 wxPyEndAllowThreads(__tstate);
42857 if (PyErr_Occurred()) SWIG_fail;
42858 }
42859 {
42860 resultobj = wxPyMake_wxObject(result, (bool)0);
42861 }
42862 {
42863 if (temp3)
42864 delete arg3;
42865 }
42866 {
42867 if (temp4)
42868 delete arg4;
42869 }
42870 return resultobj;
42871 fail:
42872 {
42873 if (temp3)
42874 delete arg3;
42875 }
42876 {
42877 if (temp4)
42878 delete arg4;
42879 }
42880 return NULL;
42881 }
42882
42883
42884 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42885 PyObject *resultobj = 0;
42886 wxMenu *arg1 = (wxMenu *) 0 ;
42887 int arg2 ;
42888 wxString *arg3 = 0 ;
42889 wxMenu *arg4 = (wxMenu *) 0 ;
42890 wxString const &arg5_defvalue = wxPyEmptyString ;
42891 wxString *arg5 = (wxString *) &arg5_defvalue ;
42892 wxMenuItem *result = 0 ;
42893 void *argp1 = 0 ;
42894 int res1 = 0 ;
42895 int val2 ;
42896 int ecode2 = 0 ;
42897 bool temp3 = false ;
42898 void *argp4 = 0 ;
42899 int res4 = 0 ;
42900 bool temp5 = false ;
42901 PyObject * obj0 = 0 ;
42902 PyObject * obj1 = 0 ;
42903 PyObject * obj2 = 0 ;
42904 PyObject * obj3 = 0 ;
42905 PyObject * obj4 = 0 ;
42906 char * kwnames[] = {
42907 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42908 };
42909
42910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42912 if (!SWIG_IsOK(res1)) {
42913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42914 }
42915 arg1 = reinterpret_cast< wxMenu * >(argp1);
42916 ecode2 = SWIG_AsVal_int(obj1, &val2);
42917 if (!SWIG_IsOK(ecode2)) {
42918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42919 }
42920 arg2 = static_cast< int >(val2);
42921 {
42922 arg3 = wxString_in_helper(obj2);
42923 if (arg3 == NULL) SWIG_fail;
42924 temp3 = true;
42925 }
42926 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42927 if (!SWIG_IsOK(res4)) {
42928 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42929 }
42930 arg4 = reinterpret_cast< wxMenu * >(argp4);
42931 if (obj4) {
42932 {
42933 arg5 = wxString_in_helper(obj4);
42934 if (arg5 == NULL) SWIG_fail;
42935 temp5 = true;
42936 }
42937 }
42938 {
42939 PyThreadState* __tstate = wxPyBeginAllowThreads();
42940 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42941 wxPyEndAllowThreads(__tstate);
42942 if (PyErr_Occurred()) SWIG_fail;
42943 }
42944 {
42945 resultobj = wxPyMake_wxObject(result, (bool)0);
42946 }
42947 {
42948 if (temp3)
42949 delete arg3;
42950 }
42951 {
42952 if (temp5)
42953 delete arg5;
42954 }
42955 return resultobj;
42956 fail:
42957 {
42958 if (temp3)
42959 delete arg3;
42960 }
42961 {
42962 if (temp5)
42963 delete arg5;
42964 }
42965 return NULL;
42966 }
42967
42968
42969 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42970 PyObject *resultobj = 0;
42971 wxMenu *arg1 = (wxMenu *) 0 ;
42972 wxMenu *arg2 = (wxMenu *) 0 ;
42973 wxString *arg3 = 0 ;
42974 wxString const &arg4_defvalue = wxPyEmptyString ;
42975 wxString *arg4 = (wxString *) &arg4_defvalue ;
42976 wxMenuItem *result = 0 ;
42977 void *argp1 = 0 ;
42978 int res1 = 0 ;
42979 void *argp2 = 0 ;
42980 int res2 = 0 ;
42981 bool temp3 = false ;
42982 bool temp4 = false ;
42983 PyObject * obj0 = 0 ;
42984 PyObject * obj1 = 0 ;
42985 PyObject * obj2 = 0 ;
42986 PyObject * obj3 = 0 ;
42987 char * kwnames[] = {
42988 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42989 };
42990
42991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42993 if (!SWIG_IsOK(res1)) {
42994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42995 }
42996 arg1 = reinterpret_cast< wxMenu * >(argp1);
42997 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42998 if (!SWIG_IsOK(res2)) {
42999 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43000 }
43001 arg2 = reinterpret_cast< wxMenu * >(argp2);
43002 {
43003 arg3 = wxString_in_helper(obj2);
43004 if (arg3 == NULL) SWIG_fail;
43005 temp3 = true;
43006 }
43007 if (obj3) {
43008 {
43009 arg4 = wxString_in_helper(obj3);
43010 if (arg4 == NULL) SWIG_fail;
43011 temp4 = true;
43012 }
43013 }
43014 {
43015 PyThreadState* __tstate = wxPyBeginAllowThreads();
43016 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43017 wxPyEndAllowThreads(__tstate);
43018 if (PyErr_Occurred()) SWIG_fail;
43019 }
43020 {
43021 resultobj = wxPyMake_wxObject(result, (bool)0);
43022 }
43023 {
43024 if (temp3)
43025 delete arg3;
43026 }
43027 {
43028 if (temp4)
43029 delete arg4;
43030 }
43031 return resultobj;
43032 fail:
43033 {
43034 if (temp3)
43035 delete arg3;
43036 }
43037 {
43038 if (temp4)
43039 delete arg4;
43040 }
43041 return NULL;
43042 }
43043
43044
43045 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43046 PyObject *resultobj = 0;
43047 wxMenu *arg1 = (wxMenu *) 0 ;
43048 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43049 wxMenuItem *result = 0 ;
43050 void *argp1 = 0 ;
43051 int res1 = 0 ;
43052 int res2 = 0 ;
43053 PyObject * obj0 = 0 ;
43054 PyObject * obj1 = 0 ;
43055 char * kwnames[] = {
43056 (char *) "self",(char *) "item", NULL
43057 };
43058
43059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
43060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43061 if (!SWIG_IsOK(res1)) {
43062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43063 }
43064 arg1 = reinterpret_cast< wxMenu * >(argp1);
43065 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43066 if (!SWIG_IsOK(res2)) {
43067 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43068 }
43069 {
43070 PyThreadState* __tstate = wxPyBeginAllowThreads();
43071 result = (wxMenuItem *)(arg1)->Append(arg2);
43072 wxPyEndAllowThreads(__tstate);
43073 if (PyErr_Occurred()) SWIG_fail;
43074 }
43075 {
43076 resultobj = wxPyMake_wxObject(result, (bool)0);
43077 }
43078 return resultobj;
43079 fail:
43080 return NULL;
43081 }
43082
43083
43084 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43085 PyObject *resultobj = 0;
43086 wxMenu *arg1 = (wxMenu *) 0 ;
43087 size_t arg2 ;
43088 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
43089 wxMenuItem *result = 0 ;
43090 void *argp1 = 0 ;
43091 int res1 = 0 ;
43092 size_t val2 ;
43093 int ecode2 = 0 ;
43094 int res3 = 0 ;
43095 PyObject * obj0 = 0 ;
43096 PyObject * obj1 = 0 ;
43097 PyObject * obj2 = 0 ;
43098 char * kwnames[] = {
43099 (char *) "self",(char *) "pos",(char *) "item", NULL
43100 };
43101
43102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43104 if (!SWIG_IsOK(res1)) {
43105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43106 }
43107 arg1 = reinterpret_cast< wxMenu * >(argp1);
43108 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43109 if (!SWIG_IsOK(ecode2)) {
43110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
43111 }
43112 arg2 = static_cast< size_t >(val2);
43113 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43114 if (!SWIG_IsOK(res3)) {
43115 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
43116 }
43117 {
43118 PyThreadState* __tstate = wxPyBeginAllowThreads();
43119 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
43120 wxPyEndAllowThreads(__tstate);
43121 if (PyErr_Occurred()) SWIG_fail;
43122 }
43123 {
43124 resultobj = wxPyMake_wxObject(result, (bool)0);
43125 }
43126 return resultobj;
43127 fail:
43128 return NULL;
43129 }
43130
43131
43132 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43133 PyObject *resultobj = 0;
43134 wxMenu *arg1 = (wxMenu *) 0 ;
43135 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43136 wxMenuItem *result = 0 ;
43137 void *argp1 = 0 ;
43138 int res1 = 0 ;
43139 int res2 = 0 ;
43140 PyObject * obj0 = 0 ;
43141 PyObject * obj1 = 0 ;
43142 char * kwnames[] = {
43143 (char *) "self",(char *) "item", NULL
43144 };
43145
43146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
43147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43148 if (!SWIG_IsOK(res1)) {
43149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43150 }
43151 arg1 = reinterpret_cast< wxMenu * >(argp1);
43152 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43153 if (!SWIG_IsOK(res2)) {
43154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43155 }
43156 {
43157 PyThreadState* __tstate = wxPyBeginAllowThreads();
43158 result = (wxMenuItem *)(arg1)->Prepend(arg2);
43159 wxPyEndAllowThreads(__tstate);
43160 if (PyErr_Occurred()) SWIG_fail;
43161 }
43162 {
43163 resultobj = wxPyMake_wxObject(result, (bool)0);
43164 }
43165 return resultobj;
43166 fail:
43167 return NULL;
43168 }
43169
43170
43171 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43172 PyObject *resultobj = 0;
43173 wxMenu *arg1 = (wxMenu *) 0 ;
43174 void *argp1 = 0 ;
43175 int res1 = 0 ;
43176 PyObject *swig_obj[1] ;
43177
43178 if (!args) SWIG_fail;
43179 swig_obj[0] = args;
43180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43181 if (!SWIG_IsOK(res1)) {
43182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
43183 }
43184 arg1 = reinterpret_cast< wxMenu * >(argp1);
43185 {
43186 PyThreadState* __tstate = wxPyBeginAllowThreads();
43187 (arg1)->Break();
43188 wxPyEndAllowThreads(__tstate);
43189 if (PyErr_Occurred()) SWIG_fail;
43190 }
43191 resultobj = SWIG_Py_Void();
43192 return resultobj;
43193 fail:
43194 return NULL;
43195 }
43196
43197
43198 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43199 PyObject *resultobj = 0;
43200 wxMenu *arg1 = (wxMenu *) 0 ;
43201 size_t arg2 ;
43202 int arg3 ;
43203 wxString const &arg4_defvalue = wxPyEmptyString ;
43204 wxString *arg4 = (wxString *) &arg4_defvalue ;
43205 wxString const &arg5_defvalue = wxPyEmptyString ;
43206 wxString *arg5 = (wxString *) &arg5_defvalue ;
43207 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
43208 wxMenuItem *result = 0 ;
43209 void *argp1 = 0 ;
43210 int res1 = 0 ;
43211 size_t val2 ;
43212 int ecode2 = 0 ;
43213 int val3 ;
43214 int ecode3 = 0 ;
43215 bool temp4 = false ;
43216 bool temp5 = false ;
43217 int val6 ;
43218 int ecode6 = 0 ;
43219 PyObject * obj0 = 0 ;
43220 PyObject * obj1 = 0 ;
43221 PyObject * obj2 = 0 ;
43222 PyObject * obj3 = 0 ;
43223 PyObject * obj4 = 0 ;
43224 PyObject * obj5 = 0 ;
43225 char * kwnames[] = {
43226 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
43227 };
43228
43229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43231 if (!SWIG_IsOK(res1)) {
43232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
43233 }
43234 arg1 = reinterpret_cast< wxMenu * >(argp1);
43235 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43236 if (!SWIG_IsOK(ecode2)) {
43237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
43238 }
43239 arg2 = static_cast< size_t >(val2);
43240 ecode3 = SWIG_AsVal_int(obj2, &val3);
43241 if (!SWIG_IsOK(ecode3)) {
43242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
43243 }
43244 arg3 = static_cast< int >(val3);
43245 if (obj3) {
43246 {
43247 arg4 = wxString_in_helper(obj3);
43248 if (arg4 == NULL) SWIG_fail;
43249 temp4 = true;
43250 }
43251 }
43252 if (obj4) {
43253 {
43254 arg5 = wxString_in_helper(obj4);
43255 if (arg5 == NULL) SWIG_fail;
43256 temp5 = true;
43257 }
43258 }
43259 if (obj5) {
43260 ecode6 = SWIG_AsVal_int(obj5, &val6);
43261 if (!SWIG_IsOK(ecode6)) {
43262 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
43263 }
43264 arg6 = static_cast< wxItemKind >(val6);
43265 }
43266 {
43267 PyThreadState* __tstate = wxPyBeginAllowThreads();
43268 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
43269 wxPyEndAllowThreads(__tstate);
43270 if (PyErr_Occurred()) SWIG_fail;
43271 }
43272 {
43273 resultobj = wxPyMake_wxObject(result, (bool)0);
43274 }
43275 {
43276 if (temp4)
43277 delete arg4;
43278 }
43279 {
43280 if (temp5)
43281 delete arg5;
43282 }
43283 return resultobj;
43284 fail:
43285 {
43286 if (temp4)
43287 delete arg4;
43288 }
43289 {
43290 if (temp5)
43291 delete arg5;
43292 }
43293 return NULL;
43294 }
43295
43296
43297 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43298 PyObject *resultobj = 0;
43299 wxMenu *arg1 = (wxMenu *) 0 ;
43300 size_t arg2 ;
43301 wxMenuItem *result = 0 ;
43302 void *argp1 = 0 ;
43303 int res1 = 0 ;
43304 size_t val2 ;
43305 int ecode2 = 0 ;
43306 PyObject * obj0 = 0 ;
43307 PyObject * obj1 = 0 ;
43308 char * kwnames[] = {
43309 (char *) "self",(char *) "pos", NULL
43310 };
43311
43312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
43313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43314 if (!SWIG_IsOK(res1)) {
43315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
43316 }
43317 arg1 = reinterpret_cast< wxMenu * >(argp1);
43318 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43319 if (!SWIG_IsOK(ecode2)) {
43320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
43321 }
43322 arg2 = static_cast< size_t >(val2);
43323 {
43324 PyThreadState* __tstate = wxPyBeginAllowThreads();
43325 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
43326 wxPyEndAllowThreads(__tstate);
43327 if (PyErr_Occurred()) SWIG_fail;
43328 }
43329 {
43330 resultobj = wxPyMake_wxObject(result, (bool)0);
43331 }
43332 return resultobj;
43333 fail:
43334 return NULL;
43335 }
43336
43337
43338 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43339 PyObject *resultobj = 0;
43340 wxMenu *arg1 = (wxMenu *) 0 ;
43341 size_t arg2 ;
43342 int arg3 ;
43343 wxString *arg4 = 0 ;
43344 wxString const &arg5_defvalue = wxPyEmptyString ;
43345 wxString *arg5 = (wxString *) &arg5_defvalue ;
43346 wxMenuItem *result = 0 ;
43347 void *argp1 = 0 ;
43348 int res1 = 0 ;
43349 size_t val2 ;
43350 int ecode2 = 0 ;
43351 int val3 ;
43352 int ecode3 = 0 ;
43353 bool temp4 = false ;
43354 bool temp5 = false ;
43355 PyObject * obj0 = 0 ;
43356 PyObject * obj1 = 0 ;
43357 PyObject * obj2 = 0 ;
43358 PyObject * obj3 = 0 ;
43359 PyObject * obj4 = 0 ;
43360 char * kwnames[] = {
43361 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
43362 };
43363
43364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43366 if (!SWIG_IsOK(res1)) {
43367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43368 }
43369 arg1 = reinterpret_cast< wxMenu * >(argp1);
43370 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43371 if (!SWIG_IsOK(ecode2)) {
43372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
43373 }
43374 arg2 = static_cast< size_t >(val2);
43375 ecode3 = SWIG_AsVal_int(obj2, &val3);
43376 if (!SWIG_IsOK(ecode3)) {
43377 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
43378 }
43379 arg3 = static_cast< int >(val3);
43380 {
43381 arg4 = wxString_in_helper(obj3);
43382 if (arg4 == NULL) SWIG_fail;
43383 temp4 = true;
43384 }
43385 if (obj4) {
43386 {
43387 arg5 = wxString_in_helper(obj4);
43388 if (arg5 == NULL) SWIG_fail;
43389 temp5 = true;
43390 }
43391 }
43392 {
43393 PyThreadState* __tstate = wxPyBeginAllowThreads();
43394 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
43395 wxPyEndAllowThreads(__tstate);
43396 if (PyErr_Occurred()) SWIG_fail;
43397 }
43398 {
43399 resultobj = wxPyMake_wxObject(result, (bool)0);
43400 }
43401 {
43402 if (temp4)
43403 delete arg4;
43404 }
43405 {
43406 if (temp5)
43407 delete arg5;
43408 }
43409 return resultobj;
43410 fail:
43411 {
43412 if (temp4)
43413 delete arg4;
43414 }
43415 {
43416 if (temp5)
43417 delete arg5;
43418 }
43419 return NULL;
43420 }
43421
43422
43423 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43424 PyObject *resultobj = 0;
43425 wxMenu *arg1 = (wxMenu *) 0 ;
43426 size_t arg2 ;
43427 int arg3 ;
43428 wxString *arg4 = 0 ;
43429 wxString const &arg5_defvalue = wxPyEmptyString ;
43430 wxString *arg5 = (wxString *) &arg5_defvalue ;
43431 wxMenuItem *result = 0 ;
43432 void *argp1 = 0 ;
43433 int res1 = 0 ;
43434 size_t val2 ;
43435 int ecode2 = 0 ;
43436 int val3 ;
43437 int ecode3 = 0 ;
43438 bool temp4 = false ;
43439 bool temp5 = false ;
43440 PyObject * obj0 = 0 ;
43441 PyObject * obj1 = 0 ;
43442 PyObject * obj2 = 0 ;
43443 PyObject * obj3 = 0 ;
43444 PyObject * obj4 = 0 ;
43445 char * kwnames[] = {
43446 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
43447 };
43448
43449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43451 if (!SWIG_IsOK(res1)) {
43452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43453 }
43454 arg1 = reinterpret_cast< wxMenu * >(argp1);
43455 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43456 if (!SWIG_IsOK(ecode2)) {
43457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
43458 }
43459 arg2 = static_cast< size_t >(val2);
43460 ecode3 = SWIG_AsVal_int(obj2, &val3);
43461 if (!SWIG_IsOK(ecode3)) {
43462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
43463 }
43464 arg3 = static_cast< int >(val3);
43465 {
43466 arg4 = wxString_in_helper(obj3);
43467 if (arg4 == NULL) SWIG_fail;
43468 temp4 = true;
43469 }
43470 if (obj4) {
43471 {
43472 arg5 = wxString_in_helper(obj4);
43473 if (arg5 == NULL) SWIG_fail;
43474 temp5 = true;
43475 }
43476 }
43477 {
43478 PyThreadState* __tstate = wxPyBeginAllowThreads();
43479 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
43480 wxPyEndAllowThreads(__tstate);
43481 if (PyErr_Occurred()) SWIG_fail;
43482 }
43483 {
43484 resultobj = wxPyMake_wxObject(result, (bool)0);
43485 }
43486 {
43487 if (temp4)
43488 delete arg4;
43489 }
43490 {
43491 if (temp5)
43492 delete arg5;
43493 }
43494 return resultobj;
43495 fail:
43496 {
43497 if (temp4)
43498 delete arg4;
43499 }
43500 {
43501 if (temp5)
43502 delete arg5;
43503 }
43504 return NULL;
43505 }
43506
43507
43508 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43509 PyObject *resultobj = 0;
43510 wxMenu *arg1 = (wxMenu *) 0 ;
43511 size_t arg2 ;
43512 int arg3 ;
43513 wxString *arg4 = 0 ;
43514 wxMenu *arg5 = (wxMenu *) 0 ;
43515 wxString const &arg6_defvalue = wxPyEmptyString ;
43516 wxString *arg6 = (wxString *) &arg6_defvalue ;
43517 wxMenuItem *result = 0 ;
43518 void *argp1 = 0 ;
43519 int res1 = 0 ;
43520 size_t val2 ;
43521 int ecode2 = 0 ;
43522 int val3 ;
43523 int ecode3 = 0 ;
43524 bool temp4 = false ;
43525 void *argp5 = 0 ;
43526 int res5 = 0 ;
43527 bool temp6 = false ;
43528 PyObject * obj0 = 0 ;
43529 PyObject * obj1 = 0 ;
43530 PyObject * obj2 = 0 ;
43531 PyObject * obj3 = 0 ;
43532 PyObject * obj4 = 0 ;
43533 PyObject * obj5 = 0 ;
43534 char * kwnames[] = {
43535 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43536 };
43537
43538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43540 if (!SWIG_IsOK(res1)) {
43541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43542 }
43543 arg1 = reinterpret_cast< wxMenu * >(argp1);
43544 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43545 if (!SWIG_IsOK(ecode2)) {
43546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
43547 }
43548 arg2 = static_cast< size_t >(val2);
43549 ecode3 = SWIG_AsVal_int(obj2, &val3);
43550 if (!SWIG_IsOK(ecode3)) {
43551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
43552 }
43553 arg3 = static_cast< int >(val3);
43554 {
43555 arg4 = wxString_in_helper(obj3);
43556 if (arg4 == NULL) SWIG_fail;
43557 temp4 = true;
43558 }
43559 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
43560 if (!SWIG_IsOK(res5)) {
43561 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
43562 }
43563 arg5 = reinterpret_cast< wxMenu * >(argp5);
43564 if (obj5) {
43565 {
43566 arg6 = wxString_in_helper(obj5);
43567 if (arg6 == NULL) SWIG_fail;
43568 temp6 = true;
43569 }
43570 }
43571 {
43572 PyThreadState* __tstate = wxPyBeginAllowThreads();
43573 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
43574 wxPyEndAllowThreads(__tstate);
43575 if (PyErr_Occurred()) SWIG_fail;
43576 }
43577 {
43578 resultobj = wxPyMake_wxObject(result, (bool)0);
43579 }
43580 {
43581 if (temp4)
43582 delete arg4;
43583 }
43584 {
43585 if (temp6)
43586 delete arg6;
43587 }
43588 return resultobj;
43589 fail:
43590 {
43591 if (temp4)
43592 delete arg4;
43593 }
43594 {
43595 if (temp6)
43596 delete arg6;
43597 }
43598 return NULL;
43599 }
43600
43601
43602 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43603 PyObject *resultobj = 0;
43604 wxMenu *arg1 = (wxMenu *) 0 ;
43605 int arg2 ;
43606 wxString const &arg3_defvalue = wxPyEmptyString ;
43607 wxString *arg3 = (wxString *) &arg3_defvalue ;
43608 wxString const &arg4_defvalue = wxPyEmptyString ;
43609 wxString *arg4 = (wxString *) &arg4_defvalue ;
43610 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43611 wxMenuItem *result = 0 ;
43612 void *argp1 = 0 ;
43613 int res1 = 0 ;
43614 int val2 ;
43615 int ecode2 = 0 ;
43616 bool temp3 = false ;
43617 bool temp4 = false ;
43618 int val5 ;
43619 int ecode5 = 0 ;
43620 PyObject * obj0 = 0 ;
43621 PyObject * obj1 = 0 ;
43622 PyObject * obj2 = 0 ;
43623 PyObject * obj3 = 0 ;
43624 PyObject * obj4 = 0 ;
43625 char * kwnames[] = {
43626 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
43627 };
43628
43629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43631 if (!SWIG_IsOK(res1)) {
43632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
43633 }
43634 arg1 = reinterpret_cast< wxMenu * >(argp1);
43635 ecode2 = SWIG_AsVal_int(obj1, &val2);
43636 if (!SWIG_IsOK(ecode2)) {
43637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
43638 }
43639 arg2 = static_cast< int >(val2);
43640 if (obj2) {
43641 {
43642 arg3 = wxString_in_helper(obj2);
43643 if (arg3 == NULL) SWIG_fail;
43644 temp3 = true;
43645 }
43646 }
43647 if (obj3) {
43648 {
43649 arg4 = wxString_in_helper(obj3);
43650 if (arg4 == NULL) SWIG_fail;
43651 temp4 = true;
43652 }
43653 }
43654 if (obj4) {
43655 ecode5 = SWIG_AsVal_int(obj4, &val5);
43656 if (!SWIG_IsOK(ecode5)) {
43657 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
43658 }
43659 arg5 = static_cast< wxItemKind >(val5);
43660 }
43661 {
43662 PyThreadState* __tstate = wxPyBeginAllowThreads();
43663 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
43664 wxPyEndAllowThreads(__tstate);
43665 if (PyErr_Occurred()) SWIG_fail;
43666 }
43667 {
43668 resultobj = wxPyMake_wxObject(result, (bool)0);
43669 }
43670 {
43671 if (temp3)
43672 delete arg3;
43673 }
43674 {
43675 if (temp4)
43676 delete arg4;
43677 }
43678 return resultobj;
43679 fail:
43680 {
43681 if (temp3)
43682 delete arg3;
43683 }
43684 {
43685 if (temp4)
43686 delete arg4;
43687 }
43688 return NULL;
43689 }
43690
43691
43692 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43693 PyObject *resultobj = 0;
43694 wxMenu *arg1 = (wxMenu *) 0 ;
43695 wxMenuItem *result = 0 ;
43696 void *argp1 = 0 ;
43697 int res1 = 0 ;
43698 PyObject *swig_obj[1] ;
43699
43700 if (!args) SWIG_fail;
43701 swig_obj[0] = args;
43702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43703 if (!SWIG_IsOK(res1)) {
43704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
43705 }
43706 arg1 = reinterpret_cast< wxMenu * >(argp1);
43707 {
43708 PyThreadState* __tstate = wxPyBeginAllowThreads();
43709 result = (wxMenuItem *)(arg1)->PrependSeparator();
43710 wxPyEndAllowThreads(__tstate);
43711 if (PyErr_Occurred()) SWIG_fail;
43712 }
43713 {
43714 resultobj = wxPyMake_wxObject(result, (bool)0);
43715 }
43716 return resultobj;
43717 fail:
43718 return NULL;
43719 }
43720
43721
43722 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43723 PyObject *resultobj = 0;
43724 wxMenu *arg1 = (wxMenu *) 0 ;
43725 int arg2 ;
43726 wxString *arg3 = 0 ;
43727 wxString const &arg4_defvalue = wxPyEmptyString ;
43728 wxString *arg4 = (wxString *) &arg4_defvalue ;
43729 wxMenuItem *result = 0 ;
43730 void *argp1 = 0 ;
43731 int res1 = 0 ;
43732 int val2 ;
43733 int ecode2 = 0 ;
43734 bool temp3 = false ;
43735 bool temp4 = false ;
43736 PyObject * obj0 = 0 ;
43737 PyObject * obj1 = 0 ;
43738 PyObject * obj2 = 0 ;
43739 PyObject * obj3 = 0 ;
43740 char * kwnames[] = {
43741 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43742 };
43743
43744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43746 if (!SWIG_IsOK(res1)) {
43747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43748 }
43749 arg1 = reinterpret_cast< wxMenu * >(argp1);
43750 ecode2 = SWIG_AsVal_int(obj1, &val2);
43751 if (!SWIG_IsOK(ecode2)) {
43752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
43753 }
43754 arg2 = static_cast< int >(val2);
43755 {
43756 arg3 = wxString_in_helper(obj2);
43757 if (arg3 == NULL) SWIG_fail;
43758 temp3 = true;
43759 }
43760 if (obj3) {
43761 {
43762 arg4 = wxString_in_helper(obj3);
43763 if (arg4 == NULL) SWIG_fail;
43764 temp4 = true;
43765 }
43766 }
43767 {
43768 PyThreadState* __tstate = wxPyBeginAllowThreads();
43769 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43770 wxPyEndAllowThreads(__tstate);
43771 if (PyErr_Occurred()) SWIG_fail;
43772 }
43773 {
43774 resultobj = wxPyMake_wxObject(result, (bool)0);
43775 }
43776 {
43777 if (temp3)
43778 delete arg3;
43779 }
43780 {
43781 if (temp4)
43782 delete arg4;
43783 }
43784 return resultobj;
43785 fail:
43786 {
43787 if (temp3)
43788 delete arg3;
43789 }
43790 {
43791 if (temp4)
43792 delete arg4;
43793 }
43794 return NULL;
43795 }
43796
43797
43798 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43799 PyObject *resultobj = 0;
43800 wxMenu *arg1 = (wxMenu *) 0 ;
43801 int arg2 ;
43802 wxString *arg3 = 0 ;
43803 wxString const &arg4_defvalue = wxPyEmptyString ;
43804 wxString *arg4 = (wxString *) &arg4_defvalue ;
43805 wxMenuItem *result = 0 ;
43806 void *argp1 = 0 ;
43807 int res1 = 0 ;
43808 int val2 ;
43809 int ecode2 = 0 ;
43810 bool temp3 = false ;
43811 bool temp4 = false ;
43812 PyObject * obj0 = 0 ;
43813 PyObject * obj1 = 0 ;
43814 PyObject * obj2 = 0 ;
43815 PyObject * obj3 = 0 ;
43816 char * kwnames[] = {
43817 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43818 };
43819
43820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43822 if (!SWIG_IsOK(res1)) {
43823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43824 }
43825 arg1 = reinterpret_cast< wxMenu * >(argp1);
43826 ecode2 = SWIG_AsVal_int(obj1, &val2);
43827 if (!SWIG_IsOK(ecode2)) {
43828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
43829 }
43830 arg2 = static_cast< int >(val2);
43831 {
43832 arg3 = wxString_in_helper(obj2);
43833 if (arg3 == NULL) SWIG_fail;
43834 temp3 = true;
43835 }
43836 if (obj3) {
43837 {
43838 arg4 = wxString_in_helper(obj3);
43839 if (arg4 == NULL) SWIG_fail;
43840 temp4 = true;
43841 }
43842 }
43843 {
43844 PyThreadState* __tstate = wxPyBeginAllowThreads();
43845 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43846 wxPyEndAllowThreads(__tstate);
43847 if (PyErr_Occurred()) SWIG_fail;
43848 }
43849 {
43850 resultobj = wxPyMake_wxObject(result, (bool)0);
43851 }
43852 {
43853 if (temp3)
43854 delete arg3;
43855 }
43856 {
43857 if (temp4)
43858 delete arg4;
43859 }
43860 return resultobj;
43861 fail:
43862 {
43863 if (temp3)
43864 delete arg3;
43865 }
43866 {
43867 if (temp4)
43868 delete arg4;
43869 }
43870 return NULL;
43871 }
43872
43873
43874 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43875 PyObject *resultobj = 0;
43876 wxMenu *arg1 = (wxMenu *) 0 ;
43877 int arg2 ;
43878 wxString *arg3 = 0 ;
43879 wxMenu *arg4 = (wxMenu *) 0 ;
43880 wxString const &arg5_defvalue = wxPyEmptyString ;
43881 wxString *arg5 = (wxString *) &arg5_defvalue ;
43882 wxMenuItem *result = 0 ;
43883 void *argp1 = 0 ;
43884 int res1 = 0 ;
43885 int val2 ;
43886 int ecode2 = 0 ;
43887 bool temp3 = false ;
43888 void *argp4 = 0 ;
43889 int res4 = 0 ;
43890 bool temp5 = false ;
43891 PyObject * obj0 = 0 ;
43892 PyObject * obj1 = 0 ;
43893 PyObject * obj2 = 0 ;
43894 PyObject * obj3 = 0 ;
43895 PyObject * obj4 = 0 ;
43896 char * kwnames[] = {
43897 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43898 };
43899
43900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43902 if (!SWIG_IsOK(res1)) {
43903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43904 }
43905 arg1 = reinterpret_cast< wxMenu * >(argp1);
43906 ecode2 = SWIG_AsVal_int(obj1, &val2);
43907 if (!SWIG_IsOK(ecode2)) {
43908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43909 }
43910 arg2 = static_cast< int >(val2);
43911 {
43912 arg3 = wxString_in_helper(obj2);
43913 if (arg3 == NULL) SWIG_fail;
43914 temp3 = true;
43915 }
43916 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43917 if (!SWIG_IsOK(res4)) {
43918 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43919 }
43920 arg4 = reinterpret_cast< wxMenu * >(argp4);
43921 if (obj4) {
43922 {
43923 arg5 = wxString_in_helper(obj4);
43924 if (arg5 == NULL) SWIG_fail;
43925 temp5 = true;
43926 }
43927 }
43928 {
43929 PyThreadState* __tstate = wxPyBeginAllowThreads();
43930 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43931 wxPyEndAllowThreads(__tstate);
43932 if (PyErr_Occurred()) SWIG_fail;
43933 }
43934 {
43935 resultobj = wxPyMake_wxObject(result, (bool)0);
43936 }
43937 {
43938 if (temp3)
43939 delete arg3;
43940 }
43941 {
43942 if (temp5)
43943 delete arg5;
43944 }
43945 return resultobj;
43946 fail:
43947 {
43948 if (temp3)
43949 delete arg3;
43950 }
43951 {
43952 if (temp5)
43953 delete arg5;
43954 }
43955 return NULL;
43956 }
43957
43958
43959 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43960 PyObject *resultobj = 0;
43961 wxMenu *arg1 = (wxMenu *) 0 ;
43962 int arg2 ;
43963 wxMenuItem *result = 0 ;
43964 void *argp1 = 0 ;
43965 int res1 = 0 ;
43966 int val2 ;
43967 int ecode2 = 0 ;
43968 PyObject * obj0 = 0 ;
43969 PyObject * obj1 = 0 ;
43970 char * kwnames[] = {
43971 (char *) "self",(char *) "id", NULL
43972 };
43973
43974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43976 if (!SWIG_IsOK(res1)) {
43977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43978 }
43979 arg1 = reinterpret_cast< wxMenu * >(argp1);
43980 ecode2 = SWIG_AsVal_int(obj1, &val2);
43981 if (!SWIG_IsOK(ecode2)) {
43982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43983 }
43984 arg2 = static_cast< int >(val2);
43985 {
43986 PyThreadState* __tstate = wxPyBeginAllowThreads();
43987 result = (wxMenuItem *)(arg1)->Remove(arg2);
43988 wxPyEndAllowThreads(__tstate);
43989 if (PyErr_Occurred()) SWIG_fail;
43990 }
43991 {
43992 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43993 }
43994 return resultobj;
43995 fail:
43996 return NULL;
43997 }
43998
43999
44000 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44001 PyObject *resultobj = 0;
44002 wxMenu *arg1 = (wxMenu *) 0 ;
44003 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
44004 wxMenuItem *result = 0 ;
44005 void *argp1 = 0 ;
44006 int res1 = 0 ;
44007 void *argp2 = 0 ;
44008 int res2 = 0 ;
44009 PyObject * obj0 = 0 ;
44010 PyObject * obj1 = 0 ;
44011 char * kwnames[] = {
44012 (char *) "self",(char *) "item", NULL
44013 };
44014
44015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
44016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44017 if (!SWIG_IsOK(res1)) {
44018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
44019 }
44020 arg1 = reinterpret_cast< wxMenu * >(argp1);
44021 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44022 if (!SWIG_IsOK(res2)) {
44023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
44024 }
44025 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
44026 {
44027 PyThreadState* __tstate = wxPyBeginAllowThreads();
44028 result = (wxMenuItem *)(arg1)->Remove(arg2);
44029 wxPyEndAllowThreads(__tstate);
44030 if (PyErr_Occurred()) SWIG_fail;
44031 }
44032 {
44033 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
44034 }
44035 return resultobj;
44036 fail:
44037 return NULL;
44038 }
44039
44040
44041 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44042 PyObject *resultobj = 0;
44043 wxMenu *arg1 = (wxMenu *) 0 ;
44044 int arg2 ;
44045 bool result;
44046 void *argp1 = 0 ;
44047 int res1 = 0 ;
44048 int val2 ;
44049 int ecode2 = 0 ;
44050 PyObject * obj0 = 0 ;
44051 PyObject * obj1 = 0 ;
44052 char * kwnames[] = {
44053 (char *) "self",(char *) "id", NULL
44054 };
44055
44056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44058 if (!SWIG_IsOK(res1)) {
44059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
44060 }
44061 arg1 = reinterpret_cast< wxMenu * >(argp1);
44062 ecode2 = SWIG_AsVal_int(obj1, &val2);
44063 if (!SWIG_IsOK(ecode2)) {
44064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
44065 }
44066 arg2 = static_cast< int >(val2);
44067 {
44068 PyThreadState* __tstate = wxPyBeginAllowThreads();
44069 result = (bool)(arg1)->Delete(arg2);
44070 wxPyEndAllowThreads(__tstate);
44071 if (PyErr_Occurred()) SWIG_fail;
44072 }
44073 {
44074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44075 }
44076 return resultobj;
44077 fail:
44078 return NULL;
44079 }
44080
44081
44082 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44083 PyObject *resultobj = 0;
44084 wxMenu *arg1 = (wxMenu *) 0 ;
44085 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
44086 bool result;
44087 void *argp1 = 0 ;
44088 int res1 = 0 ;
44089 void *argp2 = 0 ;
44090 int res2 = 0 ;
44091 PyObject * obj0 = 0 ;
44092 PyObject * obj1 = 0 ;
44093 char * kwnames[] = {
44094 (char *) "self",(char *) "item", NULL
44095 };
44096
44097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
44098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44099 if (!SWIG_IsOK(res1)) {
44100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
44101 }
44102 arg1 = reinterpret_cast< wxMenu * >(argp1);
44103 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44104 if (!SWIG_IsOK(res2)) {
44105 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
44106 }
44107 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
44108 {
44109 PyThreadState* __tstate = wxPyBeginAllowThreads();
44110 result = (bool)(arg1)->Delete(arg2);
44111 wxPyEndAllowThreads(__tstate);
44112 if (PyErr_Occurred()) SWIG_fail;
44113 }
44114 {
44115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44116 }
44117 return resultobj;
44118 fail:
44119 return NULL;
44120 }
44121
44122
44123 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44124 PyObject *resultobj = 0;
44125 wxMenu *arg1 = (wxMenu *) 0 ;
44126 void *argp1 = 0 ;
44127 int res1 = 0 ;
44128 PyObject *swig_obj[1] ;
44129
44130 if (!args) SWIG_fail;
44131 swig_obj[0] = args;
44132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44133 if (!SWIG_IsOK(res1)) {
44134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
44135 }
44136 arg1 = reinterpret_cast< wxMenu * >(argp1);
44137 {
44138 PyThreadState* __tstate = wxPyBeginAllowThreads();
44139 wxMenu_Destroy(arg1);
44140 wxPyEndAllowThreads(__tstate);
44141 if (PyErr_Occurred()) SWIG_fail;
44142 }
44143 resultobj = SWIG_Py_Void();
44144 return resultobj;
44145 fail:
44146 return NULL;
44147 }
44148
44149
44150 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44151 PyObject *resultobj = 0;
44152 wxMenu *arg1 = (wxMenu *) 0 ;
44153 int arg2 ;
44154 bool result;
44155 void *argp1 = 0 ;
44156 int res1 = 0 ;
44157 int val2 ;
44158 int ecode2 = 0 ;
44159 PyObject * obj0 = 0 ;
44160 PyObject * obj1 = 0 ;
44161 char * kwnames[] = {
44162 (char *) "self",(char *) "id", NULL
44163 };
44164
44165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
44166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44167 if (!SWIG_IsOK(res1)) {
44168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
44169 }
44170 arg1 = reinterpret_cast< wxMenu * >(argp1);
44171 ecode2 = SWIG_AsVal_int(obj1, &val2);
44172 if (!SWIG_IsOK(ecode2)) {
44173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
44174 }
44175 arg2 = static_cast< int >(val2);
44176 {
44177 PyThreadState* __tstate = wxPyBeginAllowThreads();
44178 result = (bool)(arg1)->Destroy(arg2);
44179 wxPyEndAllowThreads(__tstate);
44180 if (PyErr_Occurred()) SWIG_fail;
44181 }
44182 {
44183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44184 }
44185 return resultobj;
44186 fail:
44187 return NULL;
44188 }
44189
44190
44191 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44192 PyObject *resultobj = 0;
44193 wxMenu *arg1 = (wxMenu *) 0 ;
44194 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
44195 bool result;
44196 void *argp1 = 0 ;
44197 int res1 = 0 ;
44198 void *argp2 = 0 ;
44199 int res2 = 0 ;
44200 PyObject * obj0 = 0 ;
44201 PyObject * obj1 = 0 ;
44202 char * kwnames[] = {
44203 (char *) "self",(char *) "item", NULL
44204 };
44205
44206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
44207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44208 if (!SWIG_IsOK(res1)) {
44209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
44210 }
44211 arg1 = reinterpret_cast< wxMenu * >(argp1);
44212 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44213 if (!SWIG_IsOK(res2)) {
44214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
44215 }
44216 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
44217 {
44218 PyThreadState* __tstate = wxPyBeginAllowThreads();
44219 result = (bool)(arg1)->Destroy(arg2);
44220 wxPyEndAllowThreads(__tstate);
44221 if (PyErr_Occurred()) SWIG_fail;
44222 }
44223 {
44224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44225 }
44226 return resultobj;
44227 fail:
44228 return NULL;
44229 }
44230
44231
44232 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44233 PyObject *resultobj = 0;
44234 wxMenu *arg1 = (wxMenu *) 0 ;
44235 size_t result;
44236 void *argp1 = 0 ;
44237 int res1 = 0 ;
44238 PyObject *swig_obj[1] ;
44239
44240 if (!args) SWIG_fail;
44241 swig_obj[0] = args;
44242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44243 if (!SWIG_IsOK(res1)) {
44244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
44245 }
44246 arg1 = reinterpret_cast< wxMenu * >(argp1);
44247 {
44248 PyThreadState* __tstate = wxPyBeginAllowThreads();
44249 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
44250 wxPyEndAllowThreads(__tstate);
44251 if (PyErr_Occurred()) SWIG_fail;
44252 }
44253 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44254 return resultobj;
44255 fail:
44256 return NULL;
44257 }
44258
44259
44260 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44261 PyObject *resultobj = 0;
44262 wxMenu *arg1 = (wxMenu *) 0 ;
44263 PyObject *result = 0 ;
44264 void *argp1 = 0 ;
44265 int res1 = 0 ;
44266 PyObject *swig_obj[1] ;
44267
44268 if (!args) SWIG_fail;
44269 swig_obj[0] = args;
44270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44271 if (!SWIG_IsOK(res1)) {
44272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
44273 }
44274 arg1 = reinterpret_cast< wxMenu * >(argp1);
44275 {
44276 PyThreadState* __tstate = wxPyBeginAllowThreads();
44277 result = (PyObject *)wxMenu_GetMenuItems(arg1);
44278 wxPyEndAllowThreads(__tstate);
44279 if (PyErr_Occurred()) SWIG_fail;
44280 }
44281 resultobj = result;
44282 return resultobj;
44283 fail:
44284 return NULL;
44285 }
44286
44287
44288 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44289 PyObject *resultobj = 0;
44290 wxMenu *arg1 = (wxMenu *) 0 ;
44291 wxString *arg2 = 0 ;
44292 int result;
44293 void *argp1 = 0 ;
44294 int res1 = 0 ;
44295 bool temp2 = false ;
44296 PyObject * obj0 = 0 ;
44297 PyObject * obj1 = 0 ;
44298 char * kwnames[] = {
44299 (char *) "self",(char *) "item", NULL
44300 };
44301
44302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
44303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44304 if (!SWIG_IsOK(res1)) {
44305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
44306 }
44307 arg1 = reinterpret_cast< wxMenu * >(argp1);
44308 {
44309 arg2 = wxString_in_helper(obj1);
44310 if (arg2 == NULL) SWIG_fail;
44311 temp2 = true;
44312 }
44313 {
44314 PyThreadState* __tstate = wxPyBeginAllowThreads();
44315 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
44316 wxPyEndAllowThreads(__tstate);
44317 if (PyErr_Occurred()) SWIG_fail;
44318 }
44319 resultobj = SWIG_From_int(static_cast< int >(result));
44320 {
44321 if (temp2)
44322 delete arg2;
44323 }
44324 return resultobj;
44325 fail:
44326 {
44327 if (temp2)
44328 delete arg2;
44329 }
44330 return NULL;
44331 }
44332
44333
44334 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44335 PyObject *resultobj = 0;
44336 wxMenu *arg1 = (wxMenu *) 0 ;
44337 int arg2 ;
44338 wxMenuItem *result = 0 ;
44339 void *argp1 = 0 ;
44340 int res1 = 0 ;
44341 int val2 ;
44342 int ecode2 = 0 ;
44343 PyObject * obj0 = 0 ;
44344 PyObject * obj1 = 0 ;
44345 char * kwnames[] = {
44346 (char *) "self",(char *) "id", NULL
44347 };
44348
44349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44351 if (!SWIG_IsOK(res1)) {
44352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
44353 }
44354 arg1 = reinterpret_cast< wxMenu * >(argp1);
44355 ecode2 = SWIG_AsVal_int(obj1, &val2);
44356 if (!SWIG_IsOK(ecode2)) {
44357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
44358 }
44359 arg2 = static_cast< int >(val2);
44360 {
44361 PyThreadState* __tstate = wxPyBeginAllowThreads();
44362 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
44363 wxPyEndAllowThreads(__tstate);
44364 if (PyErr_Occurred()) SWIG_fail;
44365 }
44366 {
44367 resultobj = wxPyMake_wxObject(result, (bool)0);
44368 }
44369 return resultobj;
44370 fail:
44371 return NULL;
44372 }
44373
44374
44375 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44376 PyObject *resultobj = 0;
44377 wxMenu *arg1 = (wxMenu *) 0 ;
44378 size_t arg2 ;
44379 wxMenuItem *result = 0 ;
44380 void *argp1 = 0 ;
44381 int res1 = 0 ;
44382 size_t val2 ;
44383 int ecode2 = 0 ;
44384 PyObject * obj0 = 0 ;
44385 PyObject * obj1 = 0 ;
44386 char * kwnames[] = {
44387 (char *) "self",(char *) "position", NULL
44388 };
44389
44390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
44391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44392 if (!SWIG_IsOK(res1)) {
44393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
44394 }
44395 arg1 = reinterpret_cast< wxMenu * >(argp1);
44396 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44397 if (!SWIG_IsOK(ecode2)) {
44398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
44399 }
44400 arg2 = static_cast< size_t >(val2);
44401 {
44402 PyThreadState* __tstate = wxPyBeginAllowThreads();
44403 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
44404 wxPyEndAllowThreads(__tstate);
44405 if (PyErr_Occurred()) SWIG_fail;
44406 }
44407 {
44408 resultobj = wxPyMake_wxObject(result, (bool)0);
44409 }
44410 return resultobj;
44411 fail:
44412 return NULL;
44413 }
44414
44415
44416 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44417 PyObject *resultobj = 0;
44418 wxMenu *arg1 = (wxMenu *) 0 ;
44419 int arg2 ;
44420 bool arg3 ;
44421 void *argp1 = 0 ;
44422 int res1 = 0 ;
44423 int val2 ;
44424 int ecode2 = 0 ;
44425 bool val3 ;
44426 int ecode3 = 0 ;
44427 PyObject * obj0 = 0 ;
44428 PyObject * obj1 = 0 ;
44429 PyObject * obj2 = 0 ;
44430 char * kwnames[] = {
44431 (char *) "self",(char *) "id",(char *) "enable", NULL
44432 };
44433
44434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44436 if (!SWIG_IsOK(res1)) {
44437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
44438 }
44439 arg1 = reinterpret_cast< wxMenu * >(argp1);
44440 ecode2 = SWIG_AsVal_int(obj1, &val2);
44441 if (!SWIG_IsOK(ecode2)) {
44442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
44443 }
44444 arg2 = static_cast< int >(val2);
44445 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44446 if (!SWIG_IsOK(ecode3)) {
44447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
44448 }
44449 arg3 = static_cast< bool >(val3);
44450 {
44451 PyThreadState* __tstate = wxPyBeginAllowThreads();
44452 (arg1)->Enable(arg2,arg3);
44453 wxPyEndAllowThreads(__tstate);
44454 if (PyErr_Occurred()) SWIG_fail;
44455 }
44456 resultobj = SWIG_Py_Void();
44457 return resultobj;
44458 fail:
44459 return NULL;
44460 }
44461
44462
44463 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44464 PyObject *resultobj = 0;
44465 wxMenu *arg1 = (wxMenu *) 0 ;
44466 int arg2 ;
44467 bool result;
44468 void *argp1 = 0 ;
44469 int res1 = 0 ;
44470 int val2 ;
44471 int ecode2 = 0 ;
44472 PyObject * obj0 = 0 ;
44473 PyObject * obj1 = 0 ;
44474 char * kwnames[] = {
44475 (char *) "self",(char *) "id", NULL
44476 };
44477
44478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
44479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44480 if (!SWIG_IsOK(res1)) {
44481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
44482 }
44483 arg1 = reinterpret_cast< wxMenu * >(argp1);
44484 ecode2 = SWIG_AsVal_int(obj1, &val2);
44485 if (!SWIG_IsOK(ecode2)) {
44486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
44487 }
44488 arg2 = static_cast< int >(val2);
44489 {
44490 PyThreadState* __tstate = wxPyBeginAllowThreads();
44491 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
44492 wxPyEndAllowThreads(__tstate);
44493 if (PyErr_Occurred()) SWIG_fail;
44494 }
44495 {
44496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44497 }
44498 return resultobj;
44499 fail:
44500 return NULL;
44501 }
44502
44503
44504 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44505 PyObject *resultobj = 0;
44506 wxMenu *arg1 = (wxMenu *) 0 ;
44507 int arg2 ;
44508 bool arg3 ;
44509 void *argp1 = 0 ;
44510 int res1 = 0 ;
44511 int val2 ;
44512 int ecode2 = 0 ;
44513 bool val3 ;
44514 int ecode3 = 0 ;
44515 PyObject * obj0 = 0 ;
44516 PyObject * obj1 = 0 ;
44517 PyObject * obj2 = 0 ;
44518 char * kwnames[] = {
44519 (char *) "self",(char *) "id",(char *) "check", NULL
44520 };
44521
44522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44524 if (!SWIG_IsOK(res1)) {
44525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
44526 }
44527 arg1 = reinterpret_cast< wxMenu * >(argp1);
44528 ecode2 = SWIG_AsVal_int(obj1, &val2);
44529 if (!SWIG_IsOK(ecode2)) {
44530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
44531 }
44532 arg2 = static_cast< int >(val2);
44533 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44534 if (!SWIG_IsOK(ecode3)) {
44535 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
44536 }
44537 arg3 = static_cast< bool >(val3);
44538 {
44539 PyThreadState* __tstate = wxPyBeginAllowThreads();
44540 (arg1)->Check(arg2,arg3);
44541 wxPyEndAllowThreads(__tstate);
44542 if (PyErr_Occurred()) SWIG_fail;
44543 }
44544 resultobj = SWIG_Py_Void();
44545 return resultobj;
44546 fail:
44547 return NULL;
44548 }
44549
44550
44551 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44552 PyObject *resultobj = 0;
44553 wxMenu *arg1 = (wxMenu *) 0 ;
44554 int arg2 ;
44555 bool result;
44556 void *argp1 = 0 ;
44557 int res1 = 0 ;
44558 int val2 ;
44559 int ecode2 = 0 ;
44560 PyObject * obj0 = 0 ;
44561 PyObject * obj1 = 0 ;
44562 char * kwnames[] = {
44563 (char *) "self",(char *) "id", NULL
44564 };
44565
44566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
44567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44568 if (!SWIG_IsOK(res1)) {
44569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
44570 }
44571 arg1 = reinterpret_cast< wxMenu * >(argp1);
44572 ecode2 = SWIG_AsVal_int(obj1, &val2);
44573 if (!SWIG_IsOK(ecode2)) {
44574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
44575 }
44576 arg2 = static_cast< int >(val2);
44577 {
44578 PyThreadState* __tstate = wxPyBeginAllowThreads();
44579 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
44580 wxPyEndAllowThreads(__tstate);
44581 if (PyErr_Occurred()) SWIG_fail;
44582 }
44583 {
44584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44585 }
44586 return resultobj;
44587 fail:
44588 return NULL;
44589 }
44590
44591
44592 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44593 PyObject *resultobj = 0;
44594 wxMenu *arg1 = (wxMenu *) 0 ;
44595 int arg2 ;
44596 wxString *arg3 = 0 ;
44597 void *argp1 = 0 ;
44598 int res1 = 0 ;
44599 int val2 ;
44600 int ecode2 = 0 ;
44601 bool temp3 = false ;
44602 PyObject * obj0 = 0 ;
44603 PyObject * obj1 = 0 ;
44604 PyObject * obj2 = 0 ;
44605 char * kwnames[] = {
44606 (char *) "self",(char *) "id",(char *) "label", NULL
44607 };
44608
44609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44611 if (!SWIG_IsOK(res1)) {
44612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
44613 }
44614 arg1 = reinterpret_cast< wxMenu * >(argp1);
44615 ecode2 = SWIG_AsVal_int(obj1, &val2);
44616 if (!SWIG_IsOK(ecode2)) {
44617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
44618 }
44619 arg2 = static_cast< int >(val2);
44620 {
44621 arg3 = wxString_in_helper(obj2);
44622 if (arg3 == NULL) SWIG_fail;
44623 temp3 = true;
44624 }
44625 {
44626 PyThreadState* __tstate = wxPyBeginAllowThreads();
44627 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
44628 wxPyEndAllowThreads(__tstate);
44629 if (PyErr_Occurred()) SWIG_fail;
44630 }
44631 resultobj = SWIG_Py_Void();
44632 {
44633 if (temp3)
44634 delete arg3;
44635 }
44636 return resultobj;
44637 fail:
44638 {
44639 if (temp3)
44640 delete arg3;
44641 }
44642 return NULL;
44643 }
44644
44645
44646 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44647 PyObject *resultobj = 0;
44648 wxMenu *arg1 = (wxMenu *) 0 ;
44649 int arg2 ;
44650 wxString result;
44651 void *argp1 = 0 ;
44652 int res1 = 0 ;
44653 int val2 ;
44654 int ecode2 = 0 ;
44655 PyObject * obj0 = 0 ;
44656 PyObject * obj1 = 0 ;
44657 char * kwnames[] = {
44658 (char *) "self",(char *) "id", NULL
44659 };
44660
44661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
44662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44663 if (!SWIG_IsOK(res1)) {
44664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
44665 }
44666 arg1 = reinterpret_cast< wxMenu * >(argp1);
44667 ecode2 = SWIG_AsVal_int(obj1, &val2);
44668 if (!SWIG_IsOK(ecode2)) {
44669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
44670 }
44671 arg2 = static_cast< int >(val2);
44672 {
44673 PyThreadState* __tstate = wxPyBeginAllowThreads();
44674 result = ((wxMenu const *)arg1)->GetLabel(arg2);
44675 wxPyEndAllowThreads(__tstate);
44676 if (PyErr_Occurred()) SWIG_fail;
44677 }
44678 {
44679 #if wxUSE_UNICODE
44680 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44681 #else
44682 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44683 #endif
44684 }
44685 return resultobj;
44686 fail:
44687 return NULL;
44688 }
44689
44690
44691 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44692 PyObject *resultobj = 0;
44693 wxMenu *arg1 = (wxMenu *) 0 ;
44694 int arg2 ;
44695 wxString *arg3 = 0 ;
44696 void *argp1 = 0 ;
44697 int res1 = 0 ;
44698 int val2 ;
44699 int ecode2 = 0 ;
44700 bool temp3 = false ;
44701 PyObject * obj0 = 0 ;
44702 PyObject * obj1 = 0 ;
44703 PyObject * obj2 = 0 ;
44704 char * kwnames[] = {
44705 (char *) "self",(char *) "id",(char *) "helpString", NULL
44706 };
44707
44708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44710 if (!SWIG_IsOK(res1)) {
44711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
44712 }
44713 arg1 = reinterpret_cast< wxMenu * >(argp1);
44714 ecode2 = SWIG_AsVal_int(obj1, &val2);
44715 if (!SWIG_IsOK(ecode2)) {
44716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
44717 }
44718 arg2 = static_cast< int >(val2);
44719 {
44720 arg3 = wxString_in_helper(obj2);
44721 if (arg3 == NULL) SWIG_fail;
44722 temp3 = true;
44723 }
44724 {
44725 PyThreadState* __tstate = wxPyBeginAllowThreads();
44726 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
44727 wxPyEndAllowThreads(__tstate);
44728 if (PyErr_Occurred()) SWIG_fail;
44729 }
44730 resultobj = SWIG_Py_Void();
44731 {
44732 if (temp3)
44733 delete arg3;
44734 }
44735 return resultobj;
44736 fail:
44737 {
44738 if (temp3)
44739 delete arg3;
44740 }
44741 return NULL;
44742 }
44743
44744
44745 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44746 PyObject *resultobj = 0;
44747 wxMenu *arg1 = (wxMenu *) 0 ;
44748 int arg2 ;
44749 wxString result;
44750 void *argp1 = 0 ;
44751 int res1 = 0 ;
44752 int val2 ;
44753 int ecode2 = 0 ;
44754 PyObject * obj0 = 0 ;
44755 PyObject * obj1 = 0 ;
44756 char * kwnames[] = {
44757 (char *) "self",(char *) "id", NULL
44758 };
44759
44760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
44761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44762 if (!SWIG_IsOK(res1)) {
44763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
44764 }
44765 arg1 = reinterpret_cast< wxMenu * >(argp1);
44766 ecode2 = SWIG_AsVal_int(obj1, &val2);
44767 if (!SWIG_IsOK(ecode2)) {
44768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
44769 }
44770 arg2 = static_cast< int >(val2);
44771 {
44772 PyThreadState* __tstate = wxPyBeginAllowThreads();
44773 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
44774 wxPyEndAllowThreads(__tstate);
44775 if (PyErr_Occurred()) SWIG_fail;
44776 }
44777 {
44778 #if wxUSE_UNICODE
44779 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44780 #else
44781 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44782 #endif
44783 }
44784 return resultobj;
44785 fail:
44786 return NULL;
44787 }
44788
44789
44790 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44791 PyObject *resultobj = 0;
44792 wxMenu *arg1 = (wxMenu *) 0 ;
44793 wxString *arg2 = 0 ;
44794 void *argp1 = 0 ;
44795 int res1 = 0 ;
44796 bool temp2 = false ;
44797 PyObject * obj0 = 0 ;
44798 PyObject * obj1 = 0 ;
44799 char * kwnames[] = {
44800 (char *) "self",(char *) "title", NULL
44801 };
44802
44803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
44804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44805 if (!SWIG_IsOK(res1)) {
44806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
44807 }
44808 arg1 = reinterpret_cast< wxMenu * >(argp1);
44809 {
44810 arg2 = wxString_in_helper(obj1);
44811 if (arg2 == NULL) SWIG_fail;
44812 temp2 = true;
44813 }
44814 {
44815 PyThreadState* __tstate = wxPyBeginAllowThreads();
44816 (arg1)->SetTitle((wxString const &)*arg2);
44817 wxPyEndAllowThreads(__tstate);
44818 if (PyErr_Occurred()) SWIG_fail;
44819 }
44820 resultobj = SWIG_Py_Void();
44821 {
44822 if (temp2)
44823 delete arg2;
44824 }
44825 return resultobj;
44826 fail:
44827 {
44828 if (temp2)
44829 delete arg2;
44830 }
44831 return NULL;
44832 }
44833
44834
44835 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44836 PyObject *resultobj = 0;
44837 wxMenu *arg1 = (wxMenu *) 0 ;
44838 wxString result;
44839 void *argp1 = 0 ;
44840 int res1 = 0 ;
44841 PyObject *swig_obj[1] ;
44842
44843 if (!args) SWIG_fail;
44844 swig_obj[0] = args;
44845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44846 if (!SWIG_IsOK(res1)) {
44847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44848 }
44849 arg1 = reinterpret_cast< wxMenu * >(argp1);
44850 {
44851 PyThreadState* __tstate = wxPyBeginAllowThreads();
44852 result = ((wxMenu const *)arg1)->GetTitle();
44853 wxPyEndAllowThreads(__tstate);
44854 if (PyErr_Occurred()) SWIG_fail;
44855 }
44856 {
44857 #if wxUSE_UNICODE
44858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44859 #else
44860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44861 #endif
44862 }
44863 return resultobj;
44864 fail:
44865 return NULL;
44866 }
44867
44868
44869 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44870 PyObject *resultobj = 0;
44871 wxMenu *arg1 = (wxMenu *) 0 ;
44872 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44873 void *argp1 = 0 ;
44874 int res1 = 0 ;
44875 void *argp2 = 0 ;
44876 int res2 = 0 ;
44877 PyObject * obj0 = 0 ;
44878 PyObject * obj1 = 0 ;
44879 char * kwnames[] = {
44880 (char *) "self",(char *) "handler", NULL
44881 };
44882
44883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44885 if (!SWIG_IsOK(res1)) {
44886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44887 }
44888 arg1 = reinterpret_cast< wxMenu * >(argp1);
44889 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44890 if (!SWIG_IsOK(res2)) {
44891 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44892 }
44893 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44894 {
44895 PyThreadState* __tstate = wxPyBeginAllowThreads();
44896 (arg1)->SetEventHandler(arg2);
44897 wxPyEndAllowThreads(__tstate);
44898 if (PyErr_Occurred()) SWIG_fail;
44899 }
44900 resultobj = SWIG_Py_Void();
44901 return resultobj;
44902 fail:
44903 return NULL;
44904 }
44905
44906
44907 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44908 PyObject *resultobj = 0;
44909 wxMenu *arg1 = (wxMenu *) 0 ;
44910 wxEvtHandler *result = 0 ;
44911 void *argp1 = 0 ;
44912 int res1 = 0 ;
44913 PyObject *swig_obj[1] ;
44914
44915 if (!args) SWIG_fail;
44916 swig_obj[0] = args;
44917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44918 if (!SWIG_IsOK(res1)) {
44919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44920 }
44921 arg1 = reinterpret_cast< wxMenu * >(argp1);
44922 {
44923 PyThreadState* __tstate = wxPyBeginAllowThreads();
44924 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44925 wxPyEndAllowThreads(__tstate);
44926 if (PyErr_Occurred()) SWIG_fail;
44927 }
44928 {
44929 resultobj = wxPyMake_wxObject(result, 0);
44930 }
44931 return resultobj;
44932 fail:
44933 return NULL;
44934 }
44935
44936
44937 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44938 PyObject *resultobj = 0;
44939 wxMenu *arg1 = (wxMenu *) 0 ;
44940 wxWindow *arg2 = (wxWindow *) 0 ;
44941 void *argp1 = 0 ;
44942 int res1 = 0 ;
44943 void *argp2 = 0 ;
44944 int res2 = 0 ;
44945 PyObject * obj0 = 0 ;
44946 PyObject * obj1 = 0 ;
44947 char * kwnames[] = {
44948 (char *) "self",(char *) "win", NULL
44949 };
44950
44951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44953 if (!SWIG_IsOK(res1)) {
44954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44955 }
44956 arg1 = reinterpret_cast< wxMenu * >(argp1);
44957 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44958 if (!SWIG_IsOK(res2)) {
44959 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44960 }
44961 arg2 = reinterpret_cast< wxWindow * >(argp2);
44962 {
44963 PyThreadState* __tstate = wxPyBeginAllowThreads();
44964 (arg1)->SetInvokingWindow(arg2);
44965 wxPyEndAllowThreads(__tstate);
44966 if (PyErr_Occurred()) SWIG_fail;
44967 }
44968 resultobj = SWIG_Py_Void();
44969 return resultobj;
44970 fail:
44971 return NULL;
44972 }
44973
44974
44975 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44976 PyObject *resultobj = 0;
44977 wxMenu *arg1 = (wxMenu *) 0 ;
44978 wxWindow *result = 0 ;
44979 void *argp1 = 0 ;
44980 int res1 = 0 ;
44981 PyObject *swig_obj[1] ;
44982
44983 if (!args) SWIG_fail;
44984 swig_obj[0] = args;
44985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44986 if (!SWIG_IsOK(res1)) {
44987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44988 }
44989 arg1 = reinterpret_cast< wxMenu * >(argp1);
44990 {
44991 PyThreadState* __tstate = wxPyBeginAllowThreads();
44992 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44993 wxPyEndAllowThreads(__tstate);
44994 if (PyErr_Occurred()) SWIG_fail;
44995 }
44996 {
44997 resultobj = wxPyMake_wxObject(result, 0);
44998 }
44999 return resultobj;
45000 fail:
45001 return NULL;
45002 }
45003
45004
45005 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45006 PyObject *resultobj = 0;
45007 wxMenu *arg1 = (wxMenu *) 0 ;
45008 long result;
45009 void *argp1 = 0 ;
45010 int res1 = 0 ;
45011 PyObject *swig_obj[1] ;
45012
45013 if (!args) SWIG_fail;
45014 swig_obj[0] = args;
45015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45016 if (!SWIG_IsOK(res1)) {
45017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
45018 }
45019 arg1 = reinterpret_cast< wxMenu * >(argp1);
45020 {
45021 PyThreadState* __tstate = wxPyBeginAllowThreads();
45022 result = (long)((wxMenu const *)arg1)->GetStyle();
45023 wxPyEndAllowThreads(__tstate);
45024 if (PyErr_Occurred()) SWIG_fail;
45025 }
45026 resultobj = SWIG_From_long(static_cast< long >(result));
45027 return resultobj;
45028 fail:
45029 return NULL;
45030 }
45031
45032
45033 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45034 PyObject *resultobj = 0;
45035 wxMenu *arg1 = (wxMenu *) 0 ;
45036 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
45037 void *argp1 = 0 ;
45038 int res1 = 0 ;
45039 void *argp2 = 0 ;
45040 int res2 = 0 ;
45041 PyObject * obj0 = 0 ;
45042 PyObject * obj1 = 0 ;
45043 char * kwnames[] = {
45044 (char *) "self",(char *) "source", NULL
45045 };
45046
45047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
45048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45049 if (!SWIG_IsOK(res1)) {
45050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
45051 }
45052 arg1 = reinterpret_cast< wxMenu * >(argp1);
45053 if (obj1) {
45054 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
45055 if (!SWIG_IsOK(res2)) {
45056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
45057 }
45058 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
45059 }
45060 {
45061 PyThreadState* __tstate = wxPyBeginAllowThreads();
45062 (arg1)->UpdateUI(arg2);
45063 wxPyEndAllowThreads(__tstate);
45064 if (PyErr_Occurred()) SWIG_fail;
45065 }
45066 resultobj = SWIG_Py_Void();
45067 return resultobj;
45068 fail:
45069 return NULL;
45070 }
45071
45072
45073 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45074 PyObject *resultobj = 0;
45075 wxMenu *arg1 = (wxMenu *) 0 ;
45076 wxMenuBar *result = 0 ;
45077 void *argp1 = 0 ;
45078 int res1 = 0 ;
45079 PyObject *swig_obj[1] ;
45080
45081 if (!args) SWIG_fail;
45082 swig_obj[0] = args;
45083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45084 if (!SWIG_IsOK(res1)) {
45085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
45086 }
45087 arg1 = reinterpret_cast< wxMenu * >(argp1);
45088 {
45089 PyThreadState* __tstate = wxPyBeginAllowThreads();
45090 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
45091 wxPyEndAllowThreads(__tstate);
45092 if (PyErr_Occurred()) SWIG_fail;
45093 }
45094 {
45095 resultobj = wxPyMake_wxObject(result, (bool)0);
45096 }
45097 return resultobj;
45098 fail:
45099 return NULL;
45100 }
45101
45102
45103 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45104 PyObject *resultobj = 0;
45105 wxMenu *arg1 = (wxMenu *) 0 ;
45106 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
45107 void *argp1 = 0 ;
45108 int res1 = 0 ;
45109 void *argp2 = 0 ;
45110 int res2 = 0 ;
45111 PyObject * obj0 = 0 ;
45112 PyObject * obj1 = 0 ;
45113 char * kwnames[] = {
45114 (char *) "self",(char *) "menubar", NULL
45115 };
45116
45117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45119 if (!SWIG_IsOK(res1)) {
45120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
45121 }
45122 arg1 = reinterpret_cast< wxMenu * >(argp1);
45123 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
45124 if (!SWIG_IsOK(res2)) {
45125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
45126 }
45127 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
45128 {
45129 PyThreadState* __tstate = wxPyBeginAllowThreads();
45130 (arg1)->Attach(arg2);
45131 wxPyEndAllowThreads(__tstate);
45132 if (PyErr_Occurred()) SWIG_fail;
45133 }
45134 resultobj = SWIG_Py_Void();
45135 return resultobj;
45136 fail:
45137 return NULL;
45138 }
45139
45140
45141 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45142 PyObject *resultobj = 0;
45143 wxMenu *arg1 = (wxMenu *) 0 ;
45144 void *argp1 = 0 ;
45145 int res1 = 0 ;
45146 PyObject *swig_obj[1] ;
45147
45148 if (!args) SWIG_fail;
45149 swig_obj[0] = args;
45150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45151 if (!SWIG_IsOK(res1)) {
45152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
45153 }
45154 arg1 = reinterpret_cast< wxMenu * >(argp1);
45155 {
45156 PyThreadState* __tstate = wxPyBeginAllowThreads();
45157 (arg1)->Detach();
45158 wxPyEndAllowThreads(__tstate);
45159 if (PyErr_Occurred()) SWIG_fail;
45160 }
45161 resultobj = SWIG_Py_Void();
45162 return resultobj;
45163 fail:
45164 return NULL;
45165 }
45166
45167
45168 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45169 PyObject *resultobj = 0;
45170 wxMenu *arg1 = (wxMenu *) 0 ;
45171 bool result;
45172 void *argp1 = 0 ;
45173 int res1 = 0 ;
45174 PyObject *swig_obj[1] ;
45175
45176 if (!args) SWIG_fail;
45177 swig_obj[0] = args;
45178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45179 if (!SWIG_IsOK(res1)) {
45180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
45181 }
45182 arg1 = reinterpret_cast< wxMenu * >(argp1);
45183 {
45184 PyThreadState* __tstate = wxPyBeginAllowThreads();
45185 result = (bool)((wxMenu const *)arg1)->IsAttached();
45186 wxPyEndAllowThreads(__tstate);
45187 if (PyErr_Occurred()) SWIG_fail;
45188 }
45189 {
45190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45191 }
45192 return resultobj;
45193 fail:
45194 return NULL;
45195 }
45196
45197
45198 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45199 PyObject *resultobj = 0;
45200 wxMenu *arg1 = (wxMenu *) 0 ;
45201 wxMenu *arg2 = (wxMenu *) 0 ;
45202 void *argp1 = 0 ;
45203 int res1 = 0 ;
45204 void *argp2 = 0 ;
45205 int res2 = 0 ;
45206 PyObject * obj0 = 0 ;
45207 PyObject * obj1 = 0 ;
45208 char * kwnames[] = {
45209 (char *) "self",(char *) "parent", NULL
45210 };
45211
45212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
45213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45214 if (!SWIG_IsOK(res1)) {
45215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
45216 }
45217 arg1 = reinterpret_cast< wxMenu * >(argp1);
45218 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45219 if (!SWIG_IsOK(res2)) {
45220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
45221 }
45222 arg2 = reinterpret_cast< wxMenu * >(argp2);
45223 {
45224 PyThreadState* __tstate = wxPyBeginAllowThreads();
45225 (arg1)->SetParent(arg2);
45226 wxPyEndAllowThreads(__tstate);
45227 if (PyErr_Occurred()) SWIG_fail;
45228 }
45229 resultobj = SWIG_Py_Void();
45230 return resultobj;
45231 fail:
45232 return NULL;
45233 }
45234
45235
45236 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45237 PyObject *resultobj = 0;
45238 wxMenu *arg1 = (wxMenu *) 0 ;
45239 wxMenu *result = 0 ;
45240 void *argp1 = 0 ;
45241 int res1 = 0 ;
45242 PyObject *swig_obj[1] ;
45243
45244 if (!args) SWIG_fail;
45245 swig_obj[0] = args;
45246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45247 if (!SWIG_IsOK(res1)) {
45248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
45249 }
45250 arg1 = reinterpret_cast< wxMenu * >(argp1);
45251 {
45252 PyThreadState* __tstate = wxPyBeginAllowThreads();
45253 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
45254 wxPyEndAllowThreads(__tstate);
45255 if (PyErr_Occurred()) SWIG_fail;
45256 }
45257 {
45258 resultobj = wxPyMake_wxObject(result, 0);
45259 }
45260 return resultobj;
45261 fail:
45262 return NULL;
45263 }
45264
45265
45266 SWIGINTERN PyObject *Menu_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_wxMenu, SWIG_NewClientData(obj));
45270 return SWIG_Py_Void();
45271 }
45272
45273 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45274 return SWIG_Python_InitShadowInstance(args);
45275 }
45276
45277 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45278 PyObject *resultobj = 0;
45279 long arg1 = (long) 0 ;
45280 wxMenuBar *result = 0 ;
45281 long val1 ;
45282 int ecode1 = 0 ;
45283 PyObject * obj0 = 0 ;
45284 char * kwnames[] = {
45285 (char *) "style", NULL
45286 };
45287
45288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
45289 if (obj0) {
45290 ecode1 = SWIG_AsVal_long(obj0, &val1);
45291 if (!SWIG_IsOK(ecode1)) {
45292 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
45293 }
45294 arg1 = static_cast< long >(val1);
45295 }
45296 {
45297 if (!wxPyCheckForApp()) SWIG_fail;
45298 PyThreadState* __tstate = wxPyBeginAllowThreads();
45299 result = (wxMenuBar *)new wxMenuBar(arg1);
45300 wxPyEndAllowThreads(__tstate);
45301 if (PyErr_Occurred()) SWIG_fail;
45302 }
45303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
45304 return resultobj;
45305 fail:
45306 return NULL;
45307 }
45308
45309
45310 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45311 PyObject *resultobj = 0;
45312 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45313 wxMenu *arg2 = (wxMenu *) 0 ;
45314 wxString *arg3 = 0 ;
45315 bool result;
45316 void *argp1 = 0 ;
45317 int res1 = 0 ;
45318 void *argp2 = 0 ;
45319 int res2 = 0 ;
45320 bool temp3 = false ;
45321 PyObject * obj0 = 0 ;
45322 PyObject * obj1 = 0 ;
45323 PyObject * obj2 = 0 ;
45324 char * kwnames[] = {
45325 (char *) "self",(char *) "menu",(char *) "title", NULL
45326 };
45327
45328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45330 if (!SWIG_IsOK(res1)) {
45331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45332 }
45333 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45334 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45335 if (!SWIG_IsOK(res2)) {
45336 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
45337 }
45338 arg2 = reinterpret_cast< wxMenu * >(argp2);
45339 {
45340 arg3 = wxString_in_helper(obj2);
45341 if (arg3 == NULL) SWIG_fail;
45342 temp3 = true;
45343 }
45344 {
45345 PyThreadState* __tstate = wxPyBeginAllowThreads();
45346 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
45347 wxPyEndAllowThreads(__tstate);
45348 if (PyErr_Occurred()) SWIG_fail;
45349 }
45350 {
45351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45352 }
45353 {
45354 if (temp3)
45355 delete arg3;
45356 }
45357 return resultobj;
45358 fail:
45359 {
45360 if (temp3)
45361 delete arg3;
45362 }
45363 return NULL;
45364 }
45365
45366
45367 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45368 PyObject *resultobj = 0;
45369 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45370 size_t arg2 ;
45371 wxMenu *arg3 = (wxMenu *) 0 ;
45372 wxString *arg4 = 0 ;
45373 bool result;
45374 void *argp1 = 0 ;
45375 int res1 = 0 ;
45376 size_t val2 ;
45377 int ecode2 = 0 ;
45378 void *argp3 = 0 ;
45379 int res3 = 0 ;
45380 bool temp4 = false ;
45381 PyObject * obj0 = 0 ;
45382 PyObject * obj1 = 0 ;
45383 PyObject * obj2 = 0 ;
45384 PyObject * obj3 = 0 ;
45385 char * kwnames[] = {
45386 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
45387 };
45388
45389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45391 if (!SWIG_IsOK(res1)) {
45392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45393 }
45394 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45395 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45396 if (!SWIG_IsOK(ecode2)) {
45397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
45398 }
45399 arg2 = static_cast< size_t >(val2);
45400 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
45401 if (!SWIG_IsOK(res3)) {
45402 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
45403 }
45404 arg3 = reinterpret_cast< wxMenu * >(argp3);
45405 {
45406 arg4 = wxString_in_helper(obj3);
45407 if (arg4 == NULL) SWIG_fail;
45408 temp4 = true;
45409 }
45410 {
45411 PyThreadState* __tstate = wxPyBeginAllowThreads();
45412 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
45413 wxPyEndAllowThreads(__tstate);
45414 if (PyErr_Occurred()) SWIG_fail;
45415 }
45416 {
45417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45418 }
45419 {
45420 if (temp4)
45421 delete arg4;
45422 }
45423 return resultobj;
45424 fail:
45425 {
45426 if (temp4)
45427 delete arg4;
45428 }
45429 return NULL;
45430 }
45431
45432
45433 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45434 PyObject *resultobj = 0;
45435 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45436 size_t result;
45437 void *argp1 = 0 ;
45438 int res1 = 0 ;
45439 PyObject *swig_obj[1] ;
45440
45441 if (!args) SWIG_fail;
45442 swig_obj[0] = args;
45443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45444 if (!SWIG_IsOK(res1)) {
45445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45446 }
45447 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45448 {
45449 PyThreadState* __tstate = wxPyBeginAllowThreads();
45450 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
45451 wxPyEndAllowThreads(__tstate);
45452 if (PyErr_Occurred()) SWIG_fail;
45453 }
45454 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
45455 return resultobj;
45456 fail:
45457 return NULL;
45458 }
45459
45460
45461 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45462 PyObject *resultobj = 0;
45463 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45464 size_t arg2 ;
45465 wxMenu *result = 0 ;
45466 void *argp1 = 0 ;
45467 int res1 = 0 ;
45468 size_t val2 ;
45469 int ecode2 = 0 ;
45470 PyObject * obj0 = 0 ;
45471 PyObject * obj1 = 0 ;
45472 char * kwnames[] = {
45473 (char *) "self",(char *) "pos", NULL
45474 };
45475
45476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45478 if (!SWIG_IsOK(res1)) {
45479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45480 }
45481 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45482 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45483 if (!SWIG_IsOK(ecode2)) {
45484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
45485 }
45486 arg2 = static_cast< size_t >(val2);
45487 {
45488 PyThreadState* __tstate = wxPyBeginAllowThreads();
45489 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
45490 wxPyEndAllowThreads(__tstate);
45491 if (PyErr_Occurred()) SWIG_fail;
45492 }
45493 {
45494 resultobj = wxPyMake_wxObject(result, 0);
45495 }
45496 return resultobj;
45497 fail:
45498 return NULL;
45499 }
45500
45501
45502 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45503 PyObject *resultobj = 0;
45504 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45505 size_t arg2 ;
45506 wxMenu *arg3 = (wxMenu *) 0 ;
45507 wxString *arg4 = 0 ;
45508 wxMenu *result = 0 ;
45509 void *argp1 = 0 ;
45510 int res1 = 0 ;
45511 size_t val2 ;
45512 int ecode2 = 0 ;
45513 void *argp3 = 0 ;
45514 int res3 = 0 ;
45515 bool temp4 = false ;
45516 PyObject * obj0 = 0 ;
45517 PyObject * obj1 = 0 ;
45518 PyObject * obj2 = 0 ;
45519 PyObject * obj3 = 0 ;
45520 char * kwnames[] = {
45521 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
45522 };
45523
45524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45526 if (!SWIG_IsOK(res1)) {
45527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45528 }
45529 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45530 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45531 if (!SWIG_IsOK(ecode2)) {
45532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
45533 }
45534 arg2 = static_cast< size_t >(val2);
45535 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
45536 if (!SWIG_IsOK(res3)) {
45537 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
45538 }
45539 arg3 = reinterpret_cast< wxMenu * >(argp3);
45540 {
45541 arg4 = wxString_in_helper(obj3);
45542 if (arg4 == NULL) SWIG_fail;
45543 temp4 = true;
45544 }
45545 {
45546 PyThreadState* __tstate = wxPyBeginAllowThreads();
45547 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
45548 wxPyEndAllowThreads(__tstate);
45549 if (PyErr_Occurred()) SWIG_fail;
45550 }
45551 {
45552 resultobj = wxPyMake_wxObject(result, 0);
45553 }
45554 {
45555 if (temp4)
45556 delete arg4;
45557 }
45558 return resultobj;
45559 fail:
45560 {
45561 if (temp4)
45562 delete arg4;
45563 }
45564 return NULL;
45565 }
45566
45567
45568 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45569 PyObject *resultobj = 0;
45570 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45571 size_t arg2 ;
45572 wxMenu *result = 0 ;
45573 void *argp1 = 0 ;
45574 int res1 = 0 ;
45575 size_t val2 ;
45576 int ecode2 = 0 ;
45577 PyObject * obj0 = 0 ;
45578 PyObject * obj1 = 0 ;
45579 char * kwnames[] = {
45580 (char *) "self",(char *) "pos", NULL
45581 };
45582
45583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
45584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45585 if (!SWIG_IsOK(res1)) {
45586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45587 }
45588 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45589 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45590 if (!SWIG_IsOK(ecode2)) {
45591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
45592 }
45593 arg2 = static_cast< size_t >(val2);
45594 {
45595 PyThreadState* __tstate = wxPyBeginAllowThreads();
45596 result = (wxMenu *)(arg1)->Remove(arg2);
45597 wxPyEndAllowThreads(__tstate);
45598 if (PyErr_Occurred()) SWIG_fail;
45599 }
45600 {
45601 resultobj = wxPyMake_wxObject(result, 0);
45602 }
45603 return resultobj;
45604 fail:
45605 return NULL;
45606 }
45607
45608
45609 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45610 PyObject *resultobj = 0;
45611 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45612 size_t arg2 ;
45613 bool arg3 ;
45614 void *argp1 = 0 ;
45615 int res1 = 0 ;
45616 size_t val2 ;
45617 int ecode2 = 0 ;
45618 bool val3 ;
45619 int ecode3 = 0 ;
45620 PyObject * obj0 = 0 ;
45621 PyObject * obj1 = 0 ;
45622 PyObject * obj2 = 0 ;
45623 char * kwnames[] = {
45624 (char *) "self",(char *) "pos",(char *) "enable", NULL
45625 };
45626
45627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45629 if (!SWIG_IsOK(res1)) {
45630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45631 }
45632 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45633 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45634 if (!SWIG_IsOK(ecode2)) {
45635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
45636 }
45637 arg2 = static_cast< size_t >(val2);
45638 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45639 if (!SWIG_IsOK(ecode3)) {
45640 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
45641 }
45642 arg3 = static_cast< bool >(val3);
45643 {
45644 PyThreadState* __tstate = wxPyBeginAllowThreads();
45645 (arg1)->EnableTop(arg2,arg3);
45646 wxPyEndAllowThreads(__tstate);
45647 if (PyErr_Occurred()) SWIG_fail;
45648 }
45649 resultobj = SWIG_Py_Void();
45650 return resultobj;
45651 fail:
45652 return NULL;
45653 }
45654
45655
45656 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45657 PyObject *resultobj = 0;
45658 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45659 size_t arg2 ;
45660 bool result;
45661 void *argp1 = 0 ;
45662 int res1 = 0 ;
45663 size_t val2 ;
45664 int ecode2 = 0 ;
45665 PyObject * obj0 = 0 ;
45666 PyObject * obj1 = 0 ;
45667 char * kwnames[] = {
45668 (char *) "self",(char *) "pos", NULL
45669 };
45670
45671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
45672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45673 if (!SWIG_IsOK(res1)) {
45674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45675 }
45676 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45677 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45678 if (!SWIG_IsOK(ecode2)) {
45679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
45680 }
45681 arg2 = static_cast< size_t >(val2);
45682 {
45683 PyThreadState* __tstate = wxPyBeginAllowThreads();
45684 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
45685 wxPyEndAllowThreads(__tstate);
45686 if (PyErr_Occurred()) SWIG_fail;
45687 }
45688 {
45689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45690 }
45691 return resultobj;
45692 fail:
45693 return NULL;
45694 }
45695
45696
45697 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45698 PyObject *resultobj = 0;
45699 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45700 size_t arg2 ;
45701 wxString *arg3 = 0 ;
45702 void *argp1 = 0 ;
45703 int res1 = 0 ;
45704 size_t val2 ;
45705 int ecode2 = 0 ;
45706 bool temp3 = false ;
45707 PyObject * obj0 = 0 ;
45708 PyObject * obj1 = 0 ;
45709 PyObject * obj2 = 0 ;
45710 char * kwnames[] = {
45711 (char *) "self",(char *) "pos",(char *) "label", NULL
45712 };
45713
45714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45716 if (!SWIG_IsOK(res1)) {
45717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45718 }
45719 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45720 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45721 if (!SWIG_IsOK(ecode2)) {
45722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45723 }
45724 arg2 = static_cast< size_t >(val2);
45725 {
45726 arg3 = wxString_in_helper(obj2);
45727 if (arg3 == NULL) SWIG_fail;
45728 temp3 = true;
45729 }
45730 {
45731 PyThreadState* __tstate = wxPyBeginAllowThreads();
45732 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
45733 wxPyEndAllowThreads(__tstate);
45734 if (PyErr_Occurred()) SWIG_fail;
45735 }
45736 resultobj = SWIG_Py_Void();
45737 {
45738 if (temp3)
45739 delete arg3;
45740 }
45741 return resultobj;
45742 fail:
45743 {
45744 if (temp3)
45745 delete arg3;
45746 }
45747 return NULL;
45748 }
45749
45750
45751 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45752 PyObject *resultobj = 0;
45753 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45754 size_t arg2 ;
45755 wxString result;
45756 void *argp1 = 0 ;
45757 int res1 = 0 ;
45758 size_t val2 ;
45759 int ecode2 = 0 ;
45760 PyObject * obj0 = 0 ;
45761 PyObject * obj1 = 0 ;
45762 char * kwnames[] = {
45763 (char *) "self",(char *) "pos", NULL
45764 };
45765
45766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
45767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45768 if (!SWIG_IsOK(res1)) {
45769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45770 }
45771 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45772 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45773 if (!SWIG_IsOK(ecode2)) {
45774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45775 }
45776 arg2 = static_cast< size_t >(val2);
45777 {
45778 PyThreadState* __tstate = wxPyBeginAllowThreads();
45779 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
45780 wxPyEndAllowThreads(__tstate);
45781 if (PyErr_Occurred()) SWIG_fail;
45782 }
45783 {
45784 #if wxUSE_UNICODE
45785 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45786 #else
45787 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45788 #endif
45789 }
45790 return resultobj;
45791 fail:
45792 return NULL;
45793 }
45794
45795
45796 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45797 PyObject *resultobj = 0;
45798 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45799 wxString *arg2 = 0 ;
45800 wxString *arg3 = 0 ;
45801 int result;
45802 void *argp1 = 0 ;
45803 int res1 = 0 ;
45804 bool temp2 = false ;
45805 bool temp3 = false ;
45806 PyObject * obj0 = 0 ;
45807 PyObject * obj1 = 0 ;
45808 PyObject * obj2 = 0 ;
45809 char * kwnames[] = {
45810 (char *) "self",(char *) "menu",(char *) "item", NULL
45811 };
45812
45813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45815 if (!SWIG_IsOK(res1)) {
45816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45817 }
45818 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45819 {
45820 arg2 = wxString_in_helper(obj1);
45821 if (arg2 == NULL) SWIG_fail;
45822 temp2 = true;
45823 }
45824 {
45825 arg3 = wxString_in_helper(obj2);
45826 if (arg3 == NULL) SWIG_fail;
45827 temp3 = true;
45828 }
45829 {
45830 PyThreadState* __tstate = wxPyBeginAllowThreads();
45831 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
45832 wxPyEndAllowThreads(__tstate);
45833 if (PyErr_Occurred()) SWIG_fail;
45834 }
45835 resultobj = SWIG_From_int(static_cast< int >(result));
45836 {
45837 if (temp2)
45838 delete arg2;
45839 }
45840 {
45841 if (temp3)
45842 delete arg3;
45843 }
45844 return resultobj;
45845 fail:
45846 {
45847 if (temp2)
45848 delete arg2;
45849 }
45850 {
45851 if (temp3)
45852 delete arg3;
45853 }
45854 return NULL;
45855 }
45856
45857
45858 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45859 PyObject *resultobj = 0;
45860 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45861 int arg2 ;
45862 wxMenuItem *result = 0 ;
45863 void *argp1 = 0 ;
45864 int res1 = 0 ;
45865 int val2 ;
45866 int ecode2 = 0 ;
45867 PyObject * obj0 = 0 ;
45868 PyObject * obj1 = 0 ;
45869 char * kwnames[] = {
45870 (char *) "self",(char *) "id", NULL
45871 };
45872
45873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45875 if (!SWIG_IsOK(res1)) {
45876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45877 }
45878 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45879 ecode2 = SWIG_AsVal_int(obj1, &val2);
45880 if (!SWIG_IsOK(ecode2)) {
45881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45882 }
45883 arg2 = static_cast< int >(val2);
45884 {
45885 PyThreadState* __tstate = wxPyBeginAllowThreads();
45886 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45887 wxPyEndAllowThreads(__tstate);
45888 if (PyErr_Occurred()) SWIG_fail;
45889 }
45890 {
45891 resultobj = wxPyMake_wxObject(result, (bool)0);
45892 }
45893 return resultobj;
45894 fail:
45895 return NULL;
45896 }
45897
45898
45899 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45900 PyObject *resultobj = 0;
45901 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45902 wxString *arg2 = 0 ;
45903 int result;
45904 void *argp1 = 0 ;
45905 int res1 = 0 ;
45906 bool temp2 = false ;
45907 PyObject * obj0 = 0 ;
45908 PyObject * obj1 = 0 ;
45909 char * kwnames[] = {
45910 (char *) "self",(char *) "title", NULL
45911 };
45912
45913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45915 if (!SWIG_IsOK(res1)) {
45916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45917 }
45918 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45919 {
45920 arg2 = wxString_in_helper(obj1);
45921 if (arg2 == NULL) SWIG_fail;
45922 temp2 = true;
45923 }
45924 {
45925 PyThreadState* __tstate = wxPyBeginAllowThreads();
45926 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45927 wxPyEndAllowThreads(__tstate);
45928 if (PyErr_Occurred()) SWIG_fail;
45929 }
45930 resultobj = SWIG_From_int(static_cast< int >(result));
45931 {
45932 if (temp2)
45933 delete arg2;
45934 }
45935 return resultobj;
45936 fail:
45937 {
45938 if (temp2)
45939 delete arg2;
45940 }
45941 return NULL;
45942 }
45943
45944
45945 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45946 PyObject *resultobj = 0;
45947 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45948 int arg2 ;
45949 bool arg3 ;
45950 void *argp1 = 0 ;
45951 int res1 = 0 ;
45952 int val2 ;
45953 int ecode2 = 0 ;
45954 bool val3 ;
45955 int ecode3 = 0 ;
45956 PyObject * obj0 = 0 ;
45957 PyObject * obj1 = 0 ;
45958 PyObject * obj2 = 0 ;
45959 char * kwnames[] = {
45960 (char *) "self",(char *) "id",(char *) "enable", NULL
45961 };
45962
45963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45965 if (!SWIG_IsOK(res1)) {
45966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45967 }
45968 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45969 ecode2 = SWIG_AsVal_int(obj1, &val2);
45970 if (!SWIG_IsOK(ecode2)) {
45971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45972 }
45973 arg2 = static_cast< int >(val2);
45974 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45975 if (!SWIG_IsOK(ecode3)) {
45976 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45977 }
45978 arg3 = static_cast< bool >(val3);
45979 {
45980 PyThreadState* __tstate = wxPyBeginAllowThreads();
45981 (arg1)->Enable(arg2,arg3);
45982 wxPyEndAllowThreads(__tstate);
45983 if (PyErr_Occurred()) SWIG_fail;
45984 }
45985 resultobj = SWIG_Py_Void();
45986 return resultobj;
45987 fail:
45988 return NULL;
45989 }
45990
45991
45992 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45993 PyObject *resultobj = 0;
45994 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45995 int arg2 ;
45996 bool arg3 ;
45997 void *argp1 = 0 ;
45998 int res1 = 0 ;
45999 int val2 ;
46000 int ecode2 = 0 ;
46001 bool val3 ;
46002 int ecode3 = 0 ;
46003 PyObject * obj0 = 0 ;
46004 PyObject * obj1 = 0 ;
46005 PyObject * obj2 = 0 ;
46006 char * kwnames[] = {
46007 (char *) "self",(char *) "id",(char *) "check", NULL
46008 };
46009
46010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46012 if (!SWIG_IsOK(res1)) {
46013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46014 }
46015 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46016 ecode2 = SWIG_AsVal_int(obj1, &val2);
46017 if (!SWIG_IsOK(ecode2)) {
46018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
46019 }
46020 arg2 = static_cast< int >(val2);
46021 ecode3 = SWIG_AsVal_bool(obj2, &val3);
46022 if (!SWIG_IsOK(ecode3)) {
46023 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
46024 }
46025 arg3 = static_cast< bool >(val3);
46026 {
46027 PyThreadState* __tstate = wxPyBeginAllowThreads();
46028 (arg1)->Check(arg2,arg3);
46029 wxPyEndAllowThreads(__tstate);
46030 if (PyErr_Occurred()) SWIG_fail;
46031 }
46032 resultobj = SWIG_Py_Void();
46033 return resultobj;
46034 fail:
46035 return NULL;
46036 }
46037
46038
46039 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46040 PyObject *resultobj = 0;
46041 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46042 int arg2 ;
46043 bool result;
46044 void *argp1 = 0 ;
46045 int res1 = 0 ;
46046 int val2 ;
46047 int ecode2 = 0 ;
46048 PyObject * obj0 = 0 ;
46049 PyObject * obj1 = 0 ;
46050 char * kwnames[] = {
46051 (char *) "self",(char *) "id", NULL
46052 };
46053
46054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
46055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46056 if (!SWIG_IsOK(res1)) {
46057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46058 }
46059 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46060 ecode2 = SWIG_AsVal_int(obj1, &val2);
46061 if (!SWIG_IsOK(ecode2)) {
46062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
46063 }
46064 arg2 = static_cast< int >(val2);
46065 {
46066 PyThreadState* __tstate = wxPyBeginAllowThreads();
46067 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
46068 wxPyEndAllowThreads(__tstate);
46069 if (PyErr_Occurred()) SWIG_fail;
46070 }
46071 {
46072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46073 }
46074 return resultobj;
46075 fail:
46076 return NULL;
46077 }
46078
46079
46080 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46081 PyObject *resultobj = 0;
46082 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46083 int arg2 ;
46084 bool result;
46085 void *argp1 = 0 ;
46086 int res1 = 0 ;
46087 int val2 ;
46088 int ecode2 = 0 ;
46089 PyObject * obj0 = 0 ;
46090 PyObject * obj1 = 0 ;
46091 char * kwnames[] = {
46092 (char *) "self",(char *) "id", NULL
46093 };
46094
46095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
46096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46097 if (!SWIG_IsOK(res1)) {
46098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46099 }
46100 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46101 ecode2 = SWIG_AsVal_int(obj1, &val2);
46102 if (!SWIG_IsOK(ecode2)) {
46103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
46104 }
46105 arg2 = static_cast< int >(val2);
46106 {
46107 PyThreadState* __tstate = wxPyBeginAllowThreads();
46108 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
46109 wxPyEndAllowThreads(__tstate);
46110 if (PyErr_Occurred()) SWIG_fail;
46111 }
46112 {
46113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46114 }
46115 return resultobj;
46116 fail:
46117 return NULL;
46118 }
46119
46120
46121 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46122 PyObject *resultobj = 0;
46123 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46124 int arg2 ;
46125 wxString *arg3 = 0 ;
46126 void *argp1 = 0 ;
46127 int res1 = 0 ;
46128 int val2 ;
46129 int ecode2 = 0 ;
46130 bool temp3 = false ;
46131 PyObject * obj0 = 0 ;
46132 PyObject * obj1 = 0 ;
46133 PyObject * obj2 = 0 ;
46134 char * kwnames[] = {
46135 (char *) "self",(char *) "id",(char *) "label", NULL
46136 };
46137
46138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46140 if (!SWIG_IsOK(res1)) {
46141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46142 }
46143 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46144 ecode2 = SWIG_AsVal_int(obj1, &val2);
46145 if (!SWIG_IsOK(ecode2)) {
46146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
46147 }
46148 arg2 = static_cast< int >(val2);
46149 {
46150 arg3 = wxString_in_helper(obj2);
46151 if (arg3 == NULL) SWIG_fail;
46152 temp3 = true;
46153 }
46154 {
46155 PyThreadState* __tstate = wxPyBeginAllowThreads();
46156 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
46157 wxPyEndAllowThreads(__tstate);
46158 if (PyErr_Occurred()) SWIG_fail;
46159 }
46160 resultobj = SWIG_Py_Void();
46161 {
46162 if (temp3)
46163 delete arg3;
46164 }
46165 return resultobj;
46166 fail:
46167 {
46168 if (temp3)
46169 delete arg3;
46170 }
46171 return NULL;
46172 }
46173
46174
46175 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46176 PyObject *resultobj = 0;
46177 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46178 int arg2 ;
46179 wxString result;
46180 void *argp1 = 0 ;
46181 int res1 = 0 ;
46182 int val2 ;
46183 int ecode2 = 0 ;
46184 PyObject * obj0 = 0 ;
46185 PyObject * obj1 = 0 ;
46186 char * kwnames[] = {
46187 (char *) "self",(char *) "id", NULL
46188 };
46189
46190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
46191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46192 if (!SWIG_IsOK(res1)) {
46193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46194 }
46195 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46196 ecode2 = SWIG_AsVal_int(obj1, &val2);
46197 if (!SWIG_IsOK(ecode2)) {
46198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
46199 }
46200 arg2 = static_cast< int >(val2);
46201 {
46202 PyThreadState* __tstate = wxPyBeginAllowThreads();
46203 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
46204 wxPyEndAllowThreads(__tstate);
46205 if (PyErr_Occurred()) SWIG_fail;
46206 }
46207 {
46208 #if wxUSE_UNICODE
46209 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46210 #else
46211 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46212 #endif
46213 }
46214 return resultobj;
46215 fail:
46216 return NULL;
46217 }
46218
46219
46220 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46221 PyObject *resultobj = 0;
46222 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46223 int arg2 ;
46224 wxString *arg3 = 0 ;
46225 void *argp1 = 0 ;
46226 int res1 = 0 ;
46227 int val2 ;
46228 int ecode2 = 0 ;
46229 bool temp3 = false ;
46230 PyObject * obj0 = 0 ;
46231 PyObject * obj1 = 0 ;
46232 PyObject * obj2 = 0 ;
46233 char * kwnames[] = {
46234 (char *) "self",(char *) "id",(char *) "helpString", NULL
46235 };
46236
46237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46239 if (!SWIG_IsOK(res1)) {
46240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46241 }
46242 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46243 ecode2 = SWIG_AsVal_int(obj1, &val2);
46244 if (!SWIG_IsOK(ecode2)) {
46245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
46246 }
46247 arg2 = static_cast< int >(val2);
46248 {
46249 arg3 = wxString_in_helper(obj2);
46250 if (arg3 == NULL) SWIG_fail;
46251 temp3 = true;
46252 }
46253 {
46254 PyThreadState* __tstate = wxPyBeginAllowThreads();
46255 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
46256 wxPyEndAllowThreads(__tstate);
46257 if (PyErr_Occurred()) SWIG_fail;
46258 }
46259 resultobj = SWIG_Py_Void();
46260 {
46261 if (temp3)
46262 delete arg3;
46263 }
46264 return resultobj;
46265 fail:
46266 {
46267 if (temp3)
46268 delete arg3;
46269 }
46270 return NULL;
46271 }
46272
46273
46274 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46275 PyObject *resultobj = 0;
46276 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46277 int arg2 ;
46278 wxString result;
46279 void *argp1 = 0 ;
46280 int res1 = 0 ;
46281 int val2 ;
46282 int ecode2 = 0 ;
46283 PyObject * obj0 = 0 ;
46284 PyObject * obj1 = 0 ;
46285 char * kwnames[] = {
46286 (char *) "self",(char *) "id", NULL
46287 };
46288
46289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
46290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46291 if (!SWIG_IsOK(res1)) {
46292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46293 }
46294 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46295 ecode2 = SWIG_AsVal_int(obj1, &val2);
46296 if (!SWIG_IsOK(ecode2)) {
46297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
46298 }
46299 arg2 = static_cast< int >(val2);
46300 {
46301 PyThreadState* __tstate = wxPyBeginAllowThreads();
46302 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
46303 wxPyEndAllowThreads(__tstate);
46304 if (PyErr_Occurred()) SWIG_fail;
46305 }
46306 {
46307 #if wxUSE_UNICODE
46308 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46309 #else
46310 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46311 #endif
46312 }
46313 return resultobj;
46314 fail:
46315 return NULL;
46316 }
46317
46318
46319 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46320 PyObject *resultobj = 0;
46321 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46322 wxFrame *result = 0 ;
46323 void *argp1 = 0 ;
46324 int res1 = 0 ;
46325 PyObject *swig_obj[1] ;
46326
46327 if (!args) SWIG_fail;
46328 swig_obj[0] = args;
46329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46330 if (!SWIG_IsOK(res1)) {
46331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46332 }
46333 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46334 {
46335 PyThreadState* __tstate = wxPyBeginAllowThreads();
46336 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
46337 wxPyEndAllowThreads(__tstate);
46338 if (PyErr_Occurred()) SWIG_fail;
46339 }
46340 {
46341 resultobj = wxPyMake_wxObject(result, (bool)0);
46342 }
46343 return resultobj;
46344 fail:
46345 return NULL;
46346 }
46347
46348
46349 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46350 PyObject *resultobj = 0;
46351 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46352 bool result;
46353 void *argp1 = 0 ;
46354 int res1 = 0 ;
46355 PyObject *swig_obj[1] ;
46356
46357 if (!args) SWIG_fail;
46358 swig_obj[0] = args;
46359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46360 if (!SWIG_IsOK(res1)) {
46361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46362 }
46363 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46364 {
46365 PyThreadState* __tstate = wxPyBeginAllowThreads();
46366 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
46367 wxPyEndAllowThreads(__tstate);
46368 if (PyErr_Occurred()) SWIG_fail;
46369 }
46370 {
46371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46372 }
46373 return resultobj;
46374 fail:
46375 return NULL;
46376 }
46377
46378
46379 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46380 PyObject *resultobj = 0;
46381 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46382 wxFrame *arg2 = (wxFrame *) 0 ;
46383 void *argp1 = 0 ;
46384 int res1 = 0 ;
46385 void *argp2 = 0 ;
46386 int res2 = 0 ;
46387 PyObject * obj0 = 0 ;
46388 PyObject * obj1 = 0 ;
46389 char * kwnames[] = {
46390 (char *) "self",(char *) "frame", NULL
46391 };
46392
46393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
46394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46395 if (!SWIG_IsOK(res1)) {
46396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46397 }
46398 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46399 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
46400 if (!SWIG_IsOK(res2)) {
46401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
46402 }
46403 arg2 = reinterpret_cast< wxFrame * >(argp2);
46404 {
46405 PyThreadState* __tstate = wxPyBeginAllowThreads();
46406 (arg1)->Attach(arg2);
46407 wxPyEndAllowThreads(__tstate);
46408 if (PyErr_Occurred()) SWIG_fail;
46409 }
46410 resultobj = SWIG_Py_Void();
46411 return resultobj;
46412 fail:
46413 return NULL;
46414 }
46415
46416
46417 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46418 PyObject *resultobj = 0;
46419 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46420 void *argp1 = 0 ;
46421 int res1 = 0 ;
46422 PyObject *swig_obj[1] ;
46423
46424 if (!args) SWIG_fail;
46425 swig_obj[0] = args;
46426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46427 if (!SWIG_IsOK(res1)) {
46428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46429 }
46430 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46431 {
46432 PyThreadState* __tstate = wxPyBeginAllowThreads();
46433 (arg1)->Detach();
46434 wxPyEndAllowThreads(__tstate);
46435 if (PyErr_Occurred()) SWIG_fail;
46436 }
46437 resultobj = SWIG_Py_Void();
46438 return resultobj;
46439 fail:
46440 return NULL;
46441 }
46442
46443
46444 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46445 PyObject *resultobj = 0;
46446 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46447 void *argp1 = 0 ;
46448 int res1 = 0 ;
46449 PyObject *swig_obj[1] ;
46450
46451 if (!args) SWIG_fail;
46452 swig_obj[0] = args;
46453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46454 if (!SWIG_IsOK(res1)) {
46455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46456 }
46457 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46458 {
46459 PyThreadState* __tstate = wxPyBeginAllowThreads();
46460 (arg1)->UpdateMenus();
46461 wxPyEndAllowThreads(__tstate);
46462 if (PyErr_Occurred()) SWIG_fail;
46463 }
46464 resultobj = SWIG_Py_Void();
46465 return resultobj;
46466 fail:
46467 return NULL;
46468 }
46469
46470
46471 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46472 PyObject *resultobj = 0;
46473 bool arg1 ;
46474 bool val1 ;
46475 int ecode1 = 0 ;
46476 PyObject * obj0 = 0 ;
46477 char * kwnames[] = {
46478 (char *) "enable", NULL
46479 };
46480
46481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
46482 ecode1 = SWIG_AsVal_bool(obj0, &val1);
46483 if (!SWIG_IsOK(ecode1)) {
46484 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
46485 }
46486 arg1 = static_cast< bool >(val1);
46487 {
46488 PyThreadState* __tstate = wxPyBeginAllowThreads();
46489 wxMenuBar_SetAutoWindowMenu(arg1);
46490 wxPyEndAllowThreads(__tstate);
46491 if (PyErr_Occurred()) SWIG_fail;
46492 }
46493 resultobj = SWIG_Py_Void();
46494 return resultobj;
46495 fail:
46496 return NULL;
46497 }
46498
46499
46500 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46501 PyObject *resultobj = 0;
46502 bool result;
46503
46504 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
46505 {
46506 PyThreadState* __tstate = wxPyBeginAllowThreads();
46507 result = (bool)wxMenuBar_GetAutoWindowMenu();
46508 wxPyEndAllowThreads(__tstate);
46509 if (PyErr_Occurred()) SWIG_fail;
46510 }
46511 {
46512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46513 }
46514 return resultobj;
46515 fail:
46516 return NULL;
46517 }
46518
46519
46520 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46521 PyObject *obj;
46522 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46523 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
46524 return SWIG_Py_Void();
46525 }
46526
46527 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46528 return SWIG_Python_InitShadowInstance(args);
46529 }
46530
46531 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46532 PyObject *resultobj = 0;
46533 wxMenu *arg1 = (wxMenu *) NULL ;
46534 int arg2 = (int) wxID_SEPARATOR ;
46535 wxString const &arg3_defvalue = wxPyEmptyString ;
46536 wxString *arg3 = (wxString *) &arg3_defvalue ;
46537 wxString const &arg4_defvalue = wxPyEmptyString ;
46538 wxString *arg4 = (wxString *) &arg4_defvalue ;
46539 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
46540 wxMenu *arg6 = (wxMenu *) NULL ;
46541 wxMenuItem *result = 0 ;
46542 void *argp1 = 0 ;
46543 int res1 = 0 ;
46544 int val2 ;
46545 int ecode2 = 0 ;
46546 bool temp3 = false ;
46547 bool temp4 = false ;
46548 int val5 ;
46549 int ecode5 = 0 ;
46550 void *argp6 = 0 ;
46551 int res6 = 0 ;
46552 PyObject * obj0 = 0 ;
46553 PyObject * obj1 = 0 ;
46554 PyObject * obj2 = 0 ;
46555 PyObject * obj3 = 0 ;
46556 PyObject * obj4 = 0 ;
46557 PyObject * obj5 = 0 ;
46558 char * kwnames[] = {
46559 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
46560 };
46561
46562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46563 if (obj0) {
46564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
46565 if (!SWIG_IsOK(res1)) {
46566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
46567 }
46568 arg1 = reinterpret_cast< wxMenu * >(argp1);
46569 }
46570 if (obj1) {
46571 ecode2 = SWIG_AsVal_int(obj1, &val2);
46572 if (!SWIG_IsOK(ecode2)) {
46573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
46574 }
46575 arg2 = static_cast< int >(val2);
46576 }
46577 if (obj2) {
46578 {
46579 arg3 = wxString_in_helper(obj2);
46580 if (arg3 == NULL) SWIG_fail;
46581 temp3 = true;
46582 }
46583 }
46584 if (obj3) {
46585 {
46586 arg4 = wxString_in_helper(obj3);
46587 if (arg4 == NULL) SWIG_fail;
46588 temp4 = true;
46589 }
46590 }
46591 if (obj4) {
46592 ecode5 = SWIG_AsVal_int(obj4, &val5);
46593 if (!SWIG_IsOK(ecode5)) {
46594 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
46595 }
46596 arg5 = static_cast< wxItemKind >(val5);
46597 }
46598 if (obj5) {
46599 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
46600 if (!SWIG_IsOK(res6)) {
46601 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
46602 }
46603 arg6 = reinterpret_cast< wxMenu * >(argp6);
46604 }
46605 {
46606 PyThreadState* __tstate = wxPyBeginAllowThreads();
46607 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
46608 wxPyEndAllowThreads(__tstate);
46609 if (PyErr_Occurred()) SWIG_fail;
46610 }
46611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
46612 {
46613 if (temp3)
46614 delete arg3;
46615 }
46616 {
46617 if (temp4)
46618 delete arg4;
46619 }
46620 return resultobj;
46621 fail:
46622 {
46623 if (temp3)
46624 delete arg3;
46625 }
46626 {
46627 if (temp4)
46628 delete arg4;
46629 }
46630 return NULL;
46631 }
46632
46633
46634 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46635 PyObject *resultobj = 0;
46636 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46637 void *argp1 = 0 ;
46638 int res1 = 0 ;
46639 PyObject *swig_obj[1] ;
46640
46641 if (!args) SWIG_fail;
46642 swig_obj[0] = args;
46643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
46644 if (!SWIG_IsOK(res1)) {
46645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46646 }
46647 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46648 {
46649 PyThreadState* __tstate = wxPyBeginAllowThreads();
46650 delete arg1;
46651
46652 wxPyEndAllowThreads(__tstate);
46653 if (PyErr_Occurred()) SWIG_fail;
46654 }
46655 resultobj = SWIG_Py_Void();
46656 return resultobj;
46657 fail:
46658 return NULL;
46659 }
46660
46661
46662 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46663 PyObject *resultobj = 0;
46664 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46665 wxMenu *result = 0 ;
46666 void *argp1 = 0 ;
46667 int res1 = 0 ;
46668 PyObject *swig_obj[1] ;
46669
46670 if (!args) SWIG_fail;
46671 swig_obj[0] = args;
46672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46673 if (!SWIG_IsOK(res1)) {
46674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46675 }
46676 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46677 {
46678 PyThreadState* __tstate = wxPyBeginAllowThreads();
46679 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
46680 wxPyEndAllowThreads(__tstate);
46681 if (PyErr_Occurred()) SWIG_fail;
46682 }
46683 {
46684 resultobj = wxPyMake_wxObject(result, 0);
46685 }
46686 return resultobj;
46687 fail:
46688 return NULL;
46689 }
46690
46691
46692 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46693 PyObject *resultobj = 0;
46694 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46695 wxMenu *arg2 = (wxMenu *) 0 ;
46696 void *argp1 = 0 ;
46697 int res1 = 0 ;
46698 void *argp2 = 0 ;
46699 int res2 = 0 ;
46700 PyObject * obj0 = 0 ;
46701 PyObject * obj1 = 0 ;
46702 char * kwnames[] = {
46703 (char *) "self",(char *) "menu", NULL
46704 };
46705
46706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46708 if (!SWIG_IsOK(res1)) {
46709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46710 }
46711 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46712 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46713 if (!SWIG_IsOK(res2)) {
46714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46715 }
46716 arg2 = reinterpret_cast< wxMenu * >(argp2);
46717 {
46718 PyThreadState* __tstate = wxPyBeginAllowThreads();
46719 (arg1)->SetMenu(arg2);
46720 wxPyEndAllowThreads(__tstate);
46721 if (PyErr_Occurred()) SWIG_fail;
46722 }
46723 resultobj = SWIG_Py_Void();
46724 return resultobj;
46725 fail:
46726 return NULL;
46727 }
46728
46729
46730 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46731 PyObject *resultobj = 0;
46732 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46733 int arg2 ;
46734 void *argp1 = 0 ;
46735 int res1 = 0 ;
46736 int val2 ;
46737 int ecode2 = 0 ;
46738 PyObject * obj0 = 0 ;
46739 PyObject * obj1 = 0 ;
46740 char * kwnames[] = {
46741 (char *) "self",(char *) "id", NULL
46742 };
46743
46744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
46745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46746 if (!SWIG_IsOK(res1)) {
46747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46748 }
46749 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46750 ecode2 = SWIG_AsVal_int(obj1, &val2);
46751 if (!SWIG_IsOK(ecode2)) {
46752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
46753 }
46754 arg2 = static_cast< int >(val2);
46755 {
46756 PyThreadState* __tstate = wxPyBeginAllowThreads();
46757 (arg1)->SetId(arg2);
46758 wxPyEndAllowThreads(__tstate);
46759 if (PyErr_Occurred()) SWIG_fail;
46760 }
46761 resultobj = SWIG_Py_Void();
46762 return resultobj;
46763 fail:
46764 return NULL;
46765 }
46766
46767
46768 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46769 PyObject *resultobj = 0;
46770 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46771 int result;
46772 void *argp1 = 0 ;
46773 int res1 = 0 ;
46774 PyObject *swig_obj[1] ;
46775
46776 if (!args) SWIG_fail;
46777 swig_obj[0] = args;
46778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46779 if (!SWIG_IsOK(res1)) {
46780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46781 }
46782 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46783 {
46784 PyThreadState* __tstate = wxPyBeginAllowThreads();
46785 result = (int)((wxMenuItem const *)arg1)->GetId();
46786 wxPyEndAllowThreads(__tstate);
46787 if (PyErr_Occurred()) SWIG_fail;
46788 }
46789 resultobj = SWIG_From_int(static_cast< int >(result));
46790 return resultobj;
46791 fail:
46792 return NULL;
46793 }
46794
46795
46796 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46797 PyObject *resultobj = 0;
46798 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46799 bool result;
46800 void *argp1 = 0 ;
46801 int res1 = 0 ;
46802 PyObject *swig_obj[1] ;
46803
46804 if (!args) SWIG_fail;
46805 swig_obj[0] = args;
46806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46807 if (!SWIG_IsOK(res1)) {
46808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46809 }
46810 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46811 {
46812 PyThreadState* __tstate = wxPyBeginAllowThreads();
46813 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
46814 wxPyEndAllowThreads(__tstate);
46815 if (PyErr_Occurred()) SWIG_fail;
46816 }
46817 {
46818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46819 }
46820 return resultobj;
46821 fail:
46822 return NULL;
46823 }
46824
46825
46826 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46827 PyObject *resultobj = 0;
46828 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46829 wxString *arg2 = 0 ;
46830 void *argp1 = 0 ;
46831 int res1 = 0 ;
46832 bool temp2 = false ;
46833 PyObject * obj0 = 0 ;
46834 PyObject * obj1 = 0 ;
46835 char * kwnames[] = {
46836 (char *) "self",(char *) "str", NULL
46837 };
46838
46839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
46840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46841 if (!SWIG_IsOK(res1)) {
46842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46843 }
46844 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46845 {
46846 arg2 = wxString_in_helper(obj1);
46847 if (arg2 == NULL) SWIG_fail;
46848 temp2 = true;
46849 }
46850 {
46851 PyThreadState* __tstate = wxPyBeginAllowThreads();
46852 (arg1)->SetText((wxString const &)*arg2);
46853 wxPyEndAllowThreads(__tstate);
46854 if (PyErr_Occurred()) SWIG_fail;
46855 }
46856 resultobj = SWIG_Py_Void();
46857 {
46858 if (temp2)
46859 delete arg2;
46860 }
46861 return resultobj;
46862 fail:
46863 {
46864 if (temp2)
46865 delete arg2;
46866 }
46867 return NULL;
46868 }
46869
46870
46871 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46872 PyObject *resultobj = 0;
46873 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46874 wxString result;
46875 void *argp1 = 0 ;
46876 int res1 = 0 ;
46877 PyObject *swig_obj[1] ;
46878
46879 if (!args) SWIG_fail;
46880 swig_obj[0] = args;
46881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46882 if (!SWIG_IsOK(res1)) {
46883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46884 }
46885 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46886 {
46887 PyThreadState* __tstate = wxPyBeginAllowThreads();
46888 result = ((wxMenuItem const *)arg1)->GetLabel();
46889 wxPyEndAllowThreads(__tstate);
46890 if (PyErr_Occurred()) SWIG_fail;
46891 }
46892 {
46893 #if wxUSE_UNICODE
46894 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46895 #else
46896 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46897 #endif
46898 }
46899 return resultobj;
46900 fail:
46901 return NULL;
46902 }
46903
46904
46905 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46906 PyObject *resultobj = 0;
46907 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46908 wxString *result = 0 ;
46909 void *argp1 = 0 ;
46910 int res1 = 0 ;
46911 PyObject *swig_obj[1] ;
46912
46913 if (!args) SWIG_fail;
46914 swig_obj[0] = args;
46915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46916 if (!SWIG_IsOK(res1)) {
46917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46918 }
46919 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46920 {
46921 PyThreadState* __tstate = wxPyBeginAllowThreads();
46922 {
46923 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46924 result = (wxString *) &_result_ref;
46925 }
46926 wxPyEndAllowThreads(__tstate);
46927 if (PyErr_Occurred()) SWIG_fail;
46928 }
46929 {
46930 #if wxUSE_UNICODE
46931 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46932 #else
46933 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46934 #endif
46935 }
46936 return resultobj;
46937 fail:
46938 return NULL;
46939 }
46940
46941
46942 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46943 PyObject *resultobj = 0;
46944 wxString *arg1 = 0 ;
46945 wxString result;
46946 bool temp1 = false ;
46947 PyObject * obj0 = 0 ;
46948 char * kwnames[] = {
46949 (char *) "text", NULL
46950 };
46951
46952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46953 {
46954 arg1 = wxString_in_helper(obj0);
46955 if (arg1 == NULL) SWIG_fail;
46956 temp1 = true;
46957 }
46958 {
46959 PyThreadState* __tstate = wxPyBeginAllowThreads();
46960 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46961 wxPyEndAllowThreads(__tstate);
46962 if (PyErr_Occurred()) SWIG_fail;
46963 }
46964 {
46965 #if wxUSE_UNICODE
46966 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46967 #else
46968 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46969 #endif
46970 }
46971 {
46972 if (temp1)
46973 delete arg1;
46974 }
46975 return resultobj;
46976 fail:
46977 {
46978 if (temp1)
46979 delete arg1;
46980 }
46981 return NULL;
46982 }
46983
46984
46985 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46986 PyObject *resultobj = 0;
46987 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46988 wxItemKind result;
46989 void *argp1 = 0 ;
46990 int res1 = 0 ;
46991 PyObject *swig_obj[1] ;
46992
46993 if (!args) SWIG_fail;
46994 swig_obj[0] = args;
46995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46996 if (!SWIG_IsOK(res1)) {
46997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46998 }
46999 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47000 {
47001 PyThreadState* __tstate = wxPyBeginAllowThreads();
47002 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
47003 wxPyEndAllowThreads(__tstate);
47004 if (PyErr_Occurred()) SWIG_fail;
47005 }
47006 resultobj = SWIG_From_int(static_cast< int >(result));
47007 return resultobj;
47008 fail:
47009 return NULL;
47010 }
47011
47012
47013 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47014 PyObject *resultobj = 0;
47015 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47016 wxItemKind arg2 ;
47017 void *argp1 = 0 ;
47018 int res1 = 0 ;
47019 int val2 ;
47020 int ecode2 = 0 ;
47021 PyObject * obj0 = 0 ;
47022 PyObject * obj1 = 0 ;
47023 char * kwnames[] = {
47024 (char *) "self",(char *) "kind", NULL
47025 };
47026
47027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
47028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47029 if (!SWIG_IsOK(res1)) {
47030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47031 }
47032 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47033 ecode2 = SWIG_AsVal_int(obj1, &val2);
47034 if (!SWIG_IsOK(ecode2)) {
47035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
47036 }
47037 arg2 = static_cast< wxItemKind >(val2);
47038 {
47039 PyThreadState* __tstate = wxPyBeginAllowThreads();
47040 (arg1)->SetKind(arg2);
47041 wxPyEndAllowThreads(__tstate);
47042 if (PyErr_Occurred()) SWIG_fail;
47043 }
47044 resultobj = SWIG_Py_Void();
47045 return resultobj;
47046 fail:
47047 return NULL;
47048 }
47049
47050
47051 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47052 PyObject *resultobj = 0;
47053 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47054 bool arg2 ;
47055 void *argp1 = 0 ;
47056 int res1 = 0 ;
47057 bool val2 ;
47058 int ecode2 = 0 ;
47059 PyObject * obj0 = 0 ;
47060 PyObject * obj1 = 0 ;
47061 char * kwnames[] = {
47062 (char *) "self",(char *) "checkable", NULL
47063 };
47064
47065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
47066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47067 if (!SWIG_IsOK(res1)) {
47068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47069 }
47070 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47071 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47072 if (!SWIG_IsOK(ecode2)) {
47073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
47074 }
47075 arg2 = static_cast< bool >(val2);
47076 {
47077 PyThreadState* __tstate = wxPyBeginAllowThreads();
47078 (arg1)->SetCheckable(arg2);
47079 wxPyEndAllowThreads(__tstate);
47080 if (PyErr_Occurred()) SWIG_fail;
47081 }
47082 resultobj = SWIG_Py_Void();
47083 return resultobj;
47084 fail:
47085 return NULL;
47086 }
47087
47088
47089 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47090 PyObject *resultobj = 0;
47091 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47092 bool result;
47093 void *argp1 = 0 ;
47094 int res1 = 0 ;
47095 PyObject *swig_obj[1] ;
47096
47097 if (!args) SWIG_fail;
47098 swig_obj[0] = args;
47099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47100 if (!SWIG_IsOK(res1)) {
47101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47102 }
47103 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47104 {
47105 PyThreadState* __tstate = wxPyBeginAllowThreads();
47106 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
47107 wxPyEndAllowThreads(__tstate);
47108 if (PyErr_Occurred()) SWIG_fail;
47109 }
47110 {
47111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47112 }
47113 return resultobj;
47114 fail:
47115 return NULL;
47116 }
47117
47118
47119 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47120 PyObject *resultobj = 0;
47121 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47122 bool result;
47123 void *argp1 = 0 ;
47124 int res1 = 0 ;
47125 PyObject *swig_obj[1] ;
47126
47127 if (!args) SWIG_fail;
47128 swig_obj[0] = args;
47129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47130 if (!SWIG_IsOK(res1)) {
47131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47132 }
47133 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47134 {
47135 PyThreadState* __tstate = wxPyBeginAllowThreads();
47136 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
47137 wxPyEndAllowThreads(__tstate);
47138 if (PyErr_Occurred()) SWIG_fail;
47139 }
47140 {
47141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47142 }
47143 return resultobj;
47144 fail:
47145 return NULL;
47146 }
47147
47148
47149 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47150 PyObject *resultobj = 0;
47151 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47152 wxMenu *arg2 = (wxMenu *) 0 ;
47153 void *argp1 = 0 ;
47154 int res1 = 0 ;
47155 void *argp2 = 0 ;
47156 int res2 = 0 ;
47157 PyObject * obj0 = 0 ;
47158 PyObject * obj1 = 0 ;
47159 char * kwnames[] = {
47160 (char *) "self",(char *) "menu", NULL
47161 };
47162
47163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
47164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47165 if (!SWIG_IsOK(res1)) {
47166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47167 }
47168 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47169 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
47170 if (!SWIG_IsOK(res2)) {
47171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
47172 }
47173 arg2 = reinterpret_cast< wxMenu * >(argp2);
47174 {
47175 PyThreadState* __tstate = wxPyBeginAllowThreads();
47176 (arg1)->SetSubMenu(arg2);
47177 wxPyEndAllowThreads(__tstate);
47178 if (PyErr_Occurred()) SWIG_fail;
47179 }
47180 resultobj = SWIG_Py_Void();
47181 return resultobj;
47182 fail:
47183 return NULL;
47184 }
47185
47186
47187 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47188 PyObject *resultobj = 0;
47189 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47190 wxMenu *result = 0 ;
47191 void *argp1 = 0 ;
47192 int res1 = 0 ;
47193 PyObject *swig_obj[1] ;
47194
47195 if (!args) SWIG_fail;
47196 swig_obj[0] = args;
47197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47198 if (!SWIG_IsOK(res1)) {
47199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47200 }
47201 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47202 {
47203 PyThreadState* __tstate = wxPyBeginAllowThreads();
47204 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
47205 wxPyEndAllowThreads(__tstate);
47206 if (PyErr_Occurred()) SWIG_fail;
47207 }
47208 {
47209 resultobj = wxPyMake_wxObject(result, 0);
47210 }
47211 return resultobj;
47212 fail:
47213 return NULL;
47214 }
47215
47216
47217 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47218 PyObject *resultobj = 0;
47219 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47220 bool arg2 = (bool) true ;
47221 void *argp1 = 0 ;
47222 int res1 = 0 ;
47223 bool val2 ;
47224 int ecode2 = 0 ;
47225 PyObject * obj0 = 0 ;
47226 PyObject * obj1 = 0 ;
47227 char * kwnames[] = {
47228 (char *) "self",(char *) "enable", NULL
47229 };
47230
47231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
47232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47233 if (!SWIG_IsOK(res1)) {
47234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47235 }
47236 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47237 if (obj1) {
47238 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47239 if (!SWIG_IsOK(ecode2)) {
47240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
47241 }
47242 arg2 = static_cast< bool >(val2);
47243 }
47244 {
47245 PyThreadState* __tstate = wxPyBeginAllowThreads();
47246 (arg1)->Enable(arg2);
47247 wxPyEndAllowThreads(__tstate);
47248 if (PyErr_Occurred()) SWIG_fail;
47249 }
47250 resultobj = SWIG_Py_Void();
47251 return resultobj;
47252 fail:
47253 return NULL;
47254 }
47255
47256
47257 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47258 PyObject *resultobj = 0;
47259 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47260 bool result;
47261 void *argp1 = 0 ;
47262 int res1 = 0 ;
47263 PyObject *swig_obj[1] ;
47264
47265 if (!args) SWIG_fail;
47266 swig_obj[0] = args;
47267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47268 if (!SWIG_IsOK(res1)) {
47269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47270 }
47271 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47272 {
47273 PyThreadState* __tstate = wxPyBeginAllowThreads();
47274 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
47275 wxPyEndAllowThreads(__tstate);
47276 if (PyErr_Occurred()) SWIG_fail;
47277 }
47278 {
47279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47280 }
47281 return resultobj;
47282 fail:
47283 return NULL;
47284 }
47285
47286
47287 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47288 PyObject *resultobj = 0;
47289 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47290 bool arg2 = (bool) true ;
47291 void *argp1 = 0 ;
47292 int res1 = 0 ;
47293 bool val2 ;
47294 int ecode2 = 0 ;
47295 PyObject * obj0 = 0 ;
47296 PyObject * obj1 = 0 ;
47297 char * kwnames[] = {
47298 (char *) "self",(char *) "check", NULL
47299 };
47300
47301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
47302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47303 if (!SWIG_IsOK(res1)) {
47304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47305 }
47306 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47307 if (obj1) {
47308 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47309 if (!SWIG_IsOK(ecode2)) {
47310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
47311 }
47312 arg2 = static_cast< bool >(val2);
47313 }
47314 {
47315 PyThreadState* __tstate = wxPyBeginAllowThreads();
47316 (arg1)->Check(arg2);
47317 wxPyEndAllowThreads(__tstate);
47318 if (PyErr_Occurred()) SWIG_fail;
47319 }
47320 resultobj = SWIG_Py_Void();
47321 return resultobj;
47322 fail:
47323 return NULL;
47324 }
47325
47326
47327 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47328 PyObject *resultobj = 0;
47329 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47330 bool result;
47331 void *argp1 = 0 ;
47332 int res1 = 0 ;
47333 PyObject *swig_obj[1] ;
47334
47335 if (!args) SWIG_fail;
47336 swig_obj[0] = args;
47337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47338 if (!SWIG_IsOK(res1)) {
47339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47340 }
47341 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47342 {
47343 PyThreadState* __tstate = wxPyBeginAllowThreads();
47344 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
47345 wxPyEndAllowThreads(__tstate);
47346 if (PyErr_Occurred()) SWIG_fail;
47347 }
47348 {
47349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47350 }
47351 return resultobj;
47352 fail:
47353 return NULL;
47354 }
47355
47356
47357 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47358 PyObject *resultobj = 0;
47359 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47360 void *argp1 = 0 ;
47361 int res1 = 0 ;
47362 PyObject *swig_obj[1] ;
47363
47364 if (!args) SWIG_fail;
47365 swig_obj[0] = args;
47366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47367 if (!SWIG_IsOK(res1)) {
47368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47369 }
47370 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47371 {
47372 PyThreadState* __tstate = wxPyBeginAllowThreads();
47373 (arg1)->Toggle();
47374 wxPyEndAllowThreads(__tstate);
47375 if (PyErr_Occurred()) SWIG_fail;
47376 }
47377 resultobj = SWIG_Py_Void();
47378 return resultobj;
47379 fail:
47380 return NULL;
47381 }
47382
47383
47384 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47385 PyObject *resultobj = 0;
47386 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47387 wxString *arg2 = 0 ;
47388 void *argp1 = 0 ;
47389 int res1 = 0 ;
47390 bool temp2 = false ;
47391 PyObject * obj0 = 0 ;
47392 PyObject * obj1 = 0 ;
47393 char * kwnames[] = {
47394 (char *) "self",(char *) "str", NULL
47395 };
47396
47397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
47398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47399 if (!SWIG_IsOK(res1)) {
47400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47401 }
47402 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47403 {
47404 arg2 = wxString_in_helper(obj1);
47405 if (arg2 == NULL) SWIG_fail;
47406 temp2 = true;
47407 }
47408 {
47409 PyThreadState* __tstate = wxPyBeginAllowThreads();
47410 (arg1)->SetHelp((wxString const &)*arg2);
47411 wxPyEndAllowThreads(__tstate);
47412 if (PyErr_Occurred()) SWIG_fail;
47413 }
47414 resultobj = SWIG_Py_Void();
47415 {
47416 if (temp2)
47417 delete arg2;
47418 }
47419 return resultobj;
47420 fail:
47421 {
47422 if (temp2)
47423 delete arg2;
47424 }
47425 return NULL;
47426 }
47427
47428
47429 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47430 PyObject *resultobj = 0;
47431 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47432 wxString *result = 0 ;
47433 void *argp1 = 0 ;
47434 int res1 = 0 ;
47435 PyObject *swig_obj[1] ;
47436
47437 if (!args) SWIG_fail;
47438 swig_obj[0] = args;
47439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47440 if (!SWIG_IsOK(res1)) {
47441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47442 }
47443 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47444 {
47445 PyThreadState* __tstate = wxPyBeginAllowThreads();
47446 {
47447 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
47448 result = (wxString *) &_result_ref;
47449 }
47450 wxPyEndAllowThreads(__tstate);
47451 if (PyErr_Occurred()) SWIG_fail;
47452 }
47453 {
47454 #if wxUSE_UNICODE
47455 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
47456 #else
47457 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
47458 #endif
47459 }
47460 return resultobj;
47461 fail:
47462 return NULL;
47463 }
47464
47465
47466 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47467 PyObject *resultobj = 0;
47468 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47469 wxAcceleratorEntry *result = 0 ;
47470 void *argp1 = 0 ;
47471 int res1 = 0 ;
47472 PyObject *swig_obj[1] ;
47473
47474 if (!args) SWIG_fail;
47475 swig_obj[0] = args;
47476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47477 if (!SWIG_IsOK(res1)) {
47478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47479 }
47480 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47481 {
47482 PyThreadState* __tstate = wxPyBeginAllowThreads();
47483 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
47484 wxPyEndAllowThreads(__tstate);
47485 if (PyErr_Occurred()) SWIG_fail;
47486 }
47487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
47488 return resultobj;
47489 fail:
47490 return NULL;
47491 }
47492
47493
47494 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47495 PyObject *resultobj = 0;
47496 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47497 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
47498 void *argp1 = 0 ;
47499 int res1 = 0 ;
47500 void *argp2 = 0 ;
47501 int res2 = 0 ;
47502 PyObject * obj0 = 0 ;
47503 PyObject * obj1 = 0 ;
47504 char * kwnames[] = {
47505 (char *) "self",(char *) "accel", NULL
47506 };
47507
47508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
47509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47510 if (!SWIG_IsOK(res1)) {
47511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47512 }
47513 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47514 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
47515 if (!SWIG_IsOK(res2)) {
47516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
47517 }
47518 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
47519 {
47520 PyThreadState* __tstate = wxPyBeginAllowThreads();
47521 (arg1)->SetAccel(arg2);
47522 wxPyEndAllowThreads(__tstate);
47523 if (PyErr_Occurred()) SWIG_fail;
47524 }
47525 resultobj = SWIG_Py_Void();
47526 return resultobj;
47527 fail:
47528 return NULL;
47529 }
47530
47531
47532 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47533 PyObject *resultobj = 0;
47534 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47535 wxBitmap *arg2 = 0 ;
47536 void *argp1 = 0 ;
47537 int res1 = 0 ;
47538 void *argp2 = 0 ;
47539 int res2 = 0 ;
47540 PyObject * obj0 = 0 ;
47541 PyObject * obj1 = 0 ;
47542 char * kwnames[] = {
47543 (char *) "self",(char *) "bitmap", NULL
47544 };
47545
47546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47548 if (!SWIG_IsOK(res1)) {
47549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47550 }
47551 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47552 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47553 if (!SWIG_IsOK(res2)) {
47554 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47555 }
47556 if (!argp2) {
47557 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47558 }
47559 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47560 {
47561 PyThreadState* __tstate = wxPyBeginAllowThreads();
47562 (arg1)->SetBitmap((wxBitmap const &)*arg2);
47563 wxPyEndAllowThreads(__tstate);
47564 if (PyErr_Occurred()) SWIG_fail;
47565 }
47566 resultobj = SWIG_Py_Void();
47567 return resultobj;
47568 fail:
47569 return NULL;
47570 }
47571
47572
47573 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47574 PyObject *resultobj = 0;
47575 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47576 wxBitmap *result = 0 ;
47577 void *argp1 = 0 ;
47578 int res1 = 0 ;
47579 PyObject *swig_obj[1] ;
47580
47581 if (!args) SWIG_fail;
47582 swig_obj[0] = args;
47583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47584 if (!SWIG_IsOK(res1)) {
47585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47586 }
47587 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47588 {
47589 PyThreadState* __tstate = wxPyBeginAllowThreads();
47590 {
47591 wxBitmap const &_result_ref = (arg1)->GetBitmap();
47592 result = (wxBitmap *) &_result_ref;
47593 }
47594 wxPyEndAllowThreads(__tstate);
47595 if (PyErr_Occurred()) SWIG_fail;
47596 }
47597 {
47598 wxBitmap* resultptr = new wxBitmap(*result);
47599 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47600 }
47601 return resultobj;
47602 fail:
47603 return NULL;
47604 }
47605
47606
47607 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47608 PyObject *resultobj = 0;
47609 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47610 wxFont *arg2 = 0 ;
47611 void *argp1 = 0 ;
47612 int res1 = 0 ;
47613 void *argp2 = 0 ;
47614 int res2 = 0 ;
47615 PyObject * obj0 = 0 ;
47616 PyObject * obj1 = 0 ;
47617 char * kwnames[] = {
47618 (char *) "self",(char *) "font", NULL
47619 };
47620
47621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
47622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47623 if (!SWIG_IsOK(res1)) {
47624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47625 }
47626 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47627 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
47628 if (!SWIG_IsOK(res2)) {
47629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47630 }
47631 if (!argp2) {
47632 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47633 }
47634 arg2 = reinterpret_cast< wxFont * >(argp2);
47635 {
47636 PyThreadState* __tstate = wxPyBeginAllowThreads();
47637 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
47638 wxPyEndAllowThreads(__tstate);
47639 if (PyErr_Occurred()) SWIG_fail;
47640 }
47641 resultobj = SWIG_Py_Void();
47642 return resultobj;
47643 fail:
47644 return NULL;
47645 }
47646
47647
47648 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47649 PyObject *resultobj = 0;
47650 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47651 wxFont result;
47652 void *argp1 = 0 ;
47653 int res1 = 0 ;
47654 PyObject *swig_obj[1] ;
47655
47656 if (!args) SWIG_fail;
47657 swig_obj[0] = args;
47658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47659 if (!SWIG_IsOK(res1)) {
47660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47661 }
47662 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47663 {
47664 PyThreadState* __tstate = wxPyBeginAllowThreads();
47665 result = wxMenuItem_GetFont(arg1);
47666 wxPyEndAllowThreads(__tstate);
47667 if (PyErr_Occurred()) SWIG_fail;
47668 }
47669 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
47670 return resultobj;
47671 fail:
47672 return NULL;
47673 }
47674
47675
47676 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47677 PyObject *resultobj = 0;
47678 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47679 wxColour *arg2 = 0 ;
47680 void *argp1 = 0 ;
47681 int res1 = 0 ;
47682 wxColour temp2 ;
47683 PyObject * obj0 = 0 ;
47684 PyObject * obj1 = 0 ;
47685 char * kwnames[] = {
47686 (char *) "self",(char *) "colText", NULL
47687 };
47688
47689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
47690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47691 if (!SWIG_IsOK(res1)) {
47692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47693 }
47694 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47695 {
47696 arg2 = &temp2;
47697 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47698 }
47699 {
47700 PyThreadState* __tstate = wxPyBeginAllowThreads();
47701 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
47702 wxPyEndAllowThreads(__tstate);
47703 if (PyErr_Occurred()) SWIG_fail;
47704 }
47705 resultobj = SWIG_Py_Void();
47706 return resultobj;
47707 fail:
47708 return NULL;
47709 }
47710
47711
47712 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47713 PyObject *resultobj = 0;
47714 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47715 wxColour result;
47716 void *argp1 = 0 ;
47717 int res1 = 0 ;
47718 PyObject *swig_obj[1] ;
47719
47720 if (!args) SWIG_fail;
47721 swig_obj[0] = args;
47722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47723 if (!SWIG_IsOK(res1)) {
47724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47725 }
47726 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47727 {
47728 PyThreadState* __tstate = wxPyBeginAllowThreads();
47729 result = wxMenuItem_GetTextColour(arg1);
47730 wxPyEndAllowThreads(__tstate);
47731 if (PyErr_Occurred()) SWIG_fail;
47732 }
47733 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47734 return resultobj;
47735 fail:
47736 return NULL;
47737 }
47738
47739
47740 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47741 PyObject *resultobj = 0;
47742 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47743 wxColour *arg2 = 0 ;
47744 void *argp1 = 0 ;
47745 int res1 = 0 ;
47746 wxColour temp2 ;
47747 PyObject * obj0 = 0 ;
47748 PyObject * obj1 = 0 ;
47749 char * kwnames[] = {
47750 (char *) "self",(char *) "colBack", NULL
47751 };
47752
47753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
47754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47755 if (!SWIG_IsOK(res1)) {
47756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47757 }
47758 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47759 {
47760 arg2 = &temp2;
47761 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47762 }
47763 {
47764 PyThreadState* __tstate = wxPyBeginAllowThreads();
47765 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
47766 wxPyEndAllowThreads(__tstate);
47767 if (PyErr_Occurred()) SWIG_fail;
47768 }
47769 resultobj = SWIG_Py_Void();
47770 return resultobj;
47771 fail:
47772 return NULL;
47773 }
47774
47775
47776 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47777 PyObject *resultobj = 0;
47778 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47779 wxColour result;
47780 void *argp1 = 0 ;
47781 int res1 = 0 ;
47782 PyObject *swig_obj[1] ;
47783
47784 if (!args) SWIG_fail;
47785 swig_obj[0] = args;
47786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47787 if (!SWIG_IsOK(res1)) {
47788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47789 }
47790 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47791 {
47792 PyThreadState* __tstate = wxPyBeginAllowThreads();
47793 result = wxMenuItem_GetBackgroundColour(arg1);
47794 wxPyEndAllowThreads(__tstate);
47795 if (PyErr_Occurred()) SWIG_fail;
47796 }
47797 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47798 return resultobj;
47799 fail:
47800 return NULL;
47801 }
47802
47803
47804 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47805 PyObject *resultobj = 0;
47806 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47807 wxBitmap *arg2 = 0 ;
47808 wxBitmap const &arg3_defvalue = wxNullBitmap ;
47809 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
47810 void *argp1 = 0 ;
47811 int res1 = 0 ;
47812 void *argp2 = 0 ;
47813 int res2 = 0 ;
47814 void *argp3 = 0 ;
47815 int res3 = 0 ;
47816 PyObject * obj0 = 0 ;
47817 PyObject * obj1 = 0 ;
47818 PyObject * obj2 = 0 ;
47819 char * kwnames[] = {
47820 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
47821 };
47822
47823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47825 if (!SWIG_IsOK(res1)) {
47826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47827 }
47828 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47829 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47830 if (!SWIG_IsOK(res2)) {
47831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47832 }
47833 if (!argp2) {
47834 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47835 }
47836 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47837 if (obj2) {
47838 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
47839 if (!SWIG_IsOK(res3)) {
47840 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47841 }
47842 if (!argp3) {
47843 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47844 }
47845 arg3 = reinterpret_cast< wxBitmap * >(argp3);
47846 }
47847 {
47848 PyThreadState* __tstate = wxPyBeginAllowThreads();
47849 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
47850 wxPyEndAllowThreads(__tstate);
47851 if (PyErr_Occurred()) SWIG_fail;
47852 }
47853 resultobj = SWIG_Py_Void();
47854 return resultobj;
47855 fail:
47856 return NULL;
47857 }
47858
47859
47860 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47861 PyObject *resultobj = 0;
47862 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47863 wxBitmap *arg2 = 0 ;
47864 void *argp1 = 0 ;
47865 int res1 = 0 ;
47866 void *argp2 = 0 ;
47867 int res2 = 0 ;
47868 PyObject * obj0 = 0 ;
47869 PyObject * obj1 = 0 ;
47870 char * kwnames[] = {
47871 (char *) "self",(char *) "bmpDisabled", NULL
47872 };
47873
47874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47876 if (!SWIG_IsOK(res1)) {
47877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47878 }
47879 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47880 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47881 if (!SWIG_IsOK(res2)) {
47882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47883 }
47884 if (!argp2) {
47885 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47886 }
47887 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47888 {
47889 PyThreadState* __tstate = wxPyBeginAllowThreads();
47890 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
47891 wxPyEndAllowThreads(__tstate);
47892 if (PyErr_Occurred()) SWIG_fail;
47893 }
47894 resultobj = SWIG_Py_Void();
47895 return resultobj;
47896 fail:
47897 return NULL;
47898 }
47899
47900
47901 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47902 PyObject *resultobj = 0;
47903 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47904 wxBitmap *result = 0 ;
47905 void *argp1 = 0 ;
47906 int res1 = 0 ;
47907 PyObject *swig_obj[1] ;
47908
47909 if (!args) SWIG_fail;
47910 swig_obj[0] = args;
47911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47912 if (!SWIG_IsOK(res1)) {
47913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47914 }
47915 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47916 {
47917 PyThreadState* __tstate = wxPyBeginAllowThreads();
47918 {
47919 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
47920 result = (wxBitmap *) &_result_ref;
47921 }
47922 wxPyEndAllowThreads(__tstate);
47923 if (PyErr_Occurred()) SWIG_fail;
47924 }
47925 {
47926 wxBitmap* resultptr = new wxBitmap(*result);
47927 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47928 }
47929 return resultobj;
47930 fail:
47931 return NULL;
47932 }
47933
47934
47935 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47936 PyObject *resultobj = 0;
47937 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47938 int arg2 ;
47939 void *argp1 = 0 ;
47940 int res1 = 0 ;
47941 int val2 ;
47942 int ecode2 = 0 ;
47943 PyObject * obj0 = 0 ;
47944 PyObject * obj1 = 0 ;
47945 char * kwnames[] = {
47946 (char *) "self",(char *) "nWidth", NULL
47947 };
47948
47949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47951 if (!SWIG_IsOK(res1)) {
47952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47953 }
47954 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47955 ecode2 = SWIG_AsVal_int(obj1, &val2);
47956 if (!SWIG_IsOK(ecode2)) {
47957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47958 }
47959 arg2 = static_cast< int >(val2);
47960 {
47961 PyThreadState* __tstate = wxPyBeginAllowThreads();
47962 wxMenuItem_SetMarginWidth(arg1,arg2);
47963 wxPyEndAllowThreads(__tstate);
47964 if (PyErr_Occurred()) SWIG_fail;
47965 }
47966 resultobj = SWIG_Py_Void();
47967 return resultobj;
47968 fail:
47969 return NULL;
47970 }
47971
47972
47973 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47974 PyObject *resultobj = 0;
47975 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47976 int result;
47977 void *argp1 = 0 ;
47978 int res1 = 0 ;
47979 PyObject *swig_obj[1] ;
47980
47981 if (!args) SWIG_fail;
47982 swig_obj[0] = args;
47983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47984 if (!SWIG_IsOK(res1)) {
47985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47986 }
47987 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47988 {
47989 PyThreadState* __tstate = wxPyBeginAllowThreads();
47990 result = (int)wxMenuItem_GetMarginWidth(arg1);
47991 wxPyEndAllowThreads(__tstate);
47992 if (PyErr_Occurred()) SWIG_fail;
47993 }
47994 resultobj = SWIG_From_int(static_cast< int >(result));
47995 return resultobj;
47996 fail:
47997 return NULL;
47998 }
47999
48000
48001 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48002 PyObject *resultobj = 0;
48003 int result;
48004
48005 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
48006 {
48007 PyThreadState* __tstate = wxPyBeginAllowThreads();
48008 result = (int)wxMenuItem_GetDefaultMarginWidth();
48009 wxPyEndAllowThreads(__tstate);
48010 if (PyErr_Occurred()) SWIG_fail;
48011 }
48012 resultobj = SWIG_From_int(static_cast< int >(result));
48013 return resultobj;
48014 fail:
48015 return NULL;
48016 }
48017
48018
48019 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48020 PyObject *resultobj = 0;
48021 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
48022 bool result;
48023 void *argp1 = 0 ;
48024 int res1 = 0 ;
48025 PyObject *swig_obj[1] ;
48026
48027 if (!args) SWIG_fail;
48028 swig_obj[0] = args;
48029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
48030 if (!SWIG_IsOK(res1)) {
48031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
48032 }
48033 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
48034 {
48035 PyThreadState* __tstate = wxPyBeginAllowThreads();
48036 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
48037 wxPyEndAllowThreads(__tstate);
48038 if (PyErr_Occurred()) SWIG_fail;
48039 }
48040 {
48041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48042 }
48043 return resultobj;
48044 fail:
48045 return NULL;
48046 }
48047
48048
48049 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48050 PyObject *resultobj = 0;
48051 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
48052 bool arg2 = (bool) true ;
48053 void *argp1 = 0 ;
48054 int res1 = 0 ;
48055 bool val2 ;
48056 int ecode2 = 0 ;
48057 PyObject * obj0 = 0 ;
48058 PyObject * obj1 = 0 ;
48059 char * kwnames[] = {
48060 (char *) "self",(char *) "ownerDrawn", NULL
48061 };
48062
48063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
48064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
48065 if (!SWIG_IsOK(res1)) {
48066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
48067 }
48068 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
48069 if (obj1) {
48070 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48071 if (!SWIG_IsOK(ecode2)) {
48072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
48073 }
48074 arg2 = static_cast< bool >(val2);
48075 }
48076 {
48077 PyThreadState* __tstate = wxPyBeginAllowThreads();
48078 wxMenuItem_SetOwnerDrawn(arg1,arg2);
48079 wxPyEndAllowThreads(__tstate);
48080 if (PyErr_Occurred()) SWIG_fail;
48081 }
48082 resultobj = SWIG_Py_Void();
48083 return resultobj;
48084 fail:
48085 return NULL;
48086 }
48087
48088
48089 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48090 PyObject *resultobj = 0;
48091 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
48092 void *argp1 = 0 ;
48093 int res1 = 0 ;
48094 PyObject *swig_obj[1] ;
48095
48096 if (!args) SWIG_fail;
48097 swig_obj[0] = args;
48098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
48099 if (!SWIG_IsOK(res1)) {
48100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
48101 }
48102 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
48103 {
48104 PyThreadState* __tstate = wxPyBeginAllowThreads();
48105 wxMenuItem_ResetOwnerDrawn(arg1);
48106 wxPyEndAllowThreads(__tstate);
48107 if (PyErr_Occurred()) SWIG_fail;
48108 }
48109 resultobj = SWIG_Py_Void();
48110 return resultobj;
48111 fail:
48112 return NULL;
48113 }
48114
48115
48116 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48117 PyObject *obj;
48118 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48119 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
48120 return SWIG_Py_Void();
48121 }
48122
48123 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48124 return SWIG_Python_InitShadowInstance(args);
48125 }
48126
48127 SWIGINTERN int ControlNameStr_set(PyObject *) {
48128 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
48129 return 1;
48130 }
48131
48132
48133 SWIGINTERN PyObject *ControlNameStr_get(void) {
48134 PyObject *pyobj = 0;
48135
48136 {
48137 #if wxUSE_UNICODE
48138 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
48139 #else
48140 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
48141 #endif
48142 }
48143 return pyobj;
48144 }
48145
48146
48147 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48148 PyObject *resultobj = 0;
48149 wxWindow *arg1 = (wxWindow *) 0 ;
48150 int arg2 = (int) -1 ;
48151 wxPoint const &arg3_defvalue = wxDefaultPosition ;
48152 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
48153 wxSize const &arg4_defvalue = wxDefaultSize ;
48154 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
48155 long arg5 = (long) 0 ;
48156 wxValidator const &arg6_defvalue = wxDefaultValidator ;
48157 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
48158 wxString const &arg7_defvalue = wxPyControlNameStr ;
48159 wxString *arg7 = (wxString *) &arg7_defvalue ;
48160 wxControl *result = 0 ;
48161 void *argp1 = 0 ;
48162 int res1 = 0 ;
48163 int val2 ;
48164 int ecode2 = 0 ;
48165 wxPoint temp3 ;
48166 wxSize temp4 ;
48167 long val5 ;
48168 int ecode5 = 0 ;
48169 void *argp6 = 0 ;
48170 int res6 = 0 ;
48171 bool temp7 = false ;
48172 PyObject * obj0 = 0 ;
48173 PyObject * obj1 = 0 ;
48174 PyObject * obj2 = 0 ;
48175 PyObject * obj3 = 0 ;
48176 PyObject * obj4 = 0 ;
48177 PyObject * obj5 = 0 ;
48178 PyObject * obj6 = 0 ;
48179 char * kwnames[] = {
48180 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
48181 };
48182
48183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
48184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48185 if (!SWIG_IsOK(res1)) {
48186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
48187 }
48188 arg1 = reinterpret_cast< wxWindow * >(argp1);
48189 if (obj1) {
48190 ecode2 = SWIG_AsVal_int(obj1, &val2);
48191 if (!SWIG_IsOK(ecode2)) {
48192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
48193 }
48194 arg2 = static_cast< int >(val2);
48195 }
48196 if (obj2) {
48197 {
48198 arg3 = &temp3;
48199 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
48200 }
48201 }
48202 if (obj3) {
48203 {
48204 arg4 = &temp4;
48205 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
48206 }
48207 }
48208 if (obj4) {
48209 ecode5 = SWIG_AsVal_long(obj4, &val5);
48210 if (!SWIG_IsOK(ecode5)) {
48211 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
48212 }
48213 arg5 = static_cast< long >(val5);
48214 }
48215 if (obj5) {
48216 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
48217 if (!SWIG_IsOK(res6)) {
48218 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
48219 }
48220 if (!argp6) {
48221 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
48222 }
48223 arg6 = reinterpret_cast< wxValidator * >(argp6);
48224 }
48225 if (obj6) {
48226 {
48227 arg7 = wxString_in_helper(obj6);
48228 if (arg7 == NULL) SWIG_fail;
48229 temp7 = true;
48230 }
48231 }
48232 {
48233 if (!wxPyCheckForApp()) SWIG_fail;
48234 PyThreadState* __tstate = wxPyBeginAllowThreads();
48235 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
48236 wxPyEndAllowThreads(__tstate);
48237 if (PyErr_Occurred()) SWIG_fail;
48238 }
48239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
48240 {
48241 if (temp7)
48242 delete arg7;
48243 }
48244 return resultobj;
48245 fail:
48246 {
48247 if (temp7)
48248 delete arg7;
48249 }
48250 return NULL;
48251 }
48252
48253
48254 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48255 PyObject *resultobj = 0;
48256 wxControl *result = 0 ;
48257
48258 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
48259 {
48260 if (!wxPyCheckForApp()) SWIG_fail;
48261 PyThreadState* __tstate = wxPyBeginAllowThreads();
48262 result = (wxControl *)new wxControl();
48263 wxPyEndAllowThreads(__tstate);
48264 if (PyErr_Occurred()) SWIG_fail;
48265 }
48266 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
48267 return resultobj;
48268 fail:
48269 return NULL;
48270 }
48271
48272
48273 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48274 PyObject *resultobj = 0;
48275 wxControl *arg1 = (wxControl *) 0 ;
48276 wxWindow *arg2 = (wxWindow *) 0 ;
48277 int arg3 = (int) -1 ;
48278 wxPoint const &arg4_defvalue = wxDefaultPosition ;
48279 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
48280 wxSize const &arg5_defvalue = wxDefaultSize ;
48281 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
48282 long arg6 = (long) 0 ;
48283 wxValidator const &arg7_defvalue = wxDefaultValidator ;
48284 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
48285 wxString const &arg8_defvalue = wxPyControlNameStr ;
48286 wxString *arg8 = (wxString *) &arg8_defvalue ;
48287 bool result;
48288 void *argp1 = 0 ;
48289 int res1 = 0 ;
48290 void *argp2 = 0 ;
48291 int res2 = 0 ;
48292 int val3 ;
48293 int ecode3 = 0 ;
48294 wxPoint temp4 ;
48295 wxSize temp5 ;
48296 long val6 ;
48297 int ecode6 = 0 ;
48298 void *argp7 = 0 ;
48299 int res7 = 0 ;
48300 bool temp8 = false ;
48301 PyObject * obj0 = 0 ;
48302 PyObject * obj1 = 0 ;
48303 PyObject * obj2 = 0 ;
48304 PyObject * obj3 = 0 ;
48305 PyObject * obj4 = 0 ;
48306 PyObject * obj5 = 0 ;
48307 PyObject * obj6 = 0 ;
48308 PyObject * obj7 = 0 ;
48309 char * kwnames[] = {
48310 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
48311 };
48312
48313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
48314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48315 if (!SWIG_IsOK(res1)) {
48316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
48317 }
48318 arg1 = reinterpret_cast< wxControl * >(argp1);
48319 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48320 if (!SWIG_IsOK(res2)) {
48321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
48322 }
48323 arg2 = reinterpret_cast< wxWindow * >(argp2);
48324 if (obj2) {
48325 ecode3 = SWIG_AsVal_int(obj2, &val3);
48326 if (!SWIG_IsOK(ecode3)) {
48327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
48328 }
48329 arg3 = static_cast< int >(val3);
48330 }
48331 if (obj3) {
48332 {
48333 arg4 = &temp4;
48334 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
48335 }
48336 }
48337 if (obj4) {
48338 {
48339 arg5 = &temp5;
48340 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
48341 }
48342 }
48343 if (obj5) {
48344 ecode6 = SWIG_AsVal_long(obj5, &val6);
48345 if (!SWIG_IsOK(ecode6)) {
48346 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
48347 }
48348 arg6 = static_cast< long >(val6);
48349 }
48350 if (obj6) {
48351 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
48352 if (!SWIG_IsOK(res7)) {
48353 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
48354 }
48355 if (!argp7) {
48356 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
48357 }
48358 arg7 = reinterpret_cast< wxValidator * >(argp7);
48359 }
48360 if (obj7) {
48361 {
48362 arg8 = wxString_in_helper(obj7);
48363 if (arg8 == NULL) SWIG_fail;
48364 temp8 = true;
48365 }
48366 }
48367 {
48368 PyThreadState* __tstate = wxPyBeginAllowThreads();
48369 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
48370 wxPyEndAllowThreads(__tstate);
48371 if (PyErr_Occurred()) SWIG_fail;
48372 }
48373 {
48374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48375 }
48376 {
48377 if (temp8)
48378 delete arg8;
48379 }
48380 return resultobj;
48381 fail:
48382 {
48383 if (temp8)
48384 delete arg8;
48385 }
48386 return NULL;
48387 }
48388
48389
48390 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48391 PyObject *resultobj = 0;
48392 wxControl *arg1 = (wxControl *) 0 ;
48393 int result;
48394 void *argp1 = 0 ;
48395 int res1 = 0 ;
48396 PyObject *swig_obj[1] ;
48397
48398 if (!args) SWIG_fail;
48399 swig_obj[0] = args;
48400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48401 if (!SWIG_IsOK(res1)) {
48402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
48403 }
48404 arg1 = reinterpret_cast< wxControl * >(argp1);
48405 {
48406 PyThreadState* __tstate = wxPyBeginAllowThreads();
48407 result = (int)((wxControl const *)arg1)->GetAlignment();
48408 wxPyEndAllowThreads(__tstate);
48409 if (PyErr_Occurred()) SWIG_fail;
48410 }
48411 resultobj = SWIG_From_int(static_cast< int >(result));
48412 return resultobj;
48413 fail:
48414 return NULL;
48415 }
48416
48417
48418 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48419 PyObject *resultobj = 0;
48420 wxControl *arg1 = (wxControl *) 0 ;
48421 wxString result;
48422 void *argp1 = 0 ;
48423 int res1 = 0 ;
48424 PyObject *swig_obj[1] ;
48425
48426 if (!args) SWIG_fail;
48427 swig_obj[0] = args;
48428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48429 if (!SWIG_IsOK(res1)) {
48430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
48431 }
48432 arg1 = reinterpret_cast< wxControl * >(argp1);
48433 {
48434 PyThreadState* __tstate = wxPyBeginAllowThreads();
48435 result = ((wxControl const *)arg1)->GetLabelText();
48436 wxPyEndAllowThreads(__tstate);
48437 if (PyErr_Occurred()) SWIG_fail;
48438 }
48439 {
48440 #if wxUSE_UNICODE
48441 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48442 #else
48443 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48444 #endif
48445 }
48446 return resultobj;
48447 fail:
48448 return NULL;
48449 }
48450
48451
48452 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48453 PyObject *resultobj = 0;
48454 wxControl *arg1 = (wxControl *) 0 ;
48455 wxCommandEvent *arg2 = 0 ;
48456 void *argp1 = 0 ;
48457 int res1 = 0 ;
48458 void *argp2 = 0 ;
48459 int res2 = 0 ;
48460 PyObject * obj0 = 0 ;
48461 PyObject * obj1 = 0 ;
48462 char * kwnames[] = {
48463 (char *) "self",(char *) "event", NULL
48464 };
48465
48466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
48467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48468 if (!SWIG_IsOK(res1)) {
48469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
48470 }
48471 arg1 = reinterpret_cast< wxControl * >(argp1);
48472 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
48473 if (!SWIG_IsOK(res2)) {
48474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
48475 }
48476 if (!argp2) {
48477 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
48478 }
48479 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
48480 {
48481 PyThreadState* __tstate = wxPyBeginAllowThreads();
48482 (arg1)->Command(*arg2);
48483 wxPyEndAllowThreads(__tstate);
48484 if (PyErr_Occurred()) SWIG_fail;
48485 }
48486 resultobj = SWIG_Py_Void();
48487 return resultobj;
48488 fail:
48489 return NULL;
48490 }
48491
48492
48493 SWIGINTERN PyObject *_wrap_Control_RemoveMnemonics(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48494 PyObject *resultobj = 0;
48495 wxString *arg1 = 0 ;
48496 wxString result;
48497 bool temp1 = false ;
48498 PyObject * obj0 = 0 ;
48499 char * kwnames[] = {
48500 (char *) "str", NULL
48501 };
48502
48503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_RemoveMnemonics",kwnames,&obj0)) SWIG_fail;
48504 {
48505 arg1 = wxString_in_helper(obj0);
48506 if (arg1 == NULL) SWIG_fail;
48507 temp1 = true;
48508 }
48509 {
48510 PyThreadState* __tstate = wxPyBeginAllowThreads();
48511 result = wxControl::RemoveMnemonics((wxString const &)*arg1);
48512 wxPyEndAllowThreads(__tstate);
48513 if (PyErr_Occurred()) SWIG_fail;
48514 }
48515 {
48516 #if wxUSE_UNICODE
48517 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48518 #else
48519 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48520 #endif
48521 }
48522 {
48523 if (temp1)
48524 delete arg1;
48525 }
48526 return resultobj;
48527 fail:
48528 {
48529 if (temp1)
48530 delete arg1;
48531 }
48532 return NULL;
48533 }
48534
48535
48536 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48537 PyObject *resultobj = 0;
48538 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
48539 SwigValueWrapper<wxVisualAttributes > result;
48540 int val1 ;
48541 int ecode1 = 0 ;
48542 PyObject * obj0 = 0 ;
48543 char * kwnames[] = {
48544 (char *) "variant", NULL
48545 };
48546
48547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
48548 if (obj0) {
48549 ecode1 = SWIG_AsVal_int(obj0, &val1);
48550 if (!SWIG_IsOK(ecode1)) {
48551 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
48552 }
48553 arg1 = static_cast< wxWindowVariant >(val1);
48554 }
48555 {
48556 if (!wxPyCheckForApp()) SWIG_fail;
48557 PyThreadState* __tstate = wxPyBeginAllowThreads();
48558 result = wxControl::GetClassDefaultAttributes(arg1);
48559 wxPyEndAllowThreads(__tstate);
48560 if (PyErr_Occurred()) SWIG_fail;
48561 }
48562 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
48563 return resultobj;
48564 fail:
48565 return NULL;
48566 }
48567
48568
48569 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48570 PyObject *obj;
48571 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48572 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
48573 return SWIG_Py_Void();
48574 }
48575
48576 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48577 return SWIG_Python_InitShadowInstance(args);
48578 }
48579
48580 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48581 PyObject *resultobj = 0;
48582 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48583 wxString *arg2 = 0 ;
48584 PyObject *arg3 = (PyObject *) NULL ;
48585 int result;
48586 void *argp1 = 0 ;
48587 int res1 = 0 ;
48588 bool temp2 = false ;
48589 PyObject * obj0 = 0 ;
48590 PyObject * obj1 = 0 ;
48591 PyObject * obj2 = 0 ;
48592 char * kwnames[] = {
48593 (char *) "self",(char *) "item",(char *) "clientData", NULL
48594 };
48595
48596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48598 if (!SWIG_IsOK(res1)) {
48599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48600 }
48601 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48602 {
48603 arg2 = wxString_in_helper(obj1);
48604 if (arg2 == NULL) SWIG_fail;
48605 temp2 = true;
48606 }
48607 if (obj2) {
48608 arg3 = obj2;
48609 }
48610 {
48611 PyThreadState* __tstate = wxPyBeginAllowThreads();
48612 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
48613 wxPyEndAllowThreads(__tstate);
48614 if (PyErr_Occurred()) SWIG_fail;
48615 }
48616 resultobj = SWIG_From_int(static_cast< int >(result));
48617 {
48618 if (temp2)
48619 delete arg2;
48620 }
48621 return resultobj;
48622 fail:
48623 {
48624 if (temp2)
48625 delete arg2;
48626 }
48627 return NULL;
48628 }
48629
48630
48631 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48632 PyObject *resultobj = 0;
48633 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48634 wxArrayString *arg2 = 0 ;
48635 void *argp1 = 0 ;
48636 int res1 = 0 ;
48637 bool temp2 = false ;
48638 PyObject * obj0 = 0 ;
48639 PyObject * obj1 = 0 ;
48640 char * kwnames[] = {
48641 (char *) "self",(char *) "strings", NULL
48642 };
48643
48644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
48645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48646 if (!SWIG_IsOK(res1)) {
48647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48648 }
48649 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48650 {
48651 if (! PySequence_Check(obj1)) {
48652 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
48653 SWIG_fail;
48654 }
48655 arg2 = new wxArrayString;
48656 temp2 = true;
48657 int i, len=PySequence_Length(obj1);
48658 for (i=0; i<len; i++) {
48659 PyObject* item = PySequence_GetItem(obj1, i);
48660 wxString* s = wxString_in_helper(item);
48661 if (PyErr_Occurred()) SWIG_fail;
48662 arg2->Add(*s);
48663 delete s;
48664 Py_DECREF(item);
48665 }
48666 }
48667 {
48668 PyThreadState* __tstate = wxPyBeginAllowThreads();
48669 (arg1)->Append((wxArrayString const &)*arg2);
48670 wxPyEndAllowThreads(__tstate);
48671 if (PyErr_Occurred()) SWIG_fail;
48672 }
48673 resultobj = SWIG_Py_Void();
48674 {
48675 if (temp2) delete arg2;
48676 }
48677 return resultobj;
48678 fail:
48679 {
48680 if (temp2) delete arg2;
48681 }
48682 return NULL;
48683 }
48684
48685
48686 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48687 PyObject *resultobj = 0;
48688 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48689 wxString *arg2 = 0 ;
48690 int arg3 ;
48691 PyObject *arg4 = (PyObject *) NULL ;
48692 int result;
48693 void *argp1 = 0 ;
48694 int res1 = 0 ;
48695 bool temp2 = false ;
48696 int val3 ;
48697 int ecode3 = 0 ;
48698 PyObject * obj0 = 0 ;
48699 PyObject * obj1 = 0 ;
48700 PyObject * obj2 = 0 ;
48701 PyObject * obj3 = 0 ;
48702 char * kwnames[] = {
48703 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
48704 };
48705
48706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48708 if (!SWIG_IsOK(res1)) {
48709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48710 }
48711 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48712 {
48713 arg2 = wxString_in_helper(obj1);
48714 if (arg2 == NULL) SWIG_fail;
48715 temp2 = true;
48716 }
48717 ecode3 = SWIG_AsVal_int(obj2, &val3);
48718 if (!SWIG_IsOK(ecode3)) {
48719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
48720 }
48721 arg3 = static_cast< int >(val3);
48722 if (obj3) {
48723 arg4 = obj3;
48724 }
48725 {
48726 PyThreadState* __tstate = wxPyBeginAllowThreads();
48727 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
48728 wxPyEndAllowThreads(__tstate);
48729 if (PyErr_Occurred()) SWIG_fail;
48730 }
48731 resultobj = SWIG_From_int(static_cast< int >(result));
48732 {
48733 if (temp2)
48734 delete arg2;
48735 }
48736 return resultobj;
48737 fail:
48738 {
48739 if (temp2)
48740 delete arg2;
48741 }
48742 return NULL;
48743 }
48744
48745
48746 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48747 PyObject *resultobj = 0;
48748 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48749 void *argp1 = 0 ;
48750 int res1 = 0 ;
48751 PyObject *swig_obj[1] ;
48752
48753 if (!args) SWIG_fail;
48754 swig_obj[0] = args;
48755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48756 if (!SWIG_IsOK(res1)) {
48757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48758 }
48759 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48760 {
48761 PyThreadState* __tstate = wxPyBeginAllowThreads();
48762 (arg1)->Clear();
48763 wxPyEndAllowThreads(__tstate);
48764 if (PyErr_Occurred()) SWIG_fail;
48765 }
48766 resultobj = SWIG_Py_Void();
48767 return resultobj;
48768 fail:
48769 return NULL;
48770 }
48771
48772
48773 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48774 PyObject *resultobj = 0;
48775 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48776 int arg2 ;
48777 void *argp1 = 0 ;
48778 int res1 = 0 ;
48779 int val2 ;
48780 int ecode2 = 0 ;
48781 PyObject * obj0 = 0 ;
48782 PyObject * obj1 = 0 ;
48783 char * kwnames[] = {
48784 (char *) "self",(char *) "n", NULL
48785 };
48786
48787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
48788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48789 if (!SWIG_IsOK(res1)) {
48790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48791 }
48792 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48793 ecode2 = SWIG_AsVal_int(obj1, &val2);
48794 if (!SWIG_IsOK(ecode2)) {
48795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
48796 }
48797 arg2 = static_cast< int >(val2);
48798 {
48799 PyThreadState* __tstate = wxPyBeginAllowThreads();
48800 (arg1)->Delete(arg2);
48801 wxPyEndAllowThreads(__tstate);
48802 if (PyErr_Occurred()) SWIG_fail;
48803 }
48804 resultobj = SWIG_Py_Void();
48805 return resultobj;
48806 fail:
48807 return NULL;
48808 }
48809
48810
48811 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48812 PyObject *resultobj = 0;
48813 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48814 int arg2 ;
48815 PyObject *result = 0 ;
48816 void *argp1 = 0 ;
48817 int res1 = 0 ;
48818 int val2 ;
48819 int ecode2 = 0 ;
48820 PyObject * obj0 = 0 ;
48821 PyObject * obj1 = 0 ;
48822 char * kwnames[] = {
48823 (char *) "self",(char *) "n", NULL
48824 };
48825
48826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
48827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48828 if (!SWIG_IsOK(res1)) {
48829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48830 }
48831 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48832 ecode2 = SWIG_AsVal_int(obj1, &val2);
48833 if (!SWIG_IsOK(ecode2)) {
48834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
48835 }
48836 arg2 = static_cast< int >(val2);
48837 {
48838 PyThreadState* __tstate = wxPyBeginAllowThreads();
48839 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
48840 wxPyEndAllowThreads(__tstate);
48841 if (PyErr_Occurred()) SWIG_fail;
48842 }
48843 resultobj = result;
48844 return resultobj;
48845 fail:
48846 return NULL;
48847 }
48848
48849
48850 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48851 PyObject *resultobj = 0;
48852 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48853 int arg2 ;
48854 PyObject *arg3 = (PyObject *) 0 ;
48855 void *argp1 = 0 ;
48856 int res1 = 0 ;
48857 int val2 ;
48858 int ecode2 = 0 ;
48859 PyObject * obj0 = 0 ;
48860 PyObject * obj1 = 0 ;
48861 PyObject * obj2 = 0 ;
48862 char * kwnames[] = {
48863 (char *) "self",(char *) "n",(char *) "clientData", NULL
48864 };
48865
48866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48868 if (!SWIG_IsOK(res1)) {
48869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48870 }
48871 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48872 ecode2 = SWIG_AsVal_int(obj1, &val2);
48873 if (!SWIG_IsOK(ecode2)) {
48874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
48875 }
48876 arg2 = static_cast< int >(val2);
48877 arg3 = obj2;
48878 {
48879 PyThreadState* __tstate = wxPyBeginAllowThreads();
48880 wxItemContainer_SetClientData(arg1,arg2,arg3);
48881 wxPyEndAllowThreads(__tstate);
48882 if (PyErr_Occurred()) SWIG_fail;
48883 }
48884 resultobj = SWIG_Py_Void();
48885 return resultobj;
48886 fail:
48887 return NULL;
48888 }
48889
48890
48891 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48892 PyObject *resultobj = 0;
48893 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48894 int result;
48895 void *argp1 = 0 ;
48896 int res1 = 0 ;
48897 PyObject *swig_obj[1] ;
48898
48899 if (!args) SWIG_fail;
48900 swig_obj[0] = args;
48901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48902 if (!SWIG_IsOK(res1)) {
48903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48904 }
48905 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48906 {
48907 PyThreadState* __tstate = wxPyBeginAllowThreads();
48908 result = (int)((wxItemContainer const *)arg1)->GetCount();
48909 wxPyEndAllowThreads(__tstate);
48910 if (PyErr_Occurred()) SWIG_fail;
48911 }
48912 resultobj = SWIG_From_int(static_cast< int >(result));
48913 return resultobj;
48914 fail:
48915 return NULL;
48916 }
48917
48918
48919 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48920 PyObject *resultobj = 0;
48921 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48922 bool result;
48923 void *argp1 = 0 ;
48924 int res1 = 0 ;
48925 PyObject *swig_obj[1] ;
48926
48927 if (!args) SWIG_fail;
48928 swig_obj[0] = args;
48929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48930 if (!SWIG_IsOK(res1)) {
48931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48932 }
48933 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48934 {
48935 PyThreadState* __tstate = wxPyBeginAllowThreads();
48936 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48937 wxPyEndAllowThreads(__tstate);
48938 if (PyErr_Occurred()) SWIG_fail;
48939 }
48940 {
48941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48942 }
48943 return resultobj;
48944 fail:
48945 return NULL;
48946 }
48947
48948
48949 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48950 PyObject *resultobj = 0;
48951 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48952 int arg2 ;
48953 wxString result;
48954 void *argp1 = 0 ;
48955 int res1 = 0 ;
48956 int val2 ;
48957 int ecode2 = 0 ;
48958 PyObject * obj0 = 0 ;
48959 PyObject * obj1 = 0 ;
48960 char * kwnames[] = {
48961 (char *) "self",(char *) "n", NULL
48962 };
48963
48964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48966 if (!SWIG_IsOK(res1)) {
48967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48968 }
48969 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48970 ecode2 = SWIG_AsVal_int(obj1, &val2);
48971 if (!SWIG_IsOK(ecode2)) {
48972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
48973 }
48974 arg2 = static_cast< int >(val2);
48975 {
48976 PyThreadState* __tstate = wxPyBeginAllowThreads();
48977 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48978 wxPyEndAllowThreads(__tstate);
48979 if (PyErr_Occurred()) SWIG_fail;
48980 }
48981 {
48982 #if wxUSE_UNICODE
48983 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48984 #else
48985 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48986 #endif
48987 }
48988 return resultobj;
48989 fail:
48990 return NULL;
48991 }
48992
48993
48994 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48995 PyObject *resultobj = 0;
48996 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48997 wxArrayString result;
48998 void *argp1 = 0 ;
48999 int res1 = 0 ;
49000 PyObject *swig_obj[1] ;
49001
49002 if (!args) SWIG_fail;
49003 swig_obj[0] = args;
49004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49005 if (!SWIG_IsOK(res1)) {
49006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49007 }
49008 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49009 {
49010 PyThreadState* __tstate = wxPyBeginAllowThreads();
49011 result = ((wxItemContainer const *)arg1)->GetStrings();
49012 wxPyEndAllowThreads(__tstate);
49013 if (PyErr_Occurred()) SWIG_fail;
49014 }
49015 {
49016 resultobj = wxArrayString2PyList_helper(result);
49017 }
49018 return resultobj;
49019 fail:
49020 return NULL;
49021 }
49022
49023
49024 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49025 PyObject *resultobj = 0;
49026 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49027 int arg2 ;
49028 wxString *arg3 = 0 ;
49029 void *argp1 = 0 ;
49030 int res1 = 0 ;
49031 int val2 ;
49032 int ecode2 = 0 ;
49033 bool temp3 = false ;
49034 PyObject * obj0 = 0 ;
49035 PyObject * obj1 = 0 ;
49036 PyObject * obj2 = 0 ;
49037 char * kwnames[] = {
49038 (char *) "self",(char *) "n",(char *) "s", NULL
49039 };
49040
49041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49043 if (!SWIG_IsOK(res1)) {
49044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49045 }
49046 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49047 ecode2 = SWIG_AsVal_int(obj1, &val2);
49048 if (!SWIG_IsOK(ecode2)) {
49049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
49050 }
49051 arg2 = static_cast< int >(val2);
49052 {
49053 arg3 = wxString_in_helper(obj2);
49054 if (arg3 == NULL) SWIG_fail;
49055 temp3 = true;
49056 }
49057 {
49058 PyThreadState* __tstate = wxPyBeginAllowThreads();
49059 (arg1)->SetString(arg2,(wxString const &)*arg3);
49060 wxPyEndAllowThreads(__tstate);
49061 if (PyErr_Occurred()) SWIG_fail;
49062 }
49063 resultobj = SWIG_Py_Void();
49064 {
49065 if (temp3)
49066 delete arg3;
49067 }
49068 return resultobj;
49069 fail:
49070 {
49071 if (temp3)
49072 delete arg3;
49073 }
49074 return NULL;
49075 }
49076
49077
49078 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49079 PyObject *resultobj = 0;
49080 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49081 wxString *arg2 = 0 ;
49082 int result;
49083 void *argp1 = 0 ;
49084 int res1 = 0 ;
49085 bool temp2 = false ;
49086 PyObject * obj0 = 0 ;
49087 PyObject * obj1 = 0 ;
49088 char * kwnames[] = {
49089 (char *) "self",(char *) "s", NULL
49090 };
49091
49092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
49093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49094 if (!SWIG_IsOK(res1)) {
49095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49096 }
49097 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49098 {
49099 arg2 = wxString_in_helper(obj1);
49100 if (arg2 == NULL) SWIG_fail;
49101 temp2 = true;
49102 }
49103 {
49104 PyThreadState* __tstate = wxPyBeginAllowThreads();
49105 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
49106 wxPyEndAllowThreads(__tstate);
49107 if (PyErr_Occurred()) SWIG_fail;
49108 }
49109 resultobj = SWIG_From_int(static_cast< int >(result));
49110 {
49111 if (temp2)
49112 delete arg2;
49113 }
49114 return resultobj;
49115 fail:
49116 {
49117 if (temp2)
49118 delete arg2;
49119 }
49120 return NULL;
49121 }
49122
49123
49124 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49125 PyObject *resultobj = 0;
49126 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49127 int arg2 ;
49128 void *argp1 = 0 ;
49129 int res1 = 0 ;
49130 int val2 ;
49131 int ecode2 = 0 ;
49132 PyObject * obj0 = 0 ;
49133 PyObject * obj1 = 0 ;
49134 char * kwnames[] = {
49135 (char *) "self",(char *) "n", NULL
49136 };
49137
49138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
49139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49140 if (!SWIG_IsOK(res1)) {
49141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49142 }
49143 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49144 ecode2 = SWIG_AsVal_int(obj1, &val2);
49145 if (!SWIG_IsOK(ecode2)) {
49146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
49147 }
49148 arg2 = static_cast< int >(val2);
49149 {
49150 PyThreadState* __tstate = wxPyBeginAllowThreads();
49151 (arg1)->SetSelection(arg2);
49152 wxPyEndAllowThreads(__tstate);
49153 if (PyErr_Occurred()) SWIG_fail;
49154 }
49155 resultobj = SWIG_Py_Void();
49156 return resultobj;
49157 fail:
49158 return NULL;
49159 }
49160
49161
49162 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49163 PyObject *resultobj = 0;
49164 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49165 int result;
49166 void *argp1 = 0 ;
49167 int res1 = 0 ;
49168 PyObject *swig_obj[1] ;
49169
49170 if (!args) SWIG_fail;
49171 swig_obj[0] = args;
49172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49173 if (!SWIG_IsOK(res1)) {
49174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49175 }
49176 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49177 {
49178 PyThreadState* __tstate = wxPyBeginAllowThreads();
49179 result = (int)((wxItemContainer const *)arg1)->GetSelection();
49180 wxPyEndAllowThreads(__tstate);
49181 if (PyErr_Occurred()) SWIG_fail;
49182 }
49183 resultobj = SWIG_From_int(static_cast< int >(result));
49184 return resultobj;
49185 fail:
49186 return NULL;
49187 }
49188
49189
49190 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49191 PyObject *resultobj = 0;
49192 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49193 wxString *arg2 = 0 ;
49194 bool result;
49195 void *argp1 = 0 ;
49196 int res1 = 0 ;
49197 bool temp2 = false ;
49198 PyObject * obj0 = 0 ;
49199 PyObject * obj1 = 0 ;
49200 char * kwnames[] = {
49201 (char *) "self",(char *) "s", NULL
49202 };
49203
49204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
49205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49206 if (!SWIG_IsOK(res1)) {
49207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49208 }
49209 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49210 {
49211 arg2 = wxString_in_helper(obj1);
49212 if (arg2 == NULL) SWIG_fail;
49213 temp2 = true;
49214 }
49215 {
49216 PyThreadState* __tstate = wxPyBeginAllowThreads();
49217 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
49218 wxPyEndAllowThreads(__tstate);
49219 if (PyErr_Occurred()) SWIG_fail;
49220 }
49221 {
49222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49223 }
49224 {
49225 if (temp2)
49226 delete arg2;
49227 }
49228 return resultobj;
49229 fail:
49230 {
49231 if (temp2)
49232 delete arg2;
49233 }
49234 return NULL;
49235 }
49236
49237
49238 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49239 PyObject *resultobj = 0;
49240 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49241 wxString result;
49242 void *argp1 = 0 ;
49243 int res1 = 0 ;
49244 PyObject *swig_obj[1] ;
49245
49246 if (!args) SWIG_fail;
49247 swig_obj[0] = args;
49248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49249 if (!SWIG_IsOK(res1)) {
49250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49251 }
49252 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49253 {
49254 PyThreadState* __tstate = wxPyBeginAllowThreads();
49255 result = ((wxItemContainer const *)arg1)->GetStringSelection();
49256 wxPyEndAllowThreads(__tstate);
49257 if (PyErr_Occurred()) SWIG_fail;
49258 }
49259 {
49260 #if wxUSE_UNICODE
49261 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
49262 #else
49263 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
49264 #endif
49265 }
49266 return resultobj;
49267 fail:
49268 return NULL;
49269 }
49270
49271
49272 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49273 PyObject *resultobj = 0;
49274 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49275 int arg2 ;
49276 void *argp1 = 0 ;
49277 int res1 = 0 ;
49278 int val2 ;
49279 int ecode2 = 0 ;
49280 PyObject * obj0 = 0 ;
49281 PyObject * obj1 = 0 ;
49282 char * kwnames[] = {
49283 (char *) "self",(char *) "n", NULL
49284 };
49285
49286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
49287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49288 if (!SWIG_IsOK(res1)) {
49289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49290 }
49291 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49292 ecode2 = SWIG_AsVal_int(obj1, &val2);
49293 if (!SWIG_IsOK(ecode2)) {
49294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
49295 }
49296 arg2 = static_cast< int >(val2);
49297 {
49298 PyThreadState* __tstate = wxPyBeginAllowThreads();
49299 (arg1)->Select(arg2);
49300 wxPyEndAllowThreads(__tstate);
49301 if (PyErr_Occurred()) SWIG_fail;
49302 }
49303 resultobj = SWIG_Py_Void();
49304 return resultobj;
49305 fail:
49306 return NULL;
49307 }
49308
49309
49310 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49311 PyObject *obj;
49312 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49313 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
49314 return SWIG_Py_Void();
49315 }
49316
49317 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49318 PyObject *obj;
49319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49320 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
49321 return SWIG_Py_Void();
49322 }
49323
49324 SWIGINTERN PyObject *_wrap_new_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49325 PyObject *resultobj = 0;
49326 int arg1 = (int) 0 ;
49327 wxSizerFlags *result = 0 ;
49328 int val1 ;
49329 int ecode1 = 0 ;
49330 PyObject * obj0 = 0 ;
49331 char * kwnames[] = {
49332 (char *) "proportion", NULL
49333 };
49334
49335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_SizerFlags",kwnames,&obj0)) SWIG_fail;
49336 if (obj0) {
49337 ecode1 = SWIG_AsVal_int(obj0, &val1);
49338 if (!SWIG_IsOK(ecode1)) {
49339 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerFlags" "', expected argument " "1"" of type '" "int""'");
49340 }
49341 arg1 = static_cast< int >(val1);
49342 }
49343 {
49344 PyThreadState* __tstate = wxPyBeginAllowThreads();
49345 result = (wxSizerFlags *)new wxSizerFlags(arg1);
49346 wxPyEndAllowThreads(__tstate);
49347 if (PyErr_Occurred()) SWIG_fail;
49348 }
49349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_NEW | 0 );
49350 return resultobj;
49351 fail:
49352 return NULL;
49353 }
49354
49355
49356 SWIGINTERN PyObject *_wrap_delete_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49357 PyObject *resultobj = 0;
49358 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49359 void *argp1 = 0 ;
49360 int res1 = 0 ;
49361 PyObject *swig_obj[1] ;
49362
49363 if (!args) SWIG_fail;
49364 swig_obj[0] = args;
49365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_DISOWN | 0 );
49366 if (!SWIG_IsOK(res1)) {
49367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerFlags" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49368 }
49369 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49370 {
49371 PyThreadState* __tstate = wxPyBeginAllowThreads();
49372 delete arg1;
49373
49374 wxPyEndAllowThreads(__tstate);
49375 if (PyErr_Occurred()) SWIG_fail;
49376 }
49377 resultobj = SWIG_Py_Void();
49378 return resultobj;
49379 fail:
49380 return NULL;
49381 }
49382
49383
49384 SWIGINTERN PyObject *_wrap_SizerFlags_Proportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49385 PyObject *resultobj = 0;
49386 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49387 int arg2 ;
49388 wxSizerFlags *result = 0 ;
49389 void *argp1 = 0 ;
49390 int res1 = 0 ;
49391 int val2 ;
49392 int ecode2 = 0 ;
49393 PyObject * obj0 = 0 ;
49394 PyObject * obj1 = 0 ;
49395 char * kwnames[] = {
49396 (char *) "self",(char *) "proportion", NULL
49397 };
49398
49399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Proportion",kwnames,&obj0,&obj1)) SWIG_fail;
49400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49401 if (!SWIG_IsOK(res1)) {
49402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Proportion" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49403 }
49404 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49405 ecode2 = SWIG_AsVal_int(obj1, &val2);
49406 if (!SWIG_IsOK(ecode2)) {
49407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Proportion" "', expected argument " "2"" of type '" "int""'");
49408 }
49409 arg2 = static_cast< int >(val2);
49410 {
49411 PyThreadState* __tstate = wxPyBeginAllowThreads();
49412 {
49413 wxSizerFlags &_result_ref = (arg1)->Proportion(arg2);
49414 result = (wxSizerFlags *) &_result_ref;
49415 }
49416 wxPyEndAllowThreads(__tstate);
49417 if (PyErr_Occurred()) SWIG_fail;
49418 }
49419 {
49420 resultobj = obj0; Py_INCREF(resultobj);
49421 }
49422 return resultobj;
49423 fail:
49424 return NULL;
49425 }
49426
49427
49428 SWIGINTERN PyObject *_wrap_SizerFlags_Align(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49429 PyObject *resultobj = 0;
49430 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49431 int arg2 ;
49432 wxSizerFlags *result = 0 ;
49433 void *argp1 = 0 ;
49434 int res1 = 0 ;
49435 int val2 ;
49436 int ecode2 = 0 ;
49437 PyObject * obj0 = 0 ;
49438 PyObject * obj1 = 0 ;
49439 char * kwnames[] = {
49440 (char *) "self",(char *) "alignment", NULL
49441 };
49442
49443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Align",kwnames,&obj0,&obj1)) SWIG_fail;
49444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49445 if (!SWIG_IsOK(res1)) {
49446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Align" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49447 }
49448 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49449 ecode2 = SWIG_AsVal_int(obj1, &val2);
49450 if (!SWIG_IsOK(ecode2)) {
49451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Align" "', expected argument " "2"" of type '" "int""'");
49452 }
49453 arg2 = static_cast< int >(val2);
49454 {
49455 PyThreadState* __tstate = wxPyBeginAllowThreads();
49456 {
49457 wxSizerFlags &_result_ref = (arg1)->Align(arg2);
49458 result = (wxSizerFlags *) &_result_ref;
49459 }
49460 wxPyEndAllowThreads(__tstate);
49461 if (PyErr_Occurred()) SWIG_fail;
49462 }
49463 {
49464 resultobj = obj0; Py_INCREF(resultobj);
49465 }
49466 return resultobj;
49467 fail:
49468 return NULL;
49469 }
49470
49471
49472 SWIGINTERN PyObject *_wrap_SizerFlags_Expand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49473 PyObject *resultobj = 0;
49474 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49475 wxSizerFlags *result = 0 ;
49476 void *argp1 = 0 ;
49477 int res1 = 0 ;
49478 PyObject *swig_obj[1] ;
49479
49480 if (!args) SWIG_fail;
49481 swig_obj[0] = args;
49482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49483 if (!SWIG_IsOK(res1)) {
49484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Expand" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49485 }
49486 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49487 {
49488 PyThreadState* __tstate = wxPyBeginAllowThreads();
49489 {
49490 wxSizerFlags &_result_ref = (arg1)->Expand();
49491 result = (wxSizerFlags *) &_result_ref;
49492 }
49493 wxPyEndAllowThreads(__tstate);
49494 if (PyErr_Occurred()) SWIG_fail;
49495 }
49496 {
49497 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49498 }
49499 return resultobj;
49500 fail:
49501 return NULL;
49502 }
49503
49504
49505 SWIGINTERN PyObject *_wrap_SizerFlags_Centre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49506 PyObject *resultobj = 0;
49507 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49508 wxSizerFlags *result = 0 ;
49509 void *argp1 = 0 ;
49510 int res1 = 0 ;
49511 PyObject *swig_obj[1] ;
49512
49513 if (!args) SWIG_fail;
49514 swig_obj[0] = args;
49515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49516 if (!SWIG_IsOK(res1)) {
49517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Centre" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49518 }
49519 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49520 {
49521 PyThreadState* __tstate = wxPyBeginAllowThreads();
49522 {
49523 wxSizerFlags &_result_ref = (arg1)->Centre();
49524 result = (wxSizerFlags *) &_result_ref;
49525 }
49526 wxPyEndAllowThreads(__tstate);
49527 if (PyErr_Occurred()) SWIG_fail;
49528 }
49529 {
49530 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49531 }
49532 return resultobj;
49533 fail:
49534 return NULL;
49535 }
49536
49537
49538 SWIGINTERN PyObject *_wrap_SizerFlags_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49539 PyObject *resultobj = 0;
49540 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49541 wxSizerFlags *result = 0 ;
49542 void *argp1 = 0 ;
49543 int res1 = 0 ;
49544 PyObject *swig_obj[1] ;
49545
49546 if (!args) SWIG_fail;
49547 swig_obj[0] = args;
49548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49549 if (!SWIG_IsOK(res1)) {
49550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Center" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49551 }
49552 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49553 {
49554 PyThreadState* __tstate = wxPyBeginAllowThreads();
49555 {
49556 wxSizerFlags &_result_ref = (arg1)->Center();
49557 result = (wxSizerFlags *) &_result_ref;
49558 }
49559 wxPyEndAllowThreads(__tstate);
49560 if (PyErr_Occurred()) SWIG_fail;
49561 }
49562 {
49563 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49564 }
49565 return resultobj;
49566 fail:
49567 return NULL;
49568 }
49569
49570
49571 SWIGINTERN PyObject *_wrap_SizerFlags_Left(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49572 PyObject *resultobj = 0;
49573 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49574 wxSizerFlags *result = 0 ;
49575 void *argp1 = 0 ;
49576 int res1 = 0 ;
49577 PyObject *swig_obj[1] ;
49578
49579 if (!args) SWIG_fail;
49580 swig_obj[0] = args;
49581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49582 if (!SWIG_IsOK(res1)) {
49583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Left" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49584 }
49585 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49586 {
49587 PyThreadState* __tstate = wxPyBeginAllowThreads();
49588 {
49589 wxSizerFlags &_result_ref = (arg1)->Left();
49590 result = (wxSizerFlags *) &_result_ref;
49591 }
49592 wxPyEndAllowThreads(__tstate);
49593 if (PyErr_Occurred()) SWIG_fail;
49594 }
49595 {
49596 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49597 }
49598 return resultobj;
49599 fail:
49600 return NULL;
49601 }
49602
49603
49604 SWIGINTERN PyObject *_wrap_SizerFlags_Right(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49605 PyObject *resultobj = 0;
49606 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49607 wxSizerFlags *result = 0 ;
49608 void *argp1 = 0 ;
49609 int res1 = 0 ;
49610 PyObject *swig_obj[1] ;
49611
49612 if (!args) SWIG_fail;
49613 swig_obj[0] = args;
49614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49615 if (!SWIG_IsOK(res1)) {
49616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Right" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49617 }
49618 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49619 {
49620 PyThreadState* __tstate = wxPyBeginAllowThreads();
49621 {
49622 wxSizerFlags &_result_ref = (arg1)->Right();
49623 result = (wxSizerFlags *) &_result_ref;
49624 }
49625 wxPyEndAllowThreads(__tstate);
49626 if (PyErr_Occurred()) SWIG_fail;
49627 }
49628 {
49629 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49630 }
49631 return resultobj;
49632 fail:
49633 return NULL;
49634 }
49635
49636
49637 SWIGINTERN PyObject *_wrap_SizerFlags_Top(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49638 PyObject *resultobj = 0;
49639 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49640 wxSizerFlags *result = 0 ;
49641 void *argp1 = 0 ;
49642 int res1 = 0 ;
49643 PyObject *swig_obj[1] ;
49644
49645 if (!args) SWIG_fail;
49646 swig_obj[0] = args;
49647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49648 if (!SWIG_IsOK(res1)) {
49649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Top" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49650 }
49651 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49652 {
49653 PyThreadState* __tstate = wxPyBeginAllowThreads();
49654 {
49655 wxSizerFlags &_result_ref = (arg1)->Top();
49656 result = (wxSizerFlags *) &_result_ref;
49657 }
49658 wxPyEndAllowThreads(__tstate);
49659 if (PyErr_Occurred()) SWIG_fail;
49660 }
49661 {
49662 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49663 }
49664 return resultobj;
49665 fail:
49666 return NULL;
49667 }
49668
49669
49670 SWIGINTERN PyObject *_wrap_SizerFlags_Bottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49671 PyObject *resultobj = 0;
49672 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49673 wxSizerFlags *result = 0 ;
49674 void *argp1 = 0 ;
49675 int res1 = 0 ;
49676 PyObject *swig_obj[1] ;
49677
49678 if (!args) SWIG_fail;
49679 swig_obj[0] = args;
49680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49681 if (!SWIG_IsOK(res1)) {
49682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Bottom" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49683 }
49684 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49685 {
49686 PyThreadState* __tstate = wxPyBeginAllowThreads();
49687 {
49688 wxSizerFlags &_result_ref = (arg1)->Bottom();
49689 result = (wxSizerFlags *) &_result_ref;
49690 }
49691 wxPyEndAllowThreads(__tstate);
49692 if (PyErr_Occurred()) SWIG_fail;
49693 }
49694 {
49695 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49696 }
49697 return resultobj;
49698 fail:
49699 return NULL;
49700 }
49701
49702
49703 SWIGINTERN PyObject *_wrap_SizerFlags_Shaped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49704 PyObject *resultobj = 0;
49705 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49706 wxSizerFlags *result = 0 ;
49707 void *argp1 = 0 ;
49708 int res1 = 0 ;
49709 PyObject *swig_obj[1] ;
49710
49711 if (!args) SWIG_fail;
49712 swig_obj[0] = args;
49713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49714 if (!SWIG_IsOK(res1)) {
49715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Shaped" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49716 }
49717 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49718 {
49719 PyThreadState* __tstate = wxPyBeginAllowThreads();
49720 {
49721 wxSizerFlags &_result_ref = (arg1)->Shaped();
49722 result = (wxSizerFlags *) &_result_ref;
49723 }
49724 wxPyEndAllowThreads(__tstate);
49725 if (PyErr_Occurred()) SWIG_fail;
49726 }
49727 {
49728 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49729 }
49730 return resultobj;
49731 fail:
49732 return NULL;
49733 }
49734
49735
49736 SWIGINTERN PyObject *_wrap_SizerFlags_FixedMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49737 PyObject *resultobj = 0;
49738 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49739 wxSizerFlags *result = 0 ;
49740 void *argp1 = 0 ;
49741 int res1 = 0 ;
49742 PyObject *swig_obj[1] ;
49743
49744 if (!args) SWIG_fail;
49745 swig_obj[0] = args;
49746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49747 if (!SWIG_IsOK(res1)) {
49748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_FixedMinSize" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49749 }
49750 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49751 {
49752 PyThreadState* __tstate = wxPyBeginAllowThreads();
49753 {
49754 wxSizerFlags &_result_ref = (arg1)->FixedMinSize();
49755 result = (wxSizerFlags *) &_result_ref;
49756 }
49757 wxPyEndAllowThreads(__tstate);
49758 if (PyErr_Occurred()) SWIG_fail;
49759 }
49760 {
49761 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49762 }
49763 return resultobj;
49764 fail:
49765 return NULL;
49766 }
49767
49768
49769 SWIGINTERN PyObject *_wrap_SizerFlags_Border(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49770 PyObject *resultobj = 0;
49771 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49772 int arg2 = (int) wxALL ;
49773 int arg3 = (int) -1 ;
49774 wxSizerFlags *result = 0 ;
49775 void *argp1 = 0 ;
49776 int res1 = 0 ;
49777 int val2 ;
49778 int ecode2 = 0 ;
49779 int val3 ;
49780 int ecode3 = 0 ;
49781 PyObject * obj0 = 0 ;
49782 PyObject * obj1 = 0 ;
49783 PyObject * obj2 = 0 ;
49784 char * kwnames[] = {
49785 (char *) "self",(char *) "direction",(char *) "borderInPixels", NULL
49786 };
49787
49788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:SizerFlags_Border",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49790 if (!SWIG_IsOK(res1)) {
49791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Border" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49792 }
49793 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49794 if (obj1) {
49795 ecode2 = SWIG_AsVal_int(obj1, &val2);
49796 if (!SWIG_IsOK(ecode2)) {
49797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Border" "', expected argument " "2"" of type '" "int""'");
49798 }
49799 arg2 = static_cast< int >(val2);
49800 }
49801 if (obj2) {
49802 ecode3 = SWIG_AsVal_int(obj2, &val3);
49803 if (!SWIG_IsOK(ecode3)) {
49804 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerFlags_Border" "', expected argument " "3"" of type '" "int""'");
49805 }
49806 arg3 = static_cast< int >(val3);
49807 }
49808 {
49809 PyThreadState* __tstate = wxPyBeginAllowThreads();
49810 {
49811 wxSizerFlags &_result_ref = wxSizerFlags_Border(arg1,arg2,arg3);
49812 result = (wxSizerFlags *) &_result_ref;
49813 }
49814 wxPyEndAllowThreads(__tstate);
49815 if (PyErr_Occurred()) SWIG_fail;
49816 }
49817 {
49818 resultobj = obj0; Py_INCREF(resultobj);
49819 }
49820 return resultobj;
49821 fail:
49822 return NULL;
49823 }
49824
49825
49826 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49827 PyObject *resultobj = 0;
49828 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49829 int arg2 = (int) wxALL ;
49830 wxSizerFlags *result = 0 ;
49831 void *argp1 = 0 ;
49832 int res1 = 0 ;
49833 int val2 ;
49834 int ecode2 = 0 ;
49835 PyObject * obj0 = 0 ;
49836 PyObject * obj1 = 0 ;
49837 char * kwnames[] = {
49838 (char *) "self",(char *) "direction", NULL
49839 };
49840
49841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_DoubleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49843 if (!SWIG_IsOK(res1)) {
49844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49845 }
49846 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49847 if (obj1) {
49848 ecode2 = SWIG_AsVal_int(obj1, &val2);
49849 if (!SWIG_IsOK(ecode2)) {
49850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "2"" of type '" "int""'");
49851 }
49852 arg2 = static_cast< int >(val2);
49853 }
49854 {
49855 PyThreadState* __tstate = wxPyBeginAllowThreads();
49856 {
49857 wxSizerFlags &_result_ref = (arg1)->DoubleBorder(arg2);
49858 result = (wxSizerFlags *) &_result_ref;
49859 }
49860 wxPyEndAllowThreads(__tstate);
49861 if (PyErr_Occurred()) SWIG_fail;
49862 }
49863 {
49864 resultobj = obj0; Py_INCREF(resultobj);
49865 }
49866 return resultobj;
49867 fail:
49868 return NULL;
49869 }
49870
49871
49872 SWIGINTERN PyObject *_wrap_SizerFlags_TripleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49873 PyObject *resultobj = 0;
49874 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49875 int arg2 = (int) wxALL ;
49876 wxSizerFlags *result = 0 ;
49877 void *argp1 = 0 ;
49878 int res1 = 0 ;
49879 int val2 ;
49880 int ecode2 = 0 ;
49881 PyObject * obj0 = 0 ;
49882 PyObject * obj1 = 0 ;
49883 char * kwnames[] = {
49884 (char *) "self",(char *) "direction", NULL
49885 };
49886
49887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_TripleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49889 if (!SWIG_IsOK(res1)) {
49890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_TripleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49891 }
49892 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49893 if (obj1) {
49894 ecode2 = SWIG_AsVal_int(obj1, &val2);
49895 if (!SWIG_IsOK(ecode2)) {
49896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_TripleBorder" "', expected argument " "2"" of type '" "int""'");
49897 }
49898 arg2 = static_cast< int >(val2);
49899 }
49900 {
49901 PyThreadState* __tstate = wxPyBeginAllowThreads();
49902 {
49903 wxSizerFlags &_result_ref = (arg1)->TripleBorder(arg2);
49904 result = (wxSizerFlags *) &_result_ref;
49905 }
49906 wxPyEndAllowThreads(__tstate);
49907 if (PyErr_Occurred()) SWIG_fail;
49908 }
49909 {
49910 resultobj = obj0; Py_INCREF(resultobj);
49911 }
49912 return resultobj;
49913 fail:
49914 return NULL;
49915 }
49916
49917
49918 SWIGINTERN PyObject *_wrap_SizerFlags_HorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49919 PyObject *resultobj = 0;
49920 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49921 wxSizerFlags *result = 0 ;
49922 void *argp1 = 0 ;
49923 int res1 = 0 ;
49924 PyObject *swig_obj[1] ;
49925
49926 if (!args) SWIG_fail;
49927 swig_obj[0] = args;
49928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49929 if (!SWIG_IsOK(res1)) {
49930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_HorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49931 }
49932 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49933 {
49934 PyThreadState* __tstate = wxPyBeginAllowThreads();
49935 {
49936 wxSizerFlags &_result_ref = (arg1)->HorzBorder();
49937 result = (wxSizerFlags *) &_result_ref;
49938 }
49939 wxPyEndAllowThreads(__tstate);
49940 if (PyErr_Occurred()) SWIG_fail;
49941 }
49942 {
49943 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49944 }
49945 return resultobj;
49946 fail:
49947 return NULL;
49948 }
49949
49950
49951 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleHorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49952 PyObject *resultobj = 0;
49953 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49954 wxSizerFlags *result = 0 ;
49955 void *argp1 = 0 ;
49956 int res1 = 0 ;
49957 PyObject *swig_obj[1] ;
49958
49959 if (!args) SWIG_fail;
49960 swig_obj[0] = args;
49961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49962 if (!SWIG_IsOK(res1)) {
49963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleHorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49964 }
49965 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49966 {
49967 PyThreadState* __tstate = wxPyBeginAllowThreads();
49968 {
49969 wxSizerFlags &_result_ref = (arg1)->DoubleHorzBorder();
49970 result = (wxSizerFlags *) &_result_ref;
49971 }
49972 wxPyEndAllowThreads(__tstate);
49973 if (PyErr_Occurred()) SWIG_fail;
49974 }
49975 {
49976 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49977 }
49978 return resultobj;
49979 fail:
49980 return NULL;
49981 }
49982
49983
49984 SWIGINTERN PyObject *_wrap_SizerFlags_GetDefaultBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49985 PyObject *resultobj = 0;
49986 int result;
49987
49988 if (!SWIG_Python_UnpackTuple(args,"SizerFlags_GetDefaultBorder",0,0,0)) SWIG_fail;
49989 {
49990 PyThreadState* __tstate = wxPyBeginAllowThreads();
49991 result = (int)wxSizerFlags::GetDefaultBorder();
49992 wxPyEndAllowThreads(__tstate);
49993 if (PyErr_Occurred()) SWIG_fail;
49994 }
49995 resultobj = SWIG_From_int(static_cast< int >(result));
49996 return resultobj;
49997 fail:
49998 return NULL;
49999 }
50000
50001
50002 SWIGINTERN PyObject *_wrap_SizerFlags_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50003 PyObject *resultobj = 0;
50004 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
50005 int result;
50006 void *argp1 = 0 ;
50007 int res1 = 0 ;
50008 PyObject *swig_obj[1] ;
50009
50010 if (!args) SWIG_fail;
50011 swig_obj[0] = args;
50012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
50013 if (!SWIG_IsOK(res1)) {
50014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetProportion" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
50015 }
50016 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
50017 {
50018 PyThreadState* __tstate = wxPyBeginAllowThreads();
50019 result = (int)((wxSizerFlags const *)arg1)->GetProportion();
50020 wxPyEndAllowThreads(__tstate);
50021 if (PyErr_Occurred()) SWIG_fail;
50022 }
50023 resultobj = SWIG_From_int(static_cast< int >(result));
50024 return resultobj;
50025 fail:
50026 return NULL;
50027 }
50028
50029
50030 SWIGINTERN PyObject *_wrap_SizerFlags_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50031 PyObject *resultobj = 0;
50032 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
50033 int result;
50034 void *argp1 = 0 ;
50035 int res1 = 0 ;
50036 PyObject *swig_obj[1] ;
50037
50038 if (!args) SWIG_fail;
50039 swig_obj[0] = args;
50040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
50041 if (!SWIG_IsOK(res1)) {
50042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetFlags" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
50043 }
50044 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
50045 {
50046 PyThreadState* __tstate = wxPyBeginAllowThreads();
50047 result = (int)((wxSizerFlags const *)arg1)->GetFlags();
50048 wxPyEndAllowThreads(__tstate);
50049 if (PyErr_Occurred()) SWIG_fail;
50050 }
50051 resultobj = SWIG_From_int(static_cast< int >(result));
50052 return resultobj;
50053 fail:
50054 return NULL;
50055 }
50056
50057
50058 SWIGINTERN PyObject *_wrap_SizerFlags_GetBorderInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50059 PyObject *resultobj = 0;
50060 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
50061 int result;
50062 void *argp1 = 0 ;
50063 int res1 = 0 ;
50064 PyObject *swig_obj[1] ;
50065
50066 if (!args) SWIG_fail;
50067 swig_obj[0] = args;
50068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
50069 if (!SWIG_IsOK(res1)) {
50070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetBorderInPixels" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
50071 }
50072 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
50073 {
50074 PyThreadState* __tstate = wxPyBeginAllowThreads();
50075 result = (int)((wxSizerFlags const *)arg1)->GetBorderInPixels();
50076 wxPyEndAllowThreads(__tstate);
50077 if (PyErr_Occurred()) SWIG_fail;
50078 }
50079 resultobj = SWIG_From_int(static_cast< int >(result));
50080 return resultobj;
50081 fail:
50082 return NULL;
50083 }
50084
50085
50086 SWIGINTERN PyObject *SizerFlags_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50087 PyObject *obj;
50088 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50089 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerFlags, SWIG_NewClientData(obj));
50090 return SWIG_Py_Void();
50091 }
50092
50093 SWIGINTERN PyObject *SizerFlags_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50094 return SWIG_Python_InitShadowInstance(args);
50095 }
50096
50097 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50098 PyObject *resultobj = 0;
50099 wxSizerItem *result = 0 ;
50100
50101 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
50102 {
50103 PyThreadState* __tstate = wxPyBeginAllowThreads();
50104 result = (wxSizerItem *)new wxSizerItem();
50105 wxPyEndAllowThreads(__tstate);
50106 if (PyErr_Occurred()) SWIG_fail;
50107 }
50108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
50109 return resultobj;
50110 fail:
50111 return NULL;
50112 }
50113
50114
50115 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50116 PyObject *resultobj = 0;
50117 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50118 void *argp1 = 0 ;
50119 int res1 = 0 ;
50120 PyObject *swig_obj[1] ;
50121
50122 if (!args) SWIG_fail;
50123 swig_obj[0] = args;
50124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50125 if (!SWIG_IsOK(res1)) {
50126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50127 }
50128 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50129 {
50130 PyThreadState* __tstate = wxPyBeginAllowThreads();
50131 delete arg1;
50132
50133 wxPyEndAllowThreads(__tstate);
50134 if (PyErr_Occurred()) SWIG_fail;
50135 }
50136 resultobj = SWIG_Py_Void();
50137 return resultobj;
50138 fail:
50139 return NULL;
50140 }
50141
50142
50143 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50144 PyObject *resultobj = 0;
50145 wxWindow *arg1 = (wxWindow *) 0 ;
50146 int arg2 ;
50147 int arg3 ;
50148 int arg4 ;
50149 PyObject *arg5 = (PyObject *) NULL ;
50150 wxSizerItem *result = 0 ;
50151 void *argp1 = 0 ;
50152 int res1 = 0 ;
50153 int val2 ;
50154 int ecode2 = 0 ;
50155 int val3 ;
50156 int ecode3 = 0 ;
50157 int val4 ;
50158 int ecode4 = 0 ;
50159 PyObject * obj0 = 0 ;
50160 PyObject * obj1 = 0 ;
50161 PyObject * obj2 = 0 ;
50162 PyObject * obj3 = 0 ;
50163 PyObject * obj4 = 0 ;
50164 char * kwnames[] = {
50165 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50166 };
50167
50168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50170 if (!SWIG_IsOK(res1)) {
50171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50172 }
50173 arg1 = reinterpret_cast< wxWindow * >(argp1);
50174 ecode2 = SWIG_AsVal_int(obj1, &val2);
50175 if (!SWIG_IsOK(ecode2)) {
50176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
50177 }
50178 arg2 = static_cast< int >(val2);
50179 ecode3 = SWIG_AsVal_int(obj2, &val3);
50180 if (!SWIG_IsOK(ecode3)) {
50181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
50182 }
50183 arg3 = static_cast< int >(val3);
50184 ecode4 = SWIG_AsVal_int(obj3, &val4);
50185 if (!SWIG_IsOK(ecode4)) {
50186 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50187 }
50188 arg4 = static_cast< int >(val4);
50189 if (obj4) {
50190 arg5 = obj4;
50191 }
50192 {
50193 PyThreadState* __tstate = wxPyBeginAllowThreads();
50194 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
50195 wxPyEndAllowThreads(__tstate);
50196 if (PyErr_Occurred()) SWIG_fail;
50197 }
50198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
50199 return resultobj;
50200 fail:
50201 return NULL;
50202 }
50203
50204
50205 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50206 PyObject *resultobj = 0;
50207 int arg1 ;
50208 int arg2 ;
50209 int arg3 ;
50210 int arg4 ;
50211 int arg5 ;
50212 PyObject *arg6 = (PyObject *) NULL ;
50213 wxSizerItem *result = 0 ;
50214 int val1 ;
50215 int ecode1 = 0 ;
50216 int val2 ;
50217 int ecode2 = 0 ;
50218 int val3 ;
50219 int ecode3 = 0 ;
50220 int val4 ;
50221 int ecode4 = 0 ;
50222 int val5 ;
50223 int ecode5 = 0 ;
50224 PyObject * obj0 = 0 ;
50225 PyObject * obj1 = 0 ;
50226 PyObject * obj2 = 0 ;
50227 PyObject * obj3 = 0 ;
50228 PyObject * obj4 = 0 ;
50229 PyObject * obj5 = 0 ;
50230 char * kwnames[] = {
50231 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50232 };
50233
50234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50235 ecode1 = SWIG_AsVal_int(obj0, &val1);
50236 if (!SWIG_IsOK(ecode1)) {
50237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50238 }
50239 arg1 = static_cast< int >(val1);
50240 ecode2 = SWIG_AsVal_int(obj1, &val2);
50241 if (!SWIG_IsOK(ecode2)) {
50242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50243 }
50244 arg2 = static_cast< int >(val2);
50245 ecode3 = SWIG_AsVal_int(obj2, &val3);
50246 if (!SWIG_IsOK(ecode3)) {
50247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
50248 }
50249 arg3 = static_cast< int >(val3);
50250 ecode4 = SWIG_AsVal_int(obj3, &val4);
50251 if (!SWIG_IsOK(ecode4)) {
50252 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
50253 }
50254 arg4 = static_cast< int >(val4);
50255 ecode5 = SWIG_AsVal_int(obj4, &val5);
50256 if (!SWIG_IsOK(ecode5)) {
50257 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50258 }
50259 arg5 = static_cast< int >(val5);
50260 if (obj5) {
50261 arg6 = obj5;
50262 }
50263 {
50264 PyThreadState* __tstate = wxPyBeginAllowThreads();
50265 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
50266 wxPyEndAllowThreads(__tstate);
50267 if (PyErr_Occurred()) SWIG_fail;
50268 }
50269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
50270 return resultobj;
50271 fail:
50272 return NULL;
50273 }
50274
50275
50276 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50277 PyObject *resultobj = 0;
50278 wxSizer *arg1 = (wxSizer *) 0 ;
50279 int arg2 ;
50280 int arg3 ;
50281 int arg4 ;
50282 PyObject *arg5 = (PyObject *) NULL ;
50283 wxSizerItem *result = 0 ;
50284 int res1 = 0 ;
50285 int val2 ;
50286 int ecode2 = 0 ;
50287 int val3 ;
50288 int ecode3 = 0 ;
50289 int val4 ;
50290 int ecode4 = 0 ;
50291 PyObject * obj0 = 0 ;
50292 PyObject * obj1 = 0 ;
50293 PyObject * obj2 = 0 ;
50294 PyObject * obj3 = 0 ;
50295 PyObject * obj4 = 0 ;
50296 char * kwnames[] = {
50297 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50298 };
50299
50300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50301 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50302 if (!SWIG_IsOK(res1)) {
50303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50304 }
50305 ecode2 = SWIG_AsVal_int(obj1, &val2);
50306 if (!SWIG_IsOK(ecode2)) {
50307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
50308 }
50309 arg2 = static_cast< int >(val2);
50310 ecode3 = SWIG_AsVal_int(obj2, &val3);
50311 if (!SWIG_IsOK(ecode3)) {
50312 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
50313 }
50314 arg3 = static_cast< int >(val3);
50315 ecode4 = SWIG_AsVal_int(obj3, &val4);
50316 if (!SWIG_IsOK(ecode4)) {
50317 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50318 }
50319 arg4 = static_cast< int >(val4);
50320 if (obj4) {
50321 arg5 = obj4;
50322 }
50323 {
50324 PyThreadState* __tstate = wxPyBeginAllowThreads();
50325 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
50326 wxPyEndAllowThreads(__tstate);
50327 if (PyErr_Occurred()) SWIG_fail;
50328 }
50329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
50330 return resultobj;
50331 fail:
50332 return NULL;
50333 }
50334
50335
50336 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50337 PyObject *resultobj = 0;
50338 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50339 void *argp1 = 0 ;
50340 int res1 = 0 ;
50341 PyObject *swig_obj[1] ;
50342
50343 if (!args) SWIG_fail;
50344 swig_obj[0] = args;
50345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50346 if (!SWIG_IsOK(res1)) {
50347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50348 }
50349 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50350 {
50351 PyThreadState* __tstate = wxPyBeginAllowThreads();
50352 (arg1)->DeleteWindows();
50353 wxPyEndAllowThreads(__tstate);
50354 if (PyErr_Occurred()) SWIG_fail;
50355 }
50356 resultobj = SWIG_Py_Void();
50357 return resultobj;
50358 fail:
50359 return NULL;
50360 }
50361
50362
50363 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50364 PyObject *resultobj = 0;
50365 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50366 void *argp1 = 0 ;
50367 int res1 = 0 ;
50368 PyObject *swig_obj[1] ;
50369
50370 if (!args) SWIG_fail;
50371 swig_obj[0] = args;
50372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50373 if (!SWIG_IsOK(res1)) {
50374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50375 }
50376 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50377 {
50378 PyThreadState* __tstate = wxPyBeginAllowThreads();
50379 (arg1)->DetachSizer();
50380 wxPyEndAllowThreads(__tstate);
50381 if (PyErr_Occurred()) SWIG_fail;
50382 }
50383 resultobj = SWIG_Py_Void();
50384 return resultobj;
50385 fail:
50386 return NULL;
50387 }
50388
50389
50390 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50391 PyObject *resultobj = 0;
50392 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50393 wxSize result;
50394 void *argp1 = 0 ;
50395 int res1 = 0 ;
50396 PyObject *swig_obj[1] ;
50397
50398 if (!args) SWIG_fail;
50399 swig_obj[0] = args;
50400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50401 if (!SWIG_IsOK(res1)) {
50402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50403 }
50404 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50405 {
50406 PyThreadState* __tstate = wxPyBeginAllowThreads();
50407 result = (arg1)->GetSize();
50408 wxPyEndAllowThreads(__tstate);
50409 if (PyErr_Occurred()) SWIG_fail;
50410 }
50411 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50412 return resultobj;
50413 fail:
50414 return NULL;
50415 }
50416
50417
50418 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50419 PyObject *resultobj = 0;
50420 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50421 wxSize result;
50422 void *argp1 = 0 ;
50423 int res1 = 0 ;
50424 PyObject *swig_obj[1] ;
50425
50426 if (!args) SWIG_fail;
50427 swig_obj[0] = args;
50428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50429 if (!SWIG_IsOK(res1)) {
50430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50431 }
50432 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50433 {
50434 PyThreadState* __tstate = wxPyBeginAllowThreads();
50435 result = (arg1)->CalcMin();
50436 wxPyEndAllowThreads(__tstate);
50437 if (PyErr_Occurred()) SWIG_fail;
50438 }
50439 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50440 return resultobj;
50441 fail:
50442 return NULL;
50443 }
50444
50445
50446 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50447 PyObject *resultobj = 0;
50448 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50449 wxPoint *arg2 = 0 ;
50450 wxSize *arg3 = 0 ;
50451 void *argp1 = 0 ;
50452 int res1 = 0 ;
50453 wxPoint temp2 ;
50454 wxSize temp3 ;
50455 PyObject * obj0 = 0 ;
50456 PyObject * obj1 = 0 ;
50457 PyObject * obj2 = 0 ;
50458 char * kwnames[] = {
50459 (char *) "self",(char *) "pos",(char *) "size", NULL
50460 };
50461
50462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50464 if (!SWIG_IsOK(res1)) {
50465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50466 }
50467 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50468 {
50469 arg2 = &temp2;
50470 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50471 }
50472 {
50473 arg3 = &temp3;
50474 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50475 }
50476 {
50477 PyThreadState* __tstate = wxPyBeginAllowThreads();
50478 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
50479 wxPyEndAllowThreads(__tstate);
50480 if (PyErr_Occurred()) SWIG_fail;
50481 }
50482 resultobj = SWIG_Py_Void();
50483 return resultobj;
50484 fail:
50485 return NULL;
50486 }
50487
50488
50489 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50490 PyObject *resultobj = 0;
50491 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50492 wxSize result;
50493 void *argp1 = 0 ;
50494 int res1 = 0 ;
50495 PyObject *swig_obj[1] ;
50496
50497 if (!args) SWIG_fail;
50498 swig_obj[0] = args;
50499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50500 if (!SWIG_IsOK(res1)) {
50501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50502 }
50503 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50504 {
50505 PyThreadState* __tstate = wxPyBeginAllowThreads();
50506 result = (arg1)->GetMinSize();
50507 wxPyEndAllowThreads(__tstate);
50508 if (PyErr_Occurred()) SWIG_fail;
50509 }
50510 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50511 return resultobj;
50512 fail:
50513 return NULL;
50514 }
50515
50516
50517 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50518 PyObject *resultobj = 0;
50519 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50520 wxSize result;
50521 void *argp1 = 0 ;
50522 int res1 = 0 ;
50523 PyObject *swig_obj[1] ;
50524
50525 if (!args) SWIG_fail;
50526 swig_obj[0] = args;
50527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50528 if (!SWIG_IsOK(res1)) {
50529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
50530 }
50531 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50532 {
50533 PyThreadState* __tstate = wxPyBeginAllowThreads();
50534 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
50535 wxPyEndAllowThreads(__tstate);
50536 if (PyErr_Occurred()) SWIG_fail;
50537 }
50538 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50539 return resultobj;
50540 fail:
50541 return NULL;
50542 }
50543
50544
50545 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50546 PyObject *resultobj = 0;
50547 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50548 int arg2 ;
50549 int arg3 ;
50550 void *argp1 = 0 ;
50551 int res1 = 0 ;
50552 int val2 ;
50553 int ecode2 = 0 ;
50554 int val3 ;
50555 int ecode3 = 0 ;
50556 PyObject * obj0 = 0 ;
50557 PyObject * obj1 = 0 ;
50558 PyObject * obj2 = 0 ;
50559 char * kwnames[] = {
50560 (char *) "self",(char *) "x",(char *) "y", NULL
50561 };
50562
50563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50565 if (!SWIG_IsOK(res1)) {
50566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50567 }
50568 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50569 ecode2 = SWIG_AsVal_int(obj1, &val2);
50570 if (!SWIG_IsOK(ecode2)) {
50571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
50572 }
50573 arg2 = static_cast< int >(val2);
50574 ecode3 = SWIG_AsVal_int(obj2, &val3);
50575 if (!SWIG_IsOK(ecode3)) {
50576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
50577 }
50578 arg3 = static_cast< int >(val3);
50579 {
50580 PyThreadState* __tstate = wxPyBeginAllowThreads();
50581 (arg1)->SetInitSize(arg2,arg3);
50582 wxPyEndAllowThreads(__tstate);
50583 if (PyErr_Occurred()) SWIG_fail;
50584 }
50585 resultobj = SWIG_Py_Void();
50586 return resultobj;
50587 fail:
50588 return NULL;
50589 }
50590
50591
50592 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50593 PyObject *resultobj = 0;
50594 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50595 int arg2 ;
50596 int arg3 ;
50597 void *argp1 = 0 ;
50598 int res1 = 0 ;
50599 int val2 ;
50600 int ecode2 = 0 ;
50601 int val3 ;
50602 int ecode3 = 0 ;
50603 PyObject * obj0 = 0 ;
50604 PyObject * obj1 = 0 ;
50605 PyObject * obj2 = 0 ;
50606 char * kwnames[] = {
50607 (char *) "self",(char *) "width",(char *) "height", NULL
50608 };
50609
50610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50612 if (!SWIG_IsOK(res1)) {
50613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50614 }
50615 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50616 ecode2 = SWIG_AsVal_int(obj1, &val2);
50617 if (!SWIG_IsOK(ecode2)) {
50618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
50619 }
50620 arg2 = static_cast< int >(val2);
50621 ecode3 = SWIG_AsVal_int(obj2, &val3);
50622 if (!SWIG_IsOK(ecode3)) {
50623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
50624 }
50625 arg3 = static_cast< int >(val3);
50626 {
50627 PyThreadState* __tstate = wxPyBeginAllowThreads();
50628 (arg1)->SetRatio(arg2,arg3);
50629 wxPyEndAllowThreads(__tstate);
50630 if (PyErr_Occurred()) SWIG_fail;
50631 }
50632 resultobj = SWIG_Py_Void();
50633 return resultobj;
50634 fail:
50635 return NULL;
50636 }
50637
50638
50639 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50640 PyObject *resultobj = 0;
50641 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50642 wxSize *arg2 = 0 ;
50643 void *argp1 = 0 ;
50644 int res1 = 0 ;
50645 wxSize temp2 ;
50646 PyObject * obj0 = 0 ;
50647 PyObject * obj1 = 0 ;
50648 char * kwnames[] = {
50649 (char *) "self",(char *) "size", NULL
50650 };
50651
50652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
50653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50654 if (!SWIG_IsOK(res1)) {
50655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50656 }
50657 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50658 {
50659 arg2 = &temp2;
50660 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50661 }
50662 {
50663 PyThreadState* __tstate = wxPyBeginAllowThreads();
50664 (arg1)->SetRatio((wxSize const &)*arg2);
50665 wxPyEndAllowThreads(__tstate);
50666 if (PyErr_Occurred()) SWIG_fail;
50667 }
50668 resultobj = SWIG_Py_Void();
50669 return resultobj;
50670 fail:
50671 return NULL;
50672 }
50673
50674
50675 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50676 PyObject *resultobj = 0;
50677 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50678 float arg2 ;
50679 void *argp1 = 0 ;
50680 int res1 = 0 ;
50681 float val2 ;
50682 int ecode2 = 0 ;
50683 PyObject * obj0 = 0 ;
50684 PyObject * obj1 = 0 ;
50685 char * kwnames[] = {
50686 (char *) "self",(char *) "ratio", NULL
50687 };
50688
50689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
50690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50691 if (!SWIG_IsOK(res1)) {
50692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50693 }
50694 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50695 ecode2 = SWIG_AsVal_float(obj1, &val2);
50696 if (!SWIG_IsOK(ecode2)) {
50697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
50698 }
50699 arg2 = static_cast< float >(val2);
50700 {
50701 PyThreadState* __tstate = wxPyBeginAllowThreads();
50702 (arg1)->SetRatio(arg2);
50703 wxPyEndAllowThreads(__tstate);
50704 if (PyErr_Occurred()) SWIG_fail;
50705 }
50706 resultobj = SWIG_Py_Void();
50707 return resultobj;
50708 fail:
50709 return NULL;
50710 }
50711
50712
50713 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50714 PyObject *resultobj = 0;
50715 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50716 float result;
50717 void *argp1 = 0 ;
50718 int res1 = 0 ;
50719 PyObject *swig_obj[1] ;
50720
50721 if (!args) SWIG_fail;
50722 swig_obj[0] = args;
50723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50724 if (!SWIG_IsOK(res1)) {
50725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50726 }
50727 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50728 {
50729 PyThreadState* __tstate = wxPyBeginAllowThreads();
50730 result = (float)(arg1)->GetRatio();
50731 wxPyEndAllowThreads(__tstate);
50732 if (PyErr_Occurred()) SWIG_fail;
50733 }
50734 resultobj = SWIG_From_float(static_cast< float >(result));
50735 return resultobj;
50736 fail:
50737 return NULL;
50738 }
50739
50740
50741 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50742 PyObject *resultobj = 0;
50743 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50744 wxRect result;
50745 void *argp1 = 0 ;
50746 int res1 = 0 ;
50747 PyObject *swig_obj[1] ;
50748
50749 if (!args) SWIG_fail;
50750 swig_obj[0] = args;
50751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50752 if (!SWIG_IsOK(res1)) {
50753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50754 }
50755 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50756 {
50757 PyThreadState* __tstate = wxPyBeginAllowThreads();
50758 result = (arg1)->GetRect();
50759 wxPyEndAllowThreads(__tstate);
50760 if (PyErr_Occurred()) SWIG_fail;
50761 }
50762 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
50763 return resultobj;
50764 fail:
50765 return NULL;
50766 }
50767
50768
50769 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50770 PyObject *resultobj = 0;
50771 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50772 bool result;
50773 void *argp1 = 0 ;
50774 int res1 = 0 ;
50775 PyObject *swig_obj[1] ;
50776
50777 if (!args) SWIG_fail;
50778 swig_obj[0] = args;
50779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50780 if (!SWIG_IsOK(res1)) {
50781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50782 }
50783 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50784 {
50785 PyThreadState* __tstate = wxPyBeginAllowThreads();
50786 result = (bool)(arg1)->IsWindow();
50787 wxPyEndAllowThreads(__tstate);
50788 if (PyErr_Occurred()) SWIG_fail;
50789 }
50790 {
50791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50792 }
50793 return resultobj;
50794 fail:
50795 return NULL;
50796 }
50797
50798
50799 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50800 PyObject *resultobj = 0;
50801 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50802 bool result;
50803 void *argp1 = 0 ;
50804 int res1 = 0 ;
50805 PyObject *swig_obj[1] ;
50806
50807 if (!args) SWIG_fail;
50808 swig_obj[0] = args;
50809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50810 if (!SWIG_IsOK(res1)) {
50811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50812 }
50813 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50814 {
50815 PyThreadState* __tstate = wxPyBeginAllowThreads();
50816 result = (bool)(arg1)->IsSizer();
50817 wxPyEndAllowThreads(__tstate);
50818 if (PyErr_Occurred()) SWIG_fail;
50819 }
50820 {
50821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50822 }
50823 return resultobj;
50824 fail:
50825 return NULL;
50826 }
50827
50828
50829 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50830 PyObject *resultobj = 0;
50831 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50832 bool result;
50833 void *argp1 = 0 ;
50834 int res1 = 0 ;
50835 PyObject *swig_obj[1] ;
50836
50837 if (!args) SWIG_fail;
50838 swig_obj[0] = args;
50839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50840 if (!SWIG_IsOK(res1)) {
50841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50842 }
50843 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50844 {
50845 PyThreadState* __tstate = wxPyBeginAllowThreads();
50846 result = (bool)(arg1)->IsSpacer();
50847 wxPyEndAllowThreads(__tstate);
50848 if (PyErr_Occurred()) SWIG_fail;
50849 }
50850 {
50851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50852 }
50853 return resultobj;
50854 fail:
50855 return NULL;
50856 }
50857
50858
50859 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50860 PyObject *resultobj = 0;
50861 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50862 int arg2 ;
50863 void *argp1 = 0 ;
50864 int res1 = 0 ;
50865 int val2 ;
50866 int ecode2 = 0 ;
50867 PyObject * obj0 = 0 ;
50868 PyObject * obj1 = 0 ;
50869 char * kwnames[] = {
50870 (char *) "self",(char *) "proportion", NULL
50871 };
50872
50873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
50874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50875 if (!SWIG_IsOK(res1)) {
50876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50877 }
50878 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50879 ecode2 = SWIG_AsVal_int(obj1, &val2);
50880 if (!SWIG_IsOK(ecode2)) {
50881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
50882 }
50883 arg2 = static_cast< int >(val2);
50884 {
50885 PyThreadState* __tstate = wxPyBeginAllowThreads();
50886 (arg1)->SetProportion(arg2);
50887 wxPyEndAllowThreads(__tstate);
50888 if (PyErr_Occurred()) SWIG_fail;
50889 }
50890 resultobj = SWIG_Py_Void();
50891 return resultobj;
50892 fail:
50893 return NULL;
50894 }
50895
50896
50897 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50898 PyObject *resultobj = 0;
50899 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50900 int result;
50901 void *argp1 = 0 ;
50902 int res1 = 0 ;
50903 PyObject *swig_obj[1] ;
50904
50905 if (!args) SWIG_fail;
50906 swig_obj[0] = args;
50907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50908 if (!SWIG_IsOK(res1)) {
50909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50910 }
50911 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50912 {
50913 PyThreadState* __tstate = wxPyBeginAllowThreads();
50914 result = (int)(arg1)->GetProportion();
50915 wxPyEndAllowThreads(__tstate);
50916 if (PyErr_Occurred()) SWIG_fail;
50917 }
50918 resultobj = SWIG_From_int(static_cast< int >(result));
50919 return resultobj;
50920 fail:
50921 return NULL;
50922 }
50923
50924
50925 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50926 PyObject *resultobj = 0;
50927 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50928 int arg2 ;
50929 void *argp1 = 0 ;
50930 int res1 = 0 ;
50931 int val2 ;
50932 int ecode2 = 0 ;
50933 PyObject * obj0 = 0 ;
50934 PyObject * obj1 = 0 ;
50935 char * kwnames[] = {
50936 (char *) "self",(char *) "flag", NULL
50937 };
50938
50939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
50940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50941 if (!SWIG_IsOK(res1)) {
50942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50943 }
50944 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50945 ecode2 = SWIG_AsVal_int(obj1, &val2);
50946 if (!SWIG_IsOK(ecode2)) {
50947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
50948 }
50949 arg2 = static_cast< int >(val2);
50950 {
50951 PyThreadState* __tstate = wxPyBeginAllowThreads();
50952 (arg1)->SetFlag(arg2);
50953 wxPyEndAllowThreads(__tstate);
50954 if (PyErr_Occurred()) SWIG_fail;
50955 }
50956 resultobj = SWIG_Py_Void();
50957 return resultobj;
50958 fail:
50959 return NULL;
50960 }
50961
50962
50963 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50964 PyObject *resultobj = 0;
50965 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50966 int result;
50967 void *argp1 = 0 ;
50968 int res1 = 0 ;
50969 PyObject *swig_obj[1] ;
50970
50971 if (!args) SWIG_fail;
50972 swig_obj[0] = args;
50973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50974 if (!SWIG_IsOK(res1)) {
50975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50976 }
50977 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50978 {
50979 PyThreadState* __tstate = wxPyBeginAllowThreads();
50980 result = (int)(arg1)->GetFlag();
50981 wxPyEndAllowThreads(__tstate);
50982 if (PyErr_Occurred()) SWIG_fail;
50983 }
50984 resultobj = SWIG_From_int(static_cast< int >(result));
50985 return resultobj;
50986 fail:
50987 return NULL;
50988 }
50989
50990
50991 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50992 PyObject *resultobj = 0;
50993 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50994 int arg2 ;
50995 void *argp1 = 0 ;
50996 int res1 = 0 ;
50997 int val2 ;
50998 int ecode2 = 0 ;
50999 PyObject * obj0 = 0 ;
51000 PyObject * obj1 = 0 ;
51001 char * kwnames[] = {
51002 (char *) "self",(char *) "border", NULL
51003 };
51004
51005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
51006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51007 if (!SWIG_IsOK(res1)) {
51008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51009 }
51010 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51011 ecode2 = SWIG_AsVal_int(obj1, &val2);
51012 if (!SWIG_IsOK(ecode2)) {
51013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
51014 }
51015 arg2 = static_cast< int >(val2);
51016 {
51017 PyThreadState* __tstate = wxPyBeginAllowThreads();
51018 (arg1)->SetBorder(arg2);
51019 wxPyEndAllowThreads(__tstate);
51020 if (PyErr_Occurred()) SWIG_fail;
51021 }
51022 resultobj = SWIG_Py_Void();
51023 return resultobj;
51024 fail:
51025 return NULL;
51026 }
51027
51028
51029 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51030 PyObject *resultobj = 0;
51031 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51032 int result;
51033 void *argp1 = 0 ;
51034 int res1 = 0 ;
51035 PyObject *swig_obj[1] ;
51036
51037 if (!args) SWIG_fail;
51038 swig_obj[0] = args;
51039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51040 if (!SWIG_IsOK(res1)) {
51041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51042 }
51043 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51044 {
51045 PyThreadState* __tstate = wxPyBeginAllowThreads();
51046 result = (int)(arg1)->GetBorder();
51047 wxPyEndAllowThreads(__tstate);
51048 if (PyErr_Occurred()) SWIG_fail;
51049 }
51050 resultobj = SWIG_From_int(static_cast< int >(result));
51051 return resultobj;
51052 fail:
51053 return NULL;
51054 }
51055
51056
51057 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51058 PyObject *resultobj = 0;
51059 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51060 wxWindow *result = 0 ;
51061 void *argp1 = 0 ;
51062 int res1 = 0 ;
51063 PyObject *swig_obj[1] ;
51064
51065 if (!args) SWIG_fail;
51066 swig_obj[0] = args;
51067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51068 if (!SWIG_IsOK(res1)) {
51069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51070 }
51071 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51072 {
51073 PyThreadState* __tstate = wxPyBeginAllowThreads();
51074 result = (wxWindow *)(arg1)->GetWindow();
51075 wxPyEndAllowThreads(__tstate);
51076 if (PyErr_Occurred()) SWIG_fail;
51077 }
51078 {
51079 resultobj = wxPyMake_wxObject(result, 0);
51080 }
51081 return resultobj;
51082 fail:
51083 return NULL;
51084 }
51085
51086
51087 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51088 PyObject *resultobj = 0;
51089 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51090 wxSizer *result = 0 ;
51091 void *argp1 = 0 ;
51092 int res1 = 0 ;
51093 PyObject *swig_obj[1] ;
51094
51095 if (!args) SWIG_fail;
51096 swig_obj[0] = args;
51097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51098 if (!SWIG_IsOK(res1)) {
51099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51100 }
51101 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51102 {
51103 PyThreadState* __tstate = wxPyBeginAllowThreads();
51104 result = (wxSizer *)(arg1)->GetSizer();
51105 wxPyEndAllowThreads(__tstate);
51106 if (PyErr_Occurred()) SWIG_fail;
51107 }
51108 {
51109 resultobj = wxPyMake_wxObject(result, (bool)0);
51110 }
51111 return resultobj;
51112 fail:
51113 return NULL;
51114 }
51115
51116
51117 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51118 PyObject *resultobj = 0;
51119 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51120 wxSize result;
51121 void *argp1 = 0 ;
51122 int res1 = 0 ;
51123 PyObject *swig_obj[1] ;
51124
51125 if (!args) SWIG_fail;
51126 swig_obj[0] = args;
51127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51128 if (!SWIG_IsOK(res1)) {
51129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51130 }
51131 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51132 {
51133 PyThreadState* __tstate = wxPyBeginAllowThreads();
51134 result = (arg1)->GetSpacer();
51135 wxPyEndAllowThreads(__tstate);
51136 if (PyErr_Occurred()) SWIG_fail;
51137 }
51138 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51139 return resultobj;
51140 fail:
51141 return NULL;
51142 }
51143
51144
51145 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51146 PyObject *resultobj = 0;
51147 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51148 wxWindow *arg2 = (wxWindow *) 0 ;
51149 void *argp1 = 0 ;
51150 int res1 = 0 ;
51151 void *argp2 = 0 ;
51152 int res2 = 0 ;
51153 PyObject * obj0 = 0 ;
51154 PyObject * obj1 = 0 ;
51155 char * kwnames[] = {
51156 (char *) "self",(char *) "window", NULL
51157 };
51158
51159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
51160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51161 if (!SWIG_IsOK(res1)) {
51162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51163 }
51164 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51165 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51166 if (!SWIG_IsOK(res2)) {
51167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
51168 }
51169 arg2 = reinterpret_cast< wxWindow * >(argp2);
51170 {
51171 PyThreadState* __tstate = wxPyBeginAllowThreads();
51172 (arg1)->SetWindow(arg2);
51173 wxPyEndAllowThreads(__tstate);
51174 if (PyErr_Occurred()) SWIG_fail;
51175 }
51176 resultobj = SWIG_Py_Void();
51177 return resultobj;
51178 fail:
51179 return NULL;
51180 }
51181
51182
51183 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51184 PyObject *resultobj = 0;
51185 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51186 wxSizer *arg2 = (wxSizer *) 0 ;
51187 void *argp1 = 0 ;
51188 int res1 = 0 ;
51189 int res2 = 0 ;
51190 PyObject * obj0 = 0 ;
51191 PyObject * obj1 = 0 ;
51192 char * kwnames[] = {
51193 (char *) "self",(char *) "sizer", NULL
51194 };
51195
51196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51198 if (!SWIG_IsOK(res1)) {
51199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51200 }
51201 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51202 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51203 if (!SWIG_IsOK(res2)) {
51204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
51205 }
51206 {
51207 PyThreadState* __tstate = wxPyBeginAllowThreads();
51208 (arg1)->SetSizer(arg2);
51209 wxPyEndAllowThreads(__tstate);
51210 if (PyErr_Occurred()) SWIG_fail;
51211 }
51212 resultobj = SWIG_Py_Void();
51213 return resultobj;
51214 fail:
51215 return NULL;
51216 }
51217
51218
51219 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51220 PyObject *resultobj = 0;
51221 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51222 wxSize *arg2 = 0 ;
51223 void *argp1 = 0 ;
51224 int res1 = 0 ;
51225 wxSize temp2 ;
51226 PyObject * obj0 = 0 ;
51227 PyObject * obj1 = 0 ;
51228 char * kwnames[] = {
51229 (char *) "self",(char *) "size", NULL
51230 };
51231
51232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
51233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51234 if (!SWIG_IsOK(res1)) {
51235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51236 }
51237 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51238 {
51239 arg2 = &temp2;
51240 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51241 }
51242 {
51243 PyThreadState* __tstate = wxPyBeginAllowThreads();
51244 (arg1)->SetSpacer((wxSize const &)*arg2);
51245 wxPyEndAllowThreads(__tstate);
51246 if (PyErr_Occurred()) SWIG_fail;
51247 }
51248 resultobj = SWIG_Py_Void();
51249 return resultobj;
51250 fail:
51251 return NULL;
51252 }
51253
51254
51255 SWIGINTERN PyObject *_wrap_SizerItem_AssignWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51256 PyObject *resultobj = 0;
51257 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51258 wxWindow *arg2 = (wxWindow *) 0 ;
51259 void *argp1 = 0 ;
51260 int res1 = 0 ;
51261 void *argp2 = 0 ;
51262 int res2 = 0 ;
51263 PyObject * obj0 = 0 ;
51264 PyObject * obj1 = 0 ;
51265 char * kwnames[] = {
51266 (char *) "self",(char *) "window", NULL
51267 };
51268
51269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignWindow",kwnames,&obj0,&obj1)) SWIG_fail;
51270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51271 if (!SWIG_IsOK(res1)) {
51272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51273 }
51274 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51275 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51276 if (!SWIG_IsOK(res2)) {
51277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_AssignWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
51278 }
51279 arg2 = reinterpret_cast< wxWindow * >(argp2);
51280 {
51281 PyThreadState* __tstate = wxPyBeginAllowThreads();
51282 (arg1)->AssignWindow(arg2);
51283 wxPyEndAllowThreads(__tstate);
51284 if (PyErr_Occurred()) SWIG_fail;
51285 }
51286 resultobj = SWIG_Py_Void();
51287 return resultobj;
51288 fail:
51289 return NULL;
51290 }
51291
51292
51293 SWIGINTERN PyObject *_wrap_SizerItem_AssignSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51294 PyObject *resultobj = 0;
51295 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51296 wxSizer *arg2 = (wxSizer *) 0 ;
51297 void *argp1 = 0 ;
51298 int res1 = 0 ;
51299 void *argp2 = 0 ;
51300 int res2 = 0 ;
51301 PyObject * obj0 = 0 ;
51302 PyObject * obj1 = 0 ;
51303 char * kwnames[] = {
51304 (char *) "self",(char *) "sizer", NULL
51305 };
51306
51307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51309 if (!SWIG_IsOK(res1)) {
51310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51311 }
51312 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51313 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51314 if (!SWIG_IsOK(res2)) {
51315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_AssignSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
51316 }
51317 arg2 = reinterpret_cast< wxSizer * >(argp2);
51318 {
51319 PyThreadState* __tstate = wxPyBeginAllowThreads();
51320 (arg1)->AssignSizer(arg2);
51321 wxPyEndAllowThreads(__tstate);
51322 if (PyErr_Occurred()) SWIG_fail;
51323 }
51324 resultobj = SWIG_Py_Void();
51325 return resultobj;
51326 fail:
51327 return NULL;
51328 }
51329
51330
51331 SWIGINTERN PyObject *_wrap_SizerItem_AssignSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51332 PyObject *resultobj = 0;
51333 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51334 wxSize *arg2 = 0 ;
51335 void *argp1 = 0 ;
51336 int res1 = 0 ;
51337 wxSize temp2 ;
51338 PyObject * obj0 = 0 ;
51339 PyObject * obj1 = 0 ;
51340 char * kwnames[] = {
51341 (char *) "self",(char *) "size", NULL
51342 };
51343
51344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
51345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51346 if (!SWIG_IsOK(res1)) {
51347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51348 }
51349 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51350 {
51351 arg2 = &temp2;
51352 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51353 }
51354 {
51355 PyThreadState* __tstate = wxPyBeginAllowThreads();
51356 (arg1)->AssignSpacer((wxSize const &)*arg2);
51357 wxPyEndAllowThreads(__tstate);
51358 if (PyErr_Occurred()) SWIG_fail;
51359 }
51360 resultobj = SWIG_Py_Void();
51361 return resultobj;
51362 fail:
51363 return NULL;
51364 }
51365
51366
51367 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51368 PyObject *resultobj = 0;
51369 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51370 bool arg2 ;
51371 void *argp1 = 0 ;
51372 int res1 = 0 ;
51373 bool val2 ;
51374 int ecode2 = 0 ;
51375 PyObject * obj0 = 0 ;
51376 PyObject * obj1 = 0 ;
51377 char * kwnames[] = {
51378 (char *) "self",(char *) "show", NULL
51379 };
51380
51381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
51382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51383 if (!SWIG_IsOK(res1)) {
51384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51385 }
51386 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51387 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51388 if (!SWIG_IsOK(ecode2)) {
51389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
51390 }
51391 arg2 = static_cast< bool >(val2);
51392 {
51393 PyThreadState* __tstate = wxPyBeginAllowThreads();
51394 (arg1)->Show(arg2);
51395 wxPyEndAllowThreads(__tstate);
51396 if (PyErr_Occurred()) SWIG_fail;
51397 }
51398 resultobj = SWIG_Py_Void();
51399 return resultobj;
51400 fail:
51401 return NULL;
51402 }
51403
51404
51405 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51406 PyObject *resultobj = 0;
51407 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51408 bool result;
51409 void *argp1 = 0 ;
51410 int res1 = 0 ;
51411 PyObject *swig_obj[1] ;
51412
51413 if (!args) SWIG_fail;
51414 swig_obj[0] = args;
51415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51416 if (!SWIG_IsOK(res1)) {
51417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51418 }
51419 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51420 {
51421 PyThreadState* __tstate = wxPyBeginAllowThreads();
51422 result = (bool)(arg1)->IsShown();
51423 wxPyEndAllowThreads(__tstate);
51424 if (PyErr_Occurred()) SWIG_fail;
51425 }
51426 {
51427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51428 }
51429 return resultobj;
51430 fail:
51431 return NULL;
51432 }
51433
51434
51435 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51436 PyObject *resultobj = 0;
51437 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51438 wxPoint result;
51439 void *argp1 = 0 ;
51440 int res1 = 0 ;
51441 PyObject *swig_obj[1] ;
51442
51443 if (!args) SWIG_fail;
51444 swig_obj[0] = args;
51445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51446 if (!SWIG_IsOK(res1)) {
51447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51448 }
51449 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51450 {
51451 PyThreadState* __tstate = wxPyBeginAllowThreads();
51452 result = (arg1)->GetPosition();
51453 wxPyEndAllowThreads(__tstate);
51454 if (PyErr_Occurred()) SWIG_fail;
51455 }
51456 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
51457 return resultobj;
51458 fail:
51459 return NULL;
51460 }
51461
51462
51463 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51464 PyObject *resultobj = 0;
51465 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51466 PyObject *result = 0 ;
51467 void *argp1 = 0 ;
51468 int res1 = 0 ;
51469 PyObject *swig_obj[1] ;
51470
51471 if (!args) SWIG_fail;
51472 swig_obj[0] = args;
51473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51474 if (!SWIG_IsOK(res1)) {
51475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51476 }
51477 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51478 {
51479 PyThreadState* __tstate = wxPyBeginAllowThreads();
51480 result = (PyObject *)wxSizerItem_GetUserData(arg1);
51481 wxPyEndAllowThreads(__tstate);
51482 if (PyErr_Occurred()) SWIG_fail;
51483 }
51484 resultobj = result;
51485 return resultobj;
51486 fail:
51487 return NULL;
51488 }
51489
51490
51491 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51492 PyObject *resultobj = 0;
51493 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51494 PyObject *arg2 = (PyObject *) 0 ;
51495 void *argp1 = 0 ;
51496 int res1 = 0 ;
51497 PyObject * obj0 = 0 ;
51498 PyObject * obj1 = 0 ;
51499 char * kwnames[] = {
51500 (char *) "self",(char *) "userData", NULL
51501 };
51502
51503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
51504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51505 if (!SWIG_IsOK(res1)) {
51506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51507 }
51508 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51509 arg2 = obj1;
51510 {
51511 PyThreadState* __tstate = wxPyBeginAllowThreads();
51512 wxSizerItem_SetUserData(arg1,arg2);
51513 wxPyEndAllowThreads(__tstate);
51514 if (PyErr_Occurred()) SWIG_fail;
51515 }
51516 resultobj = SWIG_Py_Void();
51517 return resultobj;
51518 fail:
51519 return NULL;
51520 }
51521
51522
51523 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51524 PyObject *obj;
51525 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51526 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
51527 return SWIG_Py_Void();
51528 }
51529
51530 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51531 return SWIG_Python_InitShadowInstance(args);
51532 }
51533
51534 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51535 PyObject *resultobj = 0;
51536 wxSizer *arg1 = (wxSizer *) 0 ;
51537 void *argp1 = 0 ;
51538 int res1 = 0 ;
51539 PyObject *swig_obj[1] ;
51540
51541 if (!args) SWIG_fail;
51542 swig_obj[0] = args;
51543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51544 if (!SWIG_IsOK(res1)) {
51545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51546 }
51547 arg1 = reinterpret_cast< wxSizer * >(argp1);
51548 {
51549 PyThreadState* __tstate = wxPyBeginAllowThreads();
51550 delete arg1;
51551
51552 wxPyEndAllowThreads(__tstate);
51553 if (PyErr_Occurred()) SWIG_fail;
51554 }
51555 resultobj = SWIG_Py_Void();
51556 return resultobj;
51557 fail:
51558 return NULL;
51559 }
51560
51561
51562 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51563 PyObject *resultobj = 0;
51564 wxSizer *arg1 = (wxSizer *) 0 ;
51565 PyObject *arg2 = (PyObject *) 0 ;
51566 void *argp1 = 0 ;
51567 int res1 = 0 ;
51568 PyObject * obj0 = 0 ;
51569 PyObject * obj1 = 0 ;
51570 char * kwnames[] = {
51571 (char *) "self",(char *) "_self", NULL
51572 };
51573
51574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
51575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51576 if (!SWIG_IsOK(res1)) {
51577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
51578 }
51579 arg1 = reinterpret_cast< wxSizer * >(argp1);
51580 arg2 = obj1;
51581 {
51582 PyThreadState* __tstate = wxPyBeginAllowThreads();
51583 wxSizer__setOORInfo(arg1,arg2);
51584 wxPyEndAllowThreads(__tstate);
51585 if (PyErr_Occurred()) SWIG_fail;
51586 }
51587 resultobj = SWIG_Py_Void();
51588 return resultobj;
51589 fail:
51590 return NULL;
51591 }
51592
51593
51594 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51595 PyObject *resultobj = 0;
51596 wxSizer *arg1 = (wxSizer *) 0 ;
51597 PyObject *arg2 = (PyObject *) 0 ;
51598 int arg3 = (int) 0 ;
51599 int arg4 = (int) 0 ;
51600 int arg5 = (int) 0 ;
51601 PyObject *arg6 = (PyObject *) NULL ;
51602 wxSizerItem *result = 0 ;
51603 void *argp1 = 0 ;
51604 int res1 = 0 ;
51605 int val3 ;
51606 int ecode3 = 0 ;
51607 int val4 ;
51608 int ecode4 = 0 ;
51609 int val5 ;
51610 int ecode5 = 0 ;
51611 PyObject * obj0 = 0 ;
51612 PyObject * obj1 = 0 ;
51613 PyObject * obj2 = 0 ;
51614 PyObject * obj3 = 0 ;
51615 PyObject * obj4 = 0 ;
51616 PyObject * obj5 = 0 ;
51617 char * kwnames[] = {
51618 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51619 };
51620
51621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51623 if (!SWIG_IsOK(res1)) {
51624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
51625 }
51626 arg1 = reinterpret_cast< wxSizer * >(argp1);
51627 arg2 = obj1;
51628 if (obj2) {
51629 ecode3 = SWIG_AsVal_int(obj2, &val3);
51630 if (!SWIG_IsOK(ecode3)) {
51631 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
51632 }
51633 arg3 = static_cast< int >(val3);
51634 }
51635 if (obj3) {
51636 ecode4 = SWIG_AsVal_int(obj3, &val4);
51637 if (!SWIG_IsOK(ecode4)) {
51638 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
51639 }
51640 arg4 = static_cast< int >(val4);
51641 }
51642 if (obj4) {
51643 ecode5 = SWIG_AsVal_int(obj4, &val5);
51644 if (!SWIG_IsOK(ecode5)) {
51645 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
51646 }
51647 arg5 = static_cast< int >(val5);
51648 }
51649 if (obj5) {
51650 arg6 = obj5;
51651 }
51652 {
51653 PyThreadState* __tstate = wxPyBeginAllowThreads();
51654 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
51655 wxPyEndAllowThreads(__tstate);
51656 if (PyErr_Occurred()) SWIG_fail;
51657 }
51658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51659 return resultobj;
51660 fail:
51661 return NULL;
51662 }
51663
51664
51665 SWIGINTERN PyObject *_wrap_Sizer_AddF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51666 PyObject *resultobj = 0;
51667 wxSizer *arg1 = (wxSizer *) 0 ;
51668 PyObject *arg2 = (PyObject *) 0 ;
51669 wxSizerFlags *arg3 = 0 ;
51670 wxSizerItem *result = 0 ;
51671 void *argp1 = 0 ;
51672 int res1 = 0 ;
51673 void *argp3 = 0 ;
51674 int res3 = 0 ;
51675 PyObject * obj0 = 0 ;
51676 PyObject * obj1 = 0 ;
51677 PyObject * obj2 = 0 ;
51678 char * kwnames[] = {
51679 (char *) "self",(char *) "item",(char *) "flags", NULL
51680 };
51681
51682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_AddF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51684 if (!SWIG_IsOK(res1)) {
51685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddF" "', expected argument " "1"" of type '" "wxSizer *""'");
51686 }
51687 arg1 = reinterpret_cast< wxSizer * >(argp1);
51688 arg2 = obj1;
51689 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51690 if (!SWIG_IsOK(res3)) {
51691 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51692 }
51693 if (!argp3) {
51694 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51695 }
51696 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51697 {
51698 PyThreadState* __tstate = wxPyBeginAllowThreads();
51699 result = (wxSizerItem *)wxSizer_AddF(arg1,arg2,*arg3);
51700 wxPyEndAllowThreads(__tstate);
51701 if (PyErr_Occurred()) SWIG_fail;
51702 }
51703 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51704 return resultobj;
51705 fail:
51706 return NULL;
51707 }
51708
51709
51710 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51711 PyObject *resultobj = 0;
51712 wxSizer *arg1 = (wxSizer *) 0 ;
51713 int arg2 ;
51714 PyObject *arg3 = (PyObject *) 0 ;
51715 int arg4 = (int) 0 ;
51716 int arg5 = (int) 0 ;
51717 int arg6 = (int) 0 ;
51718 PyObject *arg7 = (PyObject *) NULL ;
51719 wxSizerItem *result = 0 ;
51720 void *argp1 = 0 ;
51721 int res1 = 0 ;
51722 int val2 ;
51723 int ecode2 = 0 ;
51724 int val4 ;
51725 int ecode4 = 0 ;
51726 int val5 ;
51727 int ecode5 = 0 ;
51728 int val6 ;
51729 int ecode6 = 0 ;
51730 PyObject * obj0 = 0 ;
51731 PyObject * obj1 = 0 ;
51732 PyObject * obj2 = 0 ;
51733 PyObject * obj3 = 0 ;
51734 PyObject * obj4 = 0 ;
51735 PyObject * obj5 = 0 ;
51736 PyObject * obj6 = 0 ;
51737 char * kwnames[] = {
51738 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51739 };
51740
51741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51743 if (!SWIG_IsOK(res1)) {
51744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
51745 }
51746 arg1 = reinterpret_cast< wxSizer * >(argp1);
51747 ecode2 = SWIG_AsVal_int(obj1, &val2);
51748 if (!SWIG_IsOK(ecode2)) {
51749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
51750 }
51751 arg2 = static_cast< int >(val2);
51752 arg3 = obj2;
51753 if (obj3) {
51754 ecode4 = SWIG_AsVal_int(obj3, &val4);
51755 if (!SWIG_IsOK(ecode4)) {
51756 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
51757 }
51758 arg4 = static_cast< int >(val4);
51759 }
51760 if (obj4) {
51761 ecode5 = SWIG_AsVal_int(obj4, &val5);
51762 if (!SWIG_IsOK(ecode5)) {
51763 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
51764 }
51765 arg5 = static_cast< int >(val5);
51766 }
51767 if (obj5) {
51768 ecode6 = SWIG_AsVal_int(obj5, &val6);
51769 if (!SWIG_IsOK(ecode6)) {
51770 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
51771 }
51772 arg6 = static_cast< int >(val6);
51773 }
51774 if (obj6) {
51775 arg7 = obj6;
51776 }
51777 {
51778 PyThreadState* __tstate = wxPyBeginAllowThreads();
51779 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
51780 wxPyEndAllowThreads(__tstate);
51781 if (PyErr_Occurred()) SWIG_fail;
51782 }
51783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51784 return resultobj;
51785 fail:
51786 return NULL;
51787 }
51788
51789
51790 SWIGINTERN PyObject *_wrap_Sizer_InsertF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51791 PyObject *resultobj = 0;
51792 wxSizer *arg1 = (wxSizer *) 0 ;
51793 int arg2 ;
51794 PyObject *arg3 = (PyObject *) 0 ;
51795 wxSizerFlags *arg4 = 0 ;
51796 wxSizerItem *result = 0 ;
51797 void *argp1 = 0 ;
51798 int res1 = 0 ;
51799 int val2 ;
51800 int ecode2 = 0 ;
51801 void *argp4 = 0 ;
51802 int res4 = 0 ;
51803 PyObject * obj0 = 0 ;
51804 PyObject * obj1 = 0 ;
51805 PyObject * obj2 = 0 ;
51806 PyObject * obj3 = 0 ;
51807 char * kwnames[] = {
51808 (char *) "self",(char *) "before",(char *) "item",(char *) "flags", NULL
51809 };
51810
51811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Sizer_InsertF",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51813 if (!SWIG_IsOK(res1)) {
51814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertF" "', expected argument " "1"" of type '" "wxSizer *""'");
51815 }
51816 arg1 = reinterpret_cast< wxSizer * >(argp1);
51817 ecode2 = SWIG_AsVal_int(obj1, &val2);
51818 if (!SWIG_IsOK(ecode2)) {
51819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertF" "', expected argument " "2"" of type '" "int""'");
51820 }
51821 arg2 = static_cast< int >(val2);
51822 arg3 = obj2;
51823 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxSizerFlags, 0 );
51824 if (!SWIG_IsOK(res4)) {
51825 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51826 }
51827 if (!argp4) {
51828 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51829 }
51830 arg4 = reinterpret_cast< wxSizerFlags * >(argp4);
51831 {
51832 PyThreadState* __tstate = wxPyBeginAllowThreads();
51833 result = (wxSizerItem *)wxSizer_InsertF(arg1,arg2,arg3,*arg4);
51834 wxPyEndAllowThreads(__tstate);
51835 if (PyErr_Occurred()) SWIG_fail;
51836 }
51837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51838 return resultobj;
51839 fail:
51840 return NULL;
51841 }
51842
51843
51844 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51845 PyObject *resultobj = 0;
51846 wxSizer *arg1 = (wxSizer *) 0 ;
51847 PyObject *arg2 = (PyObject *) 0 ;
51848 int arg3 = (int) 0 ;
51849 int arg4 = (int) 0 ;
51850 int arg5 = (int) 0 ;
51851 PyObject *arg6 = (PyObject *) NULL ;
51852 wxSizerItem *result = 0 ;
51853 void *argp1 = 0 ;
51854 int res1 = 0 ;
51855 int val3 ;
51856 int ecode3 = 0 ;
51857 int val4 ;
51858 int ecode4 = 0 ;
51859 int val5 ;
51860 int ecode5 = 0 ;
51861 PyObject * obj0 = 0 ;
51862 PyObject * obj1 = 0 ;
51863 PyObject * obj2 = 0 ;
51864 PyObject * obj3 = 0 ;
51865 PyObject * obj4 = 0 ;
51866 PyObject * obj5 = 0 ;
51867 char * kwnames[] = {
51868 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51869 };
51870
51871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51873 if (!SWIG_IsOK(res1)) {
51874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
51875 }
51876 arg1 = reinterpret_cast< wxSizer * >(argp1);
51877 arg2 = obj1;
51878 if (obj2) {
51879 ecode3 = SWIG_AsVal_int(obj2, &val3);
51880 if (!SWIG_IsOK(ecode3)) {
51881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
51882 }
51883 arg3 = static_cast< int >(val3);
51884 }
51885 if (obj3) {
51886 ecode4 = SWIG_AsVal_int(obj3, &val4);
51887 if (!SWIG_IsOK(ecode4)) {
51888 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
51889 }
51890 arg4 = static_cast< int >(val4);
51891 }
51892 if (obj4) {
51893 ecode5 = SWIG_AsVal_int(obj4, &val5);
51894 if (!SWIG_IsOK(ecode5)) {
51895 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
51896 }
51897 arg5 = static_cast< int >(val5);
51898 }
51899 if (obj5) {
51900 arg6 = obj5;
51901 }
51902 {
51903 PyThreadState* __tstate = wxPyBeginAllowThreads();
51904 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
51905 wxPyEndAllowThreads(__tstate);
51906 if (PyErr_Occurred()) SWIG_fail;
51907 }
51908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51909 return resultobj;
51910 fail:
51911 return NULL;
51912 }
51913
51914
51915 SWIGINTERN PyObject *_wrap_Sizer_PrependF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51916 PyObject *resultobj = 0;
51917 wxSizer *arg1 = (wxSizer *) 0 ;
51918 PyObject *arg2 = (PyObject *) 0 ;
51919 wxSizerFlags *arg3 = 0 ;
51920 wxSizerItem *result = 0 ;
51921 void *argp1 = 0 ;
51922 int res1 = 0 ;
51923 void *argp3 = 0 ;
51924 int res3 = 0 ;
51925 PyObject * obj0 = 0 ;
51926 PyObject * obj1 = 0 ;
51927 PyObject * obj2 = 0 ;
51928 char * kwnames[] = {
51929 (char *) "self",(char *) "item",(char *) "flags", NULL
51930 };
51931
51932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_PrependF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51934 if (!SWIG_IsOK(res1)) {
51935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependF" "', expected argument " "1"" of type '" "wxSizer *""'");
51936 }
51937 arg1 = reinterpret_cast< wxSizer * >(argp1);
51938 arg2 = obj1;
51939 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51940 if (!SWIG_IsOK(res3)) {
51941 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51942 }
51943 if (!argp3) {
51944 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51945 }
51946 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51947 {
51948 PyThreadState* __tstate = wxPyBeginAllowThreads();
51949 result = (wxSizerItem *)wxSizer_PrependF(arg1,arg2,*arg3);
51950 wxPyEndAllowThreads(__tstate);
51951 if (PyErr_Occurred()) SWIG_fail;
51952 }
51953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51954 return resultobj;
51955 fail:
51956 return NULL;
51957 }
51958
51959
51960 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51961 PyObject *resultobj = 0;
51962 wxSizer *arg1 = (wxSizer *) 0 ;
51963 PyObject *arg2 = (PyObject *) 0 ;
51964 bool result;
51965 void *argp1 = 0 ;
51966 int res1 = 0 ;
51967 PyObject * obj0 = 0 ;
51968 PyObject * obj1 = 0 ;
51969 char * kwnames[] = {
51970 (char *) "self",(char *) "item", NULL
51971 };
51972
51973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
51974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51975 if (!SWIG_IsOK(res1)) {
51976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
51977 }
51978 arg1 = reinterpret_cast< wxSizer * >(argp1);
51979 arg2 = obj1;
51980 {
51981 PyThreadState* __tstate = wxPyBeginAllowThreads();
51982 result = (bool)wxSizer_Remove(arg1,arg2);
51983 wxPyEndAllowThreads(__tstate);
51984 if (PyErr_Occurred()) SWIG_fail;
51985 }
51986 {
51987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51988 }
51989 return resultobj;
51990 fail:
51991 return NULL;
51992 }
51993
51994
51995 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51996 PyObject *resultobj = 0;
51997 wxSizer *arg1 = (wxSizer *) 0 ;
51998 PyObject *arg2 = (PyObject *) 0 ;
51999 bool result;
52000 void *argp1 = 0 ;
52001 int res1 = 0 ;
52002 PyObject * obj0 = 0 ;
52003 PyObject * obj1 = 0 ;
52004 char * kwnames[] = {
52005 (char *) "self",(char *) "item", NULL
52006 };
52007
52008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
52009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52010 if (!SWIG_IsOK(res1)) {
52011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
52012 }
52013 arg1 = reinterpret_cast< wxSizer * >(argp1);
52014 arg2 = obj1;
52015 {
52016 PyThreadState* __tstate = wxPyBeginAllowThreads();
52017 result = (bool)wxSizer_Detach(arg1,arg2);
52018 wxPyEndAllowThreads(__tstate);
52019 if (PyErr_Occurred()) SWIG_fail;
52020 }
52021 {
52022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52023 }
52024 return resultobj;
52025 fail:
52026 return NULL;
52027 }
52028
52029
52030 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52031 PyObject *resultobj = 0;
52032 wxSizer *arg1 = (wxSizer *) 0 ;
52033 PyObject *arg2 = (PyObject *) 0 ;
52034 bool arg3 = (bool) false ;
52035 wxSizerItem *result = 0 ;
52036 void *argp1 = 0 ;
52037 int res1 = 0 ;
52038 bool val3 ;
52039 int ecode3 = 0 ;
52040 PyObject * obj0 = 0 ;
52041 PyObject * obj1 = 0 ;
52042 PyObject * obj2 = 0 ;
52043 char * kwnames[] = {
52044 (char *) "self",(char *) "item",(char *) "recursive", NULL
52045 };
52046
52047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Sizer_GetItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52049 if (!SWIG_IsOK(res1)) {
52050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52051 }
52052 arg1 = reinterpret_cast< wxSizer * >(argp1);
52053 arg2 = obj1;
52054 if (obj2) {
52055 ecode3 = SWIG_AsVal_bool(obj2, &val3);
52056 if (!SWIG_IsOK(ecode3)) {
52057 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_GetItem" "', expected argument " "3"" of type '" "bool""'");
52058 }
52059 arg3 = static_cast< bool >(val3);
52060 }
52061 {
52062 PyThreadState* __tstate = wxPyBeginAllowThreads();
52063 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2,arg3);
52064 wxPyEndAllowThreads(__tstate);
52065 if (PyErr_Occurred()) SWIG_fail;
52066 }
52067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52068 return resultobj;
52069 fail:
52070 return NULL;
52071 }
52072
52073
52074 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52075 PyObject *resultobj = 0;
52076 wxSizer *arg1 = (wxSizer *) 0 ;
52077 PyObject *arg2 = (PyObject *) 0 ;
52078 wxSize *arg3 = 0 ;
52079 void *argp1 = 0 ;
52080 int res1 = 0 ;
52081 wxSize temp3 ;
52082 PyObject * obj0 = 0 ;
52083 PyObject * obj1 = 0 ;
52084 PyObject * obj2 = 0 ;
52085 char * kwnames[] = {
52086 (char *) "self",(char *) "item",(char *) "size", NULL
52087 };
52088
52089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52091 if (!SWIG_IsOK(res1)) {
52092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52093 }
52094 arg1 = reinterpret_cast< wxSizer * >(argp1);
52095 arg2 = obj1;
52096 {
52097 arg3 = &temp3;
52098 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
52099 }
52100 {
52101 PyThreadState* __tstate = wxPyBeginAllowThreads();
52102 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
52103 wxPyEndAllowThreads(__tstate);
52104 if (PyErr_Occurred()) SWIG_fail;
52105 }
52106 resultobj = SWIG_Py_Void();
52107 return resultobj;
52108 fail:
52109 return NULL;
52110 }
52111
52112
52113 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52114 PyObject *resultobj = 0;
52115 wxSizer *arg1 = (wxSizer *) 0 ;
52116 wxWindow *arg2 = (wxWindow *) 0 ;
52117 wxWindow *arg3 = (wxWindow *) 0 ;
52118 bool arg4 = (bool) false ;
52119 bool result;
52120 void *argp1 = 0 ;
52121 int res1 = 0 ;
52122 void *argp2 = 0 ;
52123 int res2 = 0 ;
52124 void *argp3 = 0 ;
52125 int res3 = 0 ;
52126 bool val4 ;
52127 int ecode4 = 0 ;
52128 PyObject * obj0 = 0 ;
52129 PyObject * obj1 = 0 ;
52130 PyObject * obj2 = 0 ;
52131 PyObject * obj3 = 0 ;
52132 char * kwnames[] = {
52133 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
52134 };
52135
52136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52138 if (!SWIG_IsOK(res1)) {
52139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
52140 }
52141 arg1 = reinterpret_cast< wxSizer * >(argp1);
52142 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52143 if (!SWIG_IsOK(res2)) {
52144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52145 }
52146 arg2 = reinterpret_cast< wxWindow * >(argp2);
52147 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52148 if (!SWIG_IsOK(res3)) {
52149 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
52150 }
52151 arg3 = reinterpret_cast< wxWindow * >(argp3);
52152 if (obj3) {
52153 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52154 if (!SWIG_IsOK(ecode4)) {
52155 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
52156 }
52157 arg4 = static_cast< bool >(val4);
52158 }
52159 {
52160 PyThreadState* __tstate = wxPyBeginAllowThreads();
52161 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
52162 wxPyEndAllowThreads(__tstate);
52163 if (PyErr_Occurred()) SWIG_fail;
52164 }
52165 {
52166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52167 }
52168 return resultobj;
52169 fail:
52170 return NULL;
52171 }
52172
52173
52174 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52175 PyObject *resultobj = 0;
52176 wxSizer *arg1 = (wxSizer *) 0 ;
52177 wxSizer *arg2 = (wxSizer *) 0 ;
52178 wxSizer *arg3 = (wxSizer *) 0 ;
52179 bool arg4 = (bool) false ;
52180 bool result;
52181 void *argp1 = 0 ;
52182 int res1 = 0 ;
52183 void *argp2 = 0 ;
52184 int res2 = 0 ;
52185 void *argp3 = 0 ;
52186 int res3 = 0 ;
52187 bool val4 ;
52188 int ecode4 = 0 ;
52189 PyObject * obj0 = 0 ;
52190 PyObject * obj1 = 0 ;
52191 PyObject * obj2 = 0 ;
52192 PyObject * obj3 = 0 ;
52193 char * kwnames[] = {
52194 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
52195 };
52196
52197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52199 if (!SWIG_IsOK(res1)) {
52200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
52201 }
52202 arg1 = reinterpret_cast< wxSizer * >(argp1);
52203 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52204 if (!SWIG_IsOK(res2)) {
52205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
52206 }
52207 arg2 = reinterpret_cast< wxSizer * >(argp2);
52208 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
52209 if (!SWIG_IsOK(res3)) {
52210 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
52211 }
52212 arg3 = reinterpret_cast< wxSizer * >(argp3);
52213 if (obj3) {
52214 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52215 if (!SWIG_IsOK(ecode4)) {
52216 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
52217 }
52218 arg4 = static_cast< bool >(val4);
52219 }
52220 {
52221 PyThreadState* __tstate = wxPyBeginAllowThreads();
52222 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
52223 wxPyEndAllowThreads(__tstate);
52224 if (PyErr_Occurred()) SWIG_fail;
52225 }
52226 {
52227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52228 }
52229 return resultobj;
52230 fail:
52231 return NULL;
52232 }
52233
52234
52235 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52236 PyObject *resultobj = 0;
52237 wxSizer *arg1 = (wxSizer *) 0 ;
52238 size_t arg2 ;
52239 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
52240 bool result;
52241 void *argp1 = 0 ;
52242 int res1 = 0 ;
52243 size_t val2 ;
52244 int ecode2 = 0 ;
52245 void *argp3 = 0 ;
52246 int res3 = 0 ;
52247 PyObject * obj0 = 0 ;
52248 PyObject * obj1 = 0 ;
52249 PyObject * obj2 = 0 ;
52250 char * kwnames[] = {
52251 (char *) "self",(char *) "index",(char *) "newitem", NULL
52252 };
52253
52254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52256 if (!SWIG_IsOK(res1)) {
52257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52258 }
52259 arg1 = reinterpret_cast< wxSizer * >(argp1);
52260 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52261 if (!SWIG_IsOK(ecode2)) {
52262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
52263 }
52264 arg2 = static_cast< size_t >(val2);
52265 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
52266 if (!SWIG_IsOK(res3)) {
52267 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
52268 }
52269 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
52270 {
52271 PyThreadState* __tstate = wxPyBeginAllowThreads();
52272 result = (bool)(arg1)->Replace(arg2,arg3);
52273 wxPyEndAllowThreads(__tstate);
52274 if (PyErr_Occurred()) SWIG_fail;
52275 }
52276 {
52277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52278 }
52279 return resultobj;
52280 fail:
52281 return NULL;
52282 }
52283
52284
52285 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52286 PyObject *resultobj = 0;
52287 wxSizer *arg1 = (wxSizer *) 0 ;
52288 wxWindow *arg2 = (wxWindow *) 0 ;
52289 void *argp1 = 0 ;
52290 int res1 = 0 ;
52291 void *argp2 = 0 ;
52292 int res2 = 0 ;
52293 PyObject * obj0 = 0 ;
52294 PyObject * obj1 = 0 ;
52295 char * kwnames[] = {
52296 (char *) "self",(char *) "window", NULL
52297 };
52298
52299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
52300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52301 if (!SWIG_IsOK(res1)) {
52302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
52303 }
52304 arg1 = reinterpret_cast< wxSizer * >(argp1);
52305 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52306 if (!SWIG_IsOK(res2)) {
52307 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
52308 }
52309 arg2 = reinterpret_cast< wxWindow * >(argp2);
52310 {
52311 PyThreadState* __tstate = wxPyBeginAllowThreads();
52312 (arg1)->SetContainingWindow(arg2);
52313 wxPyEndAllowThreads(__tstate);
52314 if (PyErr_Occurred()) SWIG_fail;
52315 }
52316 resultobj = SWIG_Py_Void();
52317 return resultobj;
52318 fail:
52319 return NULL;
52320 }
52321
52322
52323 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52324 PyObject *resultobj = 0;
52325 wxSizer *arg1 = (wxSizer *) 0 ;
52326 wxWindow *result = 0 ;
52327 void *argp1 = 0 ;
52328 int res1 = 0 ;
52329 PyObject *swig_obj[1] ;
52330
52331 if (!args) SWIG_fail;
52332 swig_obj[0] = args;
52333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52334 if (!SWIG_IsOK(res1)) {
52335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
52336 }
52337 arg1 = reinterpret_cast< wxSizer * >(argp1);
52338 {
52339 PyThreadState* __tstate = wxPyBeginAllowThreads();
52340 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
52341 wxPyEndAllowThreads(__tstate);
52342 if (PyErr_Occurred()) SWIG_fail;
52343 }
52344 {
52345 resultobj = wxPyMake_wxObject(result, 0);
52346 }
52347 return resultobj;
52348 fail:
52349 return NULL;
52350 }
52351
52352
52353 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52354 PyObject *resultobj = 0;
52355 wxSizer *arg1 = (wxSizer *) 0 ;
52356 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
52357 wxSizerItem *result = 0 ;
52358 void *argp1 = 0 ;
52359 int res1 = 0 ;
52360 int res2 = 0 ;
52361 PyObject * obj0 = 0 ;
52362 PyObject * obj1 = 0 ;
52363 char * kwnames[] = {
52364 (char *) "self",(char *) "item", NULL
52365 };
52366
52367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
52368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52369 if (!SWIG_IsOK(res1)) {
52370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52371 }
52372 arg1 = reinterpret_cast< wxSizer * >(argp1);
52373 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
52374 if (!SWIG_IsOK(res2)) {
52375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
52376 }
52377 {
52378 PyThreadState* __tstate = wxPyBeginAllowThreads();
52379 result = (wxSizerItem *)(arg1)->Add(arg2);
52380 wxPyEndAllowThreads(__tstate);
52381 if (PyErr_Occurred()) SWIG_fail;
52382 }
52383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52384 return resultobj;
52385 fail:
52386 return NULL;
52387 }
52388
52389
52390 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52391 PyObject *resultobj = 0;
52392 wxSizer *arg1 = (wxSizer *) 0 ;
52393 size_t arg2 ;
52394 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
52395 wxSizerItem *result = 0 ;
52396 void *argp1 = 0 ;
52397 int res1 = 0 ;
52398 size_t val2 ;
52399 int ecode2 = 0 ;
52400 int res3 = 0 ;
52401 PyObject * obj0 = 0 ;
52402 PyObject * obj1 = 0 ;
52403 PyObject * obj2 = 0 ;
52404 char * kwnames[] = {
52405 (char *) "self",(char *) "index",(char *) "item", NULL
52406 };
52407
52408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52410 if (!SWIG_IsOK(res1)) {
52411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52412 }
52413 arg1 = reinterpret_cast< wxSizer * >(argp1);
52414 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52415 if (!SWIG_IsOK(ecode2)) {
52416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
52417 }
52418 arg2 = static_cast< size_t >(val2);
52419 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
52420 if (!SWIG_IsOK(res3)) {
52421 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
52422 }
52423 {
52424 PyThreadState* __tstate = wxPyBeginAllowThreads();
52425 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
52426 wxPyEndAllowThreads(__tstate);
52427 if (PyErr_Occurred()) SWIG_fail;
52428 }
52429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52430 return resultobj;
52431 fail:
52432 return NULL;
52433 }
52434
52435
52436 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52437 PyObject *resultobj = 0;
52438 wxSizer *arg1 = (wxSizer *) 0 ;
52439 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
52440 wxSizerItem *result = 0 ;
52441 void *argp1 = 0 ;
52442 int res1 = 0 ;
52443 int res2 = 0 ;
52444 PyObject * obj0 = 0 ;
52445 PyObject * obj1 = 0 ;
52446 char * kwnames[] = {
52447 (char *) "self",(char *) "item", NULL
52448 };
52449
52450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
52451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52452 if (!SWIG_IsOK(res1)) {
52453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52454 }
52455 arg1 = reinterpret_cast< wxSizer * >(argp1);
52456 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
52457 if (!SWIG_IsOK(res2)) {
52458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
52459 }
52460 {
52461 PyThreadState* __tstate = wxPyBeginAllowThreads();
52462 result = (wxSizerItem *)(arg1)->Prepend(arg2);
52463 wxPyEndAllowThreads(__tstate);
52464 if (PyErr_Occurred()) SWIG_fail;
52465 }
52466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52467 return resultobj;
52468 fail:
52469 return NULL;
52470 }
52471
52472
52473 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52474 PyObject *resultobj = 0;
52475 wxSizer *arg1 = (wxSizer *) 0 ;
52476 int arg2 ;
52477 int arg3 ;
52478 int arg4 ;
52479 int arg5 ;
52480 void *argp1 = 0 ;
52481 int res1 = 0 ;
52482 int val2 ;
52483 int ecode2 = 0 ;
52484 int val3 ;
52485 int ecode3 = 0 ;
52486 int val4 ;
52487 int ecode4 = 0 ;
52488 int val5 ;
52489 int ecode5 = 0 ;
52490 PyObject * obj0 = 0 ;
52491 PyObject * obj1 = 0 ;
52492 PyObject * obj2 = 0 ;
52493 PyObject * obj3 = 0 ;
52494 PyObject * obj4 = 0 ;
52495 char * kwnames[] = {
52496 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
52497 };
52498
52499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
52500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52501 if (!SWIG_IsOK(res1)) {
52502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
52503 }
52504 arg1 = reinterpret_cast< wxSizer * >(argp1);
52505 ecode2 = SWIG_AsVal_int(obj1, &val2);
52506 if (!SWIG_IsOK(ecode2)) {
52507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
52508 }
52509 arg2 = static_cast< int >(val2);
52510 ecode3 = SWIG_AsVal_int(obj2, &val3);
52511 if (!SWIG_IsOK(ecode3)) {
52512 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
52513 }
52514 arg3 = static_cast< int >(val3);
52515 ecode4 = SWIG_AsVal_int(obj3, &val4);
52516 if (!SWIG_IsOK(ecode4)) {
52517 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
52518 }
52519 arg4 = static_cast< int >(val4);
52520 ecode5 = SWIG_AsVal_int(obj4, &val5);
52521 if (!SWIG_IsOK(ecode5)) {
52522 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
52523 }
52524 arg5 = static_cast< int >(val5);
52525 {
52526 PyThreadState* __tstate = wxPyBeginAllowThreads();
52527 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
52528 wxPyEndAllowThreads(__tstate);
52529 if (PyErr_Occurred()) SWIG_fail;
52530 }
52531 resultobj = SWIG_Py_Void();
52532 return resultobj;
52533 fail:
52534 return NULL;
52535 }
52536
52537
52538 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52539 PyObject *resultobj = 0;
52540 wxSizer *arg1 = (wxSizer *) 0 ;
52541 wxSize *arg2 = 0 ;
52542 void *argp1 = 0 ;
52543 int res1 = 0 ;
52544 wxSize temp2 ;
52545 PyObject * obj0 = 0 ;
52546 PyObject * obj1 = 0 ;
52547 char * kwnames[] = {
52548 (char *) "self",(char *) "size", NULL
52549 };
52550
52551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
52552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52553 if (!SWIG_IsOK(res1)) {
52554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52555 }
52556 arg1 = reinterpret_cast< wxSizer * >(argp1);
52557 {
52558 arg2 = &temp2;
52559 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
52560 }
52561 {
52562 PyThreadState* __tstate = wxPyBeginAllowThreads();
52563 (arg1)->SetMinSize((wxSize const &)*arg2);
52564 wxPyEndAllowThreads(__tstate);
52565 if (PyErr_Occurred()) SWIG_fail;
52566 }
52567 resultobj = SWIG_Py_Void();
52568 return resultobj;
52569 fail:
52570 return NULL;
52571 }
52572
52573
52574 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52575 PyObject *resultobj = 0;
52576 wxSizer *arg1 = (wxSizer *) 0 ;
52577 wxSize result;
52578 void *argp1 = 0 ;
52579 int res1 = 0 ;
52580 PyObject *swig_obj[1] ;
52581
52582 if (!args) SWIG_fail;
52583 swig_obj[0] = args;
52584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52585 if (!SWIG_IsOK(res1)) {
52586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52587 }
52588 arg1 = reinterpret_cast< wxSizer * >(argp1);
52589 {
52590 PyThreadState* __tstate = wxPyBeginAllowThreads();
52591 result = (arg1)->GetSize();
52592 wxPyEndAllowThreads(__tstate);
52593 if (PyErr_Occurred()) SWIG_fail;
52594 }
52595 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52596 return resultobj;
52597 fail:
52598 return NULL;
52599 }
52600
52601
52602 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52603 PyObject *resultobj = 0;
52604 wxSizer *arg1 = (wxSizer *) 0 ;
52605 wxPoint result;
52606 void *argp1 = 0 ;
52607 int res1 = 0 ;
52608 PyObject *swig_obj[1] ;
52609
52610 if (!args) SWIG_fail;
52611 swig_obj[0] = args;
52612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52613 if (!SWIG_IsOK(res1)) {
52614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
52615 }
52616 arg1 = reinterpret_cast< wxSizer * >(argp1);
52617 {
52618 PyThreadState* __tstate = wxPyBeginAllowThreads();
52619 result = (arg1)->GetPosition();
52620 wxPyEndAllowThreads(__tstate);
52621 if (PyErr_Occurred()) SWIG_fail;
52622 }
52623 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
52624 return resultobj;
52625 fail:
52626 return NULL;
52627 }
52628
52629
52630 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52631 PyObject *resultobj = 0;
52632 wxSizer *arg1 = (wxSizer *) 0 ;
52633 wxSize result;
52634 void *argp1 = 0 ;
52635 int res1 = 0 ;
52636 PyObject *swig_obj[1] ;
52637
52638 if (!args) SWIG_fail;
52639 swig_obj[0] = args;
52640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52641 if (!SWIG_IsOK(res1)) {
52642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52643 }
52644 arg1 = reinterpret_cast< wxSizer * >(argp1);
52645 {
52646 PyThreadState* __tstate = wxPyBeginAllowThreads();
52647 result = (arg1)->GetMinSize();
52648 wxPyEndAllowThreads(__tstate);
52649 if (PyErr_Occurred()) SWIG_fail;
52650 }
52651 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52652 return resultobj;
52653 fail:
52654 return NULL;
52655 }
52656
52657
52658 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52659 PyObject *resultobj = 0;
52660 wxSizer *arg1 = (wxSizer *) 0 ;
52661 void *argp1 = 0 ;
52662 int res1 = 0 ;
52663 PyObject *swig_obj[1] ;
52664
52665 if (!args) SWIG_fail;
52666 swig_obj[0] = args;
52667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52668 if (!SWIG_IsOK(res1)) {
52669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
52670 }
52671 arg1 = reinterpret_cast< wxSizer * >(argp1);
52672 {
52673 PyThreadState* __tstate = wxPyBeginAllowThreads();
52674 (arg1)->RecalcSizes();
52675 wxPyEndAllowThreads(__tstate);
52676 if (PyErr_Occurred()) SWIG_fail;
52677 }
52678 resultobj = SWIG_Py_Void();
52679 return resultobj;
52680 fail:
52681 return NULL;
52682 }
52683
52684
52685 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52686 PyObject *resultobj = 0;
52687 wxSizer *arg1 = (wxSizer *) 0 ;
52688 wxSize result;
52689 void *argp1 = 0 ;
52690 int res1 = 0 ;
52691 PyObject *swig_obj[1] ;
52692
52693 if (!args) SWIG_fail;
52694 swig_obj[0] = args;
52695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52696 if (!SWIG_IsOK(res1)) {
52697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
52698 }
52699 arg1 = reinterpret_cast< wxSizer * >(argp1);
52700 {
52701 PyThreadState* __tstate = wxPyBeginAllowThreads();
52702 result = (arg1)->CalcMin();
52703 wxPyEndAllowThreads(__tstate);
52704 if (PyErr_Occurred()) SWIG_fail;
52705 }
52706 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52707 return resultobj;
52708 fail:
52709 return NULL;
52710 }
52711
52712
52713 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52714 PyObject *resultobj = 0;
52715 wxSizer *arg1 = (wxSizer *) 0 ;
52716 void *argp1 = 0 ;
52717 int res1 = 0 ;
52718 PyObject *swig_obj[1] ;
52719
52720 if (!args) SWIG_fail;
52721 swig_obj[0] = args;
52722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52723 if (!SWIG_IsOK(res1)) {
52724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
52725 }
52726 arg1 = reinterpret_cast< wxSizer * >(argp1);
52727 {
52728 PyThreadState* __tstate = wxPyBeginAllowThreads();
52729 (arg1)->Layout();
52730 wxPyEndAllowThreads(__tstate);
52731 if (PyErr_Occurred()) SWIG_fail;
52732 }
52733 resultobj = SWIG_Py_Void();
52734 return resultobj;
52735 fail:
52736 return NULL;
52737 }
52738
52739
52740 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52741 PyObject *resultobj = 0;
52742 wxSizer *arg1 = (wxSizer *) 0 ;
52743 wxWindow *arg2 = (wxWindow *) 0 ;
52744 wxSize result;
52745 void *argp1 = 0 ;
52746 int res1 = 0 ;
52747 void *argp2 = 0 ;
52748 int res2 = 0 ;
52749 PyObject * obj0 = 0 ;
52750 PyObject * obj1 = 0 ;
52751 char * kwnames[] = {
52752 (char *) "self",(char *) "window", NULL
52753 };
52754
52755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
52756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52757 if (!SWIG_IsOK(res1)) {
52758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
52759 }
52760 arg1 = reinterpret_cast< wxSizer * >(argp1);
52761 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52762 if (!SWIG_IsOK(res2)) {
52763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
52764 }
52765 arg2 = reinterpret_cast< wxWindow * >(argp2);
52766 {
52767 PyThreadState* __tstate = wxPyBeginAllowThreads();
52768 result = (arg1)->Fit(arg2);
52769 wxPyEndAllowThreads(__tstate);
52770 if (PyErr_Occurred()) SWIG_fail;
52771 }
52772 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52773 return resultobj;
52774 fail:
52775 return NULL;
52776 }
52777
52778
52779 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52780 PyObject *resultobj = 0;
52781 wxSizer *arg1 = (wxSizer *) 0 ;
52782 wxWindow *arg2 = (wxWindow *) 0 ;
52783 void *argp1 = 0 ;
52784 int res1 = 0 ;
52785 void *argp2 = 0 ;
52786 int res2 = 0 ;
52787 PyObject * obj0 = 0 ;
52788 PyObject * obj1 = 0 ;
52789 char * kwnames[] = {
52790 (char *) "self",(char *) "window", NULL
52791 };
52792
52793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
52794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52795 if (!SWIG_IsOK(res1)) {
52796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
52797 }
52798 arg1 = reinterpret_cast< wxSizer * >(argp1);
52799 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52800 if (!SWIG_IsOK(res2)) {
52801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
52802 }
52803 arg2 = reinterpret_cast< wxWindow * >(argp2);
52804 {
52805 PyThreadState* __tstate = wxPyBeginAllowThreads();
52806 (arg1)->FitInside(arg2);
52807 wxPyEndAllowThreads(__tstate);
52808 if (PyErr_Occurred()) SWIG_fail;
52809 }
52810 resultobj = SWIG_Py_Void();
52811 return resultobj;
52812 fail:
52813 return NULL;
52814 }
52815
52816
52817 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52818 PyObject *resultobj = 0;
52819 wxSizer *arg1 = (wxSizer *) 0 ;
52820 wxWindow *arg2 = (wxWindow *) 0 ;
52821 void *argp1 = 0 ;
52822 int res1 = 0 ;
52823 void *argp2 = 0 ;
52824 int res2 = 0 ;
52825 PyObject * obj0 = 0 ;
52826 PyObject * obj1 = 0 ;
52827 char * kwnames[] = {
52828 (char *) "self",(char *) "window", NULL
52829 };
52830
52831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52833 if (!SWIG_IsOK(res1)) {
52834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52835 }
52836 arg1 = reinterpret_cast< wxSizer * >(argp1);
52837 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52838 if (!SWIG_IsOK(res2)) {
52839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52840 }
52841 arg2 = reinterpret_cast< wxWindow * >(argp2);
52842 {
52843 PyThreadState* __tstate = wxPyBeginAllowThreads();
52844 (arg1)->SetSizeHints(arg2);
52845 wxPyEndAllowThreads(__tstate);
52846 if (PyErr_Occurred()) SWIG_fail;
52847 }
52848 resultobj = SWIG_Py_Void();
52849 return resultobj;
52850 fail:
52851 return NULL;
52852 }
52853
52854
52855 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52856 PyObject *resultobj = 0;
52857 wxSizer *arg1 = (wxSizer *) 0 ;
52858 wxWindow *arg2 = (wxWindow *) 0 ;
52859 void *argp1 = 0 ;
52860 int res1 = 0 ;
52861 void *argp2 = 0 ;
52862 int res2 = 0 ;
52863 PyObject * obj0 = 0 ;
52864 PyObject * obj1 = 0 ;
52865 char * kwnames[] = {
52866 (char *) "self",(char *) "window", NULL
52867 };
52868
52869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52871 if (!SWIG_IsOK(res1)) {
52872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52873 }
52874 arg1 = reinterpret_cast< wxSizer * >(argp1);
52875 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52876 if (!SWIG_IsOK(res2)) {
52877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52878 }
52879 arg2 = reinterpret_cast< wxWindow * >(argp2);
52880 {
52881 PyThreadState* __tstate = wxPyBeginAllowThreads();
52882 (arg1)->SetVirtualSizeHints(arg2);
52883 wxPyEndAllowThreads(__tstate);
52884 if (PyErr_Occurred()) SWIG_fail;
52885 }
52886 resultobj = SWIG_Py_Void();
52887 return resultobj;
52888 fail:
52889 return NULL;
52890 }
52891
52892
52893 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52894 PyObject *resultobj = 0;
52895 wxSizer *arg1 = (wxSizer *) 0 ;
52896 bool arg2 = (bool) false ;
52897 void *argp1 = 0 ;
52898 int res1 = 0 ;
52899 bool val2 ;
52900 int ecode2 = 0 ;
52901 PyObject * obj0 = 0 ;
52902 PyObject * obj1 = 0 ;
52903 char * kwnames[] = {
52904 (char *) "self",(char *) "deleteWindows", NULL
52905 };
52906
52907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
52908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52909 if (!SWIG_IsOK(res1)) {
52910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
52911 }
52912 arg1 = reinterpret_cast< wxSizer * >(argp1);
52913 if (obj1) {
52914 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52915 if (!SWIG_IsOK(ecode2)) {
52916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
52917 }
52918 arg2 = static_cast< bool >(val2);
52919 }
52920 {
52921 PyThreadState* __tstate = wxPyBeginAllowThreads();
52922 (arg1)->Clear(arg2);
52923 wxPyEndAllowThreads(__tstate);
52924 if (PyErr_Occurred()) SWIG_fail;
52925 }
52926 resultobj = SWIG_Py_Void();
52927 return resultobj;
52928 fail:
52929 return NULL;
52930 }
52931
52932
52933 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52934 PyObject *resultobj = 0;
52935 wxSizer *arg1 = (wxSizer *) 0 ;
52936 void *argp1 = 0 ;
52937 int res1 = 0 ;
52938 PyObject *swig_obj[1] ;
52939
52940 if (!args) SWIG_fail;
52941 swig_obj[0] = args;
52942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52943 if (!SWIG_IsOK(res1)) {
52944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
52945 }
52946 arg1 = reinterpret_cast< wxSizer * >(argp1);
52947 {
52948 PyThreadState* __tstate = wxPyBeginAllowThreads();
52949 (arg1)->DeleteWindows();
52950 wxPyEndAllowThreads(__tstate);
52951 if (PyErr_Occurred()) SWIG_fail;
52952 }
52953 resultobj = SWIG_Py_Void();
52954 return resultobj;
52955 fail:
52956 return NULL;
52957 }
52958
52959
52960 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52961 PyObject *resultobj = 0;
52962 wxSizer *arg1 = (wxSizer *) 0 ;
52963 PyObject *result = 0 ;
52964 void *argp1 = 0 ;
52965 int res1 = 0 ;
52966 PyObject *swig_obj[1] ;
52967
52968 if (!args) SWIG_fail;
52969 swig_obj[0] = args;
52970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52971 if (!SWIG_IsOK(res1)) {
52972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
52973 }
52974 arg1 = reinterpret_cast< wxSizer * >(argp1);
52975 {
52976 PyThreadState* __tstate = wxPyBeginAllowThreads();
52977 result = (PyObject *)wxSizer_GetChildren(arg1);
52978 wxPyEndAllowThreads(__tstate);
52979 if (PyErr_Occurred()) SWIG_fail;
52980 }
52981 resultobj = result;
52982 return resultobj;
52983 fail:
52984 return NULL;
52985 }
52986
52987
52988 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52989 PyObject *resultobj = 0;
52990 wxSizer *arg1 = (wxSizer *) 0 ;
52991 PyObject *arg2 = (PyObject *) 0 ;
52992 bool arg3 = (bool) true ;
52993 bool arg4 = (bool) false ;
52994 bool result;
52995 void *argp1 = 0 ;
52996 int res1 = 0 ;
52997 bool val3 ;
52998 int ecode3 = 0 ;
52999 bool val4 ;
53000 int ecode4 = 0 ;
53001 PyObject * obj0 = 0 ;
53002 PyObject * obj1 = 0 ;
53003 PyObject * obj2 = 0 ;
53004 PyObject * obj3 = 0 ;
53005 char * kwnames[] = {
53006 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
53007 };
53008
53009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
53011 if (!SWIG_IsOK(res1)) {
53012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
53013 }
53014 arg1 = reinterpret_cast< wxSizer * >(argp1);
53015 arg2 = obj1;
53016 if (obj2) {
53017 ecode3 = SWIG_AsVal_bool(obj2, &val3);
53018 if (!SWIG_IsOK(ecode3)) {
53019 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
53020 }
53021 arg3 = static_cast< bool >(val3);
53022 }
53023 if (obj3) {
53024 ecode4 = SWIG_AsVal_bool(obj3, &val4);
53025 if (!SWIG_IsOK(ecode4)) {
53026 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
53027 }
53028 arg4 = static_cast< bool >(val4);
53029 }
53030 {
53031 PyThreadState* __tstate = wxPyBeginAllowThreads();
53032 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
53033 wxPyEndAllowThreads(__tstate);
53034 if (PyErr_Occurred()) SWIG_fail;
53035 }
53036 {
53037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53038 }
53039 return resultobj;
53040 fail:
53041 return NULL;
53042 }
53043
53044
53045 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53046 PyObject *resultobj = 0;
53047 wxSizer *arg1 = (wxSizer *) 0 ;
53048 PyObject *arg2 = (PyObject *) 0 ;
53049 bool result;
53050 void *argp1 = 0 ;
53051 int res1 = 0 ;
53052 PyObject * obj0 = 0 ;
53053 PyObject * obj1 = 0 ;
53054 char * kwnames[] = {
53055 (char *) "self",(char *) "item", NULL
53056 };
53057
53058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
53059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
53060 if (!SWIG_IsOK(res1)) {
53061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
53062 }
53063 arg1 = reinterpret_cast< wxSizer * >(argp1);
53064 arg2 = obj1;
53065 {
53066 PyThreadState* __tstate = wxPyBeginAllowThreads();
53067 result = (bool)wxSizer_IsShown(arg1,arg2);
53068 wxPyEndAllowThreads(__tstate);
53069 if (PyErr_Occurred()) SWIG_fail;
53070 }
53071 {
53072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53073 }
53074 return resultobj;
53075 fail:
53076 return NULL;
53077 }
53078
53079
53080 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53081 PyObject *resultobj = 0;
53082 wxSizer *arg1 = (wxSizer *) 0 ;
53083 bool arg2 ;
53084 void *argp1 = 0 ;
53085 int res1 = 0 ;
53086 bool val2 ;
53087 int ecode2 = 0 ;
53088 PyObject * obj0 = 0 ;
53089 PyObject * obj1 = 0 ;
53090 char * kwnames[] = {
53091 (char *) "self",(char *) "show", NULL
53092 };
53093
53094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
53095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
53096 if (!SWIG_IsOK(res1)) {
53097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
53098 }
53099 arg1 = reinterpret_cast< wxSizer * >(argp1);
53100 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53101 if (!SWIG_IsOK(ecode2)) {
53102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
53103 }
53104 arg2 = static_cast< bool >(val2);
53105 {
53106 PyThreadState* __tstate = wxPyBeginAllowThreads();
53107 (arg1)->ShowItems(arg2);
53108 wxPyEndAllowThreads(__tstate);
53109 if (PyErr_Occurred()) SWIG_fail;
53110 }
53111 resultobj = SWIG_Py_Void();
53112 return resultobj;
53113 fail:
53114 return NULL;
53115 }
53116
53117
53118 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53119 PyObject *obj;
53120 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53121 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
53122 return SWIG_Py_Void();
53123 }
53124
53125 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53126 PyObject *resultobj = 0;
53127 wxPySizer *result = 0 ;
53128
53129 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
53130 {
53131 PyThreadState* __tstate = wxPyBeginAllowThreads();
53132 result = (wxPySizer *)new wxPySizer();
53133 wxPyEndAllowThreads(__tstate);
53134 if (PyErr_Occurred()) SWIG_fail;
53135 }
53136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
53137 return resultobj;
53138 fail:
53139 return NULL;
53140 }
53141
53142
53143 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53144 PyObject *resultobj = 0;
53145 wxPySizer *arg1 = (wxPySizer *) 0 ;
53146 PyObject *arg2 = (PyObject *) 0 ;
53147 PyObject *arg3 = (PyObject *) 0 ;
53148 void *argp1 = 0 ;
53149 int res1 = 0 ;
53150 PyObject * obj0 = 0 ;
53151 PyObject * obj1 = 0 ;
53152 PyObject * obj2 = 0 ;
53153 char * kwnames[] = {
53154 (char *) "self",(char *) "self",(char *) "_class", NULL
53155 };
53156
53157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
53159 if (!SWIG_IsOK(res1)) {
53160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
53161 }
53162 arg1 = reinterpret_cast< wxPySizer * >(argp1);
53163 arg2 = obj1;
53164 arg3 = obj2;
53165 {
53166 PyThreadState* __tstate = wxPyBeginAllowThreads();
53167 (arg1)->_setCallbackInfo(arg2,arg3);
53168 wxPyEndAllowThreads(__tstate);
53169 if (PyErr_Occurred()) SWIG_fail;
53170 }
53171 resultobj = SWIG_Py_Void();
53172 return resultobj;
53173 fail:
53174 return NULL;
53175 }
53176
53177
53178 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53179 PyObject *obj;
53180 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53181 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
53182 return SWIG_Py_Void();
53183 }
53184
53185 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53186 return SWIG_Python_InitShadowInstance(args);
53187 }
53188
53189 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53190 PyObject *resultobj = 0;
53191 int arg1 = (int) wxHORIZONTAL ;
53192 wxBoxSizer *result = 0 ;
53193 int val1 ;
53194 int ecode1 = 0 ;
53195 PyObject * obj0 = 0 ;
53196 char * kwnames[] = {
53197 (char *) "orient", NULL
53198 };
53199
53200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
53201 if (obj0) {
53202 ecode1 = SWIG_AsVal_int(obj0, &val1);
53203 if (!SWIG_IsOK(ecode1)) {
53204 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
53205 }
53206 arg1 = static_cast< int >(val1);
53207 }
53208 {
53209 PyThreadState* __tstate = wxPyBeginAllowThreads();
53210 result = (wxBoxSizer *)new wxBoxSizer(arg1);
53211 wxPyEndAllowThreads(__tstate);
53212 if (PyErr_Occurred()) SWIG_fail;
53213 }
53214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
53215 return resultobj;
53216 fail:
53217 return NULL;
53218 }
53219
53220
53221 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53222 PyObject *resultobj = 0;
53223 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
53224 int result;
53225 void *argp1 = 0 ;
53226 int res1 = 0 ;
53227 PyObject *swig_obj[1] ;
53228
53229 if (!args) SWIG_fail;
53230 swig_obj[0] = args;
53231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
53232 if (!SWIG_IsOK(res1)) {
53233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
53234 }
53235 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
53236 {
53237 PyThreadState* __tstate = wxPyBeginAllowThreads();
53238 result = (int)(arg1)->GetOrientation();
53239 wxPyEndAllowThreads(__tstate);
53240 if (PyErr_Occurred()) SWIG_fail;
53241 }
53242 resultobj = SWIG_From_int(static_cast< int >(result));
53243 return resultobj;
53244 fail:
53245 return NULL;
53246 }
53247
53248
53249 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53250 PyObject *resultobj = 0;
53251 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
53252 int arg2 ;
53253 void *argp1 = 0 ;
53254 int res1 = 0 ;
53255 int val2 ;
53256 int ecode2 = 0 ;
53257 PyObject * obj0 = 0 ;
53258 PyObject * obj1 = 0 ;
53259 char * kwnames[] = {
53260 (char *) "self",(char *) "orient", NULL
53261 };
53262
53263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
53264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
53265 if (!SWIG_IsOK(res1)) {
53266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
53267 }
53268 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
53269 ecode2 = SWIG_AsVal_int(obj1, &val2);
53270 if (!SWIG_IsOK(ecode2)) {
53271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
53272 }
53273 arg2 = static_cast< int >(val2);
53274 {
53275 PyThreadState* __tstate = wxPyBeginAllowThreads();
53276 (arg1)->SetOrientation(arg2);
53277 wxPyEndAllowThreads(__tstate);
53278 if (PyErr_Occurred()) SWIG_fail;
53279 }
53280 resultobj = SWIG_Py_Void();
53281 return resultobj;
53282 fail:
53283 return NULL;
53284 }
53285
53286
53287 SWIGINTERN PyObject *_wrap_BoxSizer_IsVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53288 PyObject *resultobj = 0;
53289 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
53290 bool result;
53291 void *argp1 = 0 ;
53292 int res1 = 0 ;
53293 PyObject *swig_obj[1] ;
53294
53295 if (!args) SWIG_fail;
53296 swig_obj[0] = args;
53297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
53298 if (!SWIG_IsOK(res1)) {
53299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_IsVertical" "', expected argument " "1"" of type '" "wxBoxSizer const *""'");
53300 }
53301 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
53302 {
53303 PyThreadState* __tstate = wxPyBeginAllowThreads();
53304 result = (bool)((wxBoxSizer const *)arg1)->IsVertical();
53305 wxPyEndAllowThreads(__tstate);
53306 if (PyErr_Occurred()) SWIG_fail;
53307 }
53308 {
53309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53310 }
53311 return resultobj;
53312 fail:
53313 return NULL;
53314 }
53315
53316
53317 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53318 PyObject *obj;
53319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53320 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
53321 return SWIG_Py_Void();
53322 }
53323
53324 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53325 return SWIG_Python_InitShadowInstance(args);
53326 }
53327
53328 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53329 PyObject *resultobj = 0;
53330 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
53331 int arg2 = (int) wxHORIZONTAL ;
53332 wxStaticBoxSizer *result = 0 ;
53333 void *argp1 = 0 ;
53334 int res1 = 0 ;
53335 int val2 ;
53336 int ecode2 = 0 ;
53337 PyObject * obj0 = 0 ;
53338 PyObject * obj1 = 0 ;
53339 char * kwnames[] = {
53340 (char *) "box",(char *) "orient", NULL
53341 };
53342
53343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
53345 if (!SWIG_IsOK(res1)) {
53346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
53347 }
53348 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
53349 if (obj1) {
53350 ecode2 = SWIG_AsVal_int(obj1, &val2);
53351 if (!SWIG_IsOK(ecode2)) {
53352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
53353 }
53354 arg2 = static_cast< int >(val2);
53355 }
53356 {
53357 PyThreadState* __tstate = wxPyBeginAllowThreads();
53358 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
53359 wxPyEndAllowThreads(__tstate);
53360 if (PyErr_Occurred()) SWIG_fail;
53361 }
53362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
53363 return resultobj;
53364 fail:
53365 return NULL;
53366 }
53367
53368
53369 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53370 PyObject *resultobj = 0;
53371 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
53372 wxStaticBox *result = 0 ;
53373 void *argp1 = 0 ;
53374 int res1 = 0 ;
53375 PyObject *swig_obj[1] ;
53376
53377 if (!args) SWIG_fail;
53378 swig_obj[0] = args;
53379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
53380 if (!SWIG_IsOK(res1)) {
53381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
53382 }
53383 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
53384 {
53385 PyThreadState* __tstate = wxPyBeginAllowThreads();
53386 result = (wxStaticBox *)(arg1)->GetStaticBox();
53387 wxPyEndAllowThreads(__tstate);
53388 if (PyErr_Occurred()) SWIG_fail;
53389 }
53390 {
53391 resultobj = wxPyMake_wxObject(result, (bool)0);
53392 }
53393 return resultobj;
53394 fail:
53395 return NULL;
53396 }
53397
53398
53399 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53400 PyObject *obj;
53401 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53402 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
53403 return SWIG_Py_Void();
53404 }
53405
53406 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53407 return SWIG_Python_InitShadowInstance(args);
53408 }
53409
53410 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53411 PyObject *resultobj = 0;
53412 int arg1 = (int) 1 ;
53413 int arg2 = (int) 0 ;
53414 int arg3 = (int) 0 ;
53415 int arg4 = (int) 0 ;
53416 wxGridSizer *result = 0 ;
53417 int val1 ;
53418 int ecode1 = 0 ;
53419 int val2 ;
53420 int ecode2 = 0 ;
53421 int val3 ;
53422 int ecode3 = 0 ;
53423 int val4 ;
53424 int ecode4 = 0 ;
53425 PyObject * obj0 = 0 ;
53426 PyObject * obj1 = 0 ;
53427 PyObject * obj2 = 0 ;
53428 PyObject * obj3 = 0 ;
53429 char * kwnames[] = {
53430 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
53431 };
53432
53433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53434 if (obj0) {
53435 ecode1 = SWIG_AsVal_int(obj0, &val1);
53436 if (!SWIG_IsOK(ecode1)) {
53437 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
53438 }
53439 arg1 = static_cast< int >(val1);
53440 }
53441 if (obj1) {
53442 ecode2 = SWIG_AsVal_int(obj1, &val2);
53443 if (!SWIG_IsOK(ecode2)) {
53444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
53445 }
53446 arg2 = static_cast< int >(val2);
53447 }
53448 if (obj2) {
53449 ecode3 = SWIG_AsVal_int(obj2, &val3);
53450 if (!SWIG_IsOK(ecode3)) {
53451 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
53452 }
53453 arg3 = static_cast< int >(val3);
53454 }
53455 if (obj3) {
53456 ecode4 = SWIG_AsVal_int(obj3, &val4);
53457 if (!SWIG_IsOK(ecode4)) {
53458 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
53459 }
53460 arg4 = static_cast< int >(val4);
53461 }
53462 {
53463 PyThreadState* __tstate = wxPyBeginAllowThreads();
53464 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
53465 wxPyEndAllowThreads(__tstate);
53466 if (PyErr_Occurred()) SWIG_fail;
53467 }
53468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
53469 return resultobj;
53470 fail:
53471 return NULL;
53472 }
53473
53474
53475 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53476 PyObject *resultobj = 0;
53477 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53478 int arg2 ;
53479 void *argp1 = 0 ;
53480 int res1 = 0 ;
53481 int val2 ;
53482 int ecode2 = 0 ;
53483 PyObject * obj0 = 0 ;
53484 PyObject * obj1 = 0 ;
53485 char * kwnames[] = {
53486 (char *) "self",(char *) "cols", NULL
53487 };
53488
53489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
53490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53491 if (!SWIG_IsOK(res1)) {
53492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53493 }
53494 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53495 ecode2 = SWIG_AsVal_int(obj1, &val2);
53496 if (!SWIG_IsOK(ecode2)) {
53497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
53498 }
53499 arg2 = static_cast< int >(val2);
53500 {
53501 PyThreadState* __tstate = wxPyBeginAllowThreads();
53502 (arg1)->SetCols(arg2);
53503 wxPyEndAllowThreads(__tstate);
53504 if (PyErr_Occurred()) SWIG_fail;
53505 }
53506 resultobj = SWIG_Py_Void();
53507 return resultobj;
53508 fail:
53509 return NULL;
53510 }
53511
53512
53513 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53514 PyObject *resultobj = 0;
53515 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53516 int arg2 ;
53517 void *argp1 = 0 ;
53518 int res1 = 0 ;
53519 int val2 ;
53520 int ecode2 = 0 ;
53521 PyObject * obj0 = 0 ;
53522 PyObject * obj1 = 0 ;
53523 char * kwnames[] = {
53524 (char *) "self",(char *) "rows", NULL
53525 };
53526
53527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
53528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53529 if (!SWIG_IsOK(res1)) {
53530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53531 }
53532 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53533 ecode2 = SWIG_AsVal_int(obj1, &val2);
53534 if (!SWIG_IsOK(ecode2)) {
53535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
53536 }
53537 arg2 = static_cast< int >(val2);
53538 {
53539 PyThreadState* __tstate = wxPyBeginAllowThreads();
53540 (arg1)->SetRows(arg2);
53541 wxPyEndAllowThreads(__tstate);
53542 if (PyErr_Occurred()) SWIG_fail;
53543 }
53544 resultobj = SWIG_Py_Void();
53545 return resultobj;
53546 fail:
53547 return NULL;
53548 }
53549
53550
53551 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53552 PyObject *resultobj = 0;
53553 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53554 int arg2 ;
53555 void *argp1 = 0 ;
53556 int res1 = 0 ;
53557 int val2 ;
53558 int ecode2 = 0 ;
53559 PyObject * obj0 = 0 ;
53560 PyObject * obj1 = 0 ;
53561 char * kwnames[] = {
53562 (char *) "self",(char *) "gap", NULL
53563 };
53564
53565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
53566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53567 if (!SWIG_IsOK(res1)) {
53568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53569 }
53570 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53571 ecode2 = SWIG_AsVal_int(obj1, &val2);
53572 if (!SWIG_IsOK(ecode2)) {
53573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
53574 }
53575 arg2 = static_cast< int >(val2);
53576 {
53577 PyThreadState* __tstate = wxPyBeginAllowThreads();
53578 (arg1)->SetVGap(arg2);
53579 wxPyEndAllowThreads(__tstate);
53580 if (PyErr_Occurred()) SWIG_fail;
53581 }
53582 resultobj = SWIG_Py_Void();
53583 return resultobj;
53584 fail:
53585 return NULL;
53586 }
53587
53588
53589 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53590 PyObject *resultobj = 0;
53591 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53592 int arg2 ;
53593 void *argp1 = 0 ;
53594 int res1 = 0 ;
53595 int val2 ;
53596 int ecode2 = 0 ;
53597 PyObject * obj0 = 0 ;
53598 PyObject * obj1 = 0 ;
53599 char * kwnames[] = {
53600 (char *) "self",(char *) "gap", NULL
53601 };
53602
53603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
53604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53605 if (!SWIG_IsOK(res1)) {
53606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53607 }
53608 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53609 ecode2 = SWIG_AsVal_int(obj1, &val2);
53610 if (!SWIG_IsOK(ecode2)) {
53611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
53612 }
53613 arg2 = static_cast< int >(val2);
53614 {
53615 PyThreadState* __tstate = wxPyBeginAllowThreads();
53616 (arg1)->SetHGap(arg2);
53617 wxPyEndAllowThreads(__tstate);
53618 if (PyErr_Occurred()) SWIG_fail;
53619 }
53620 resultobj = SWIG_Py_Void();
53621 return resultobj;
53622 fail:
53623 return NULL;
53624 }
53625
53626
53627 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53628 PyObject *resultobj = 0;
53629 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53630 int result;
53631 void *argp1 = 0 ;
53632 int res1 = 0 ;
53633 PyObject *swig_obj[1] ;
53634
53635 if (!args) SWIG_fail;
53636 swig_obj[0] = args;
53637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53638 if (!SWIG_IsOK(res1)) {
53639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53640 }
53641 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53642 {
53643 PyThreadState* __tstate = wxPyBeginAllowThreads();
53644 result = (int)(arg1)->GetCols();
53645 wxPyEndAllowThreads(__tstate);
53646 if (PyErr_Occurred()) SWIG_fail;
53647 }
53648 resultobj = SWIG_From_int(static_cast< int >(result));
53649 return resultobj;
53650 fail:
53651 return NULL;
53652 }
53653
53654
53655 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53656 PyObject *resultobj = 0;
53657 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53658 int result;
53659 void *argp1 = 0 ;
53660 int res1 = 0 ;
53661 PyObject *swig_obj[1] ;
53662
53663 if (!args) SWIG_fail;
53664 swig_obj[0] = args;
53665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53666 if (!SWIG_IsOK(res1)) {
53667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53668 }
53669 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53670 {
53671 PyThreadState* __tstate = wxPyBeginAllowThreads();
53672 result = (int)(arg1)->GetRows();
53673 wxPyEndAllowThreads(__tstate);
53674 if (PyErr_Occurred()) SWIG_fail;
53675 }
53676 resultobj = SWIG_From_int(static_cast< int >(result));
53677 return resultobj;
53678 fail:
53679 return NULL;
53680 }
53681
53682
53683 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53684 PyObject *resultobj = 0;
53685 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53686 int result;
53687 void *argp1 = 0 ;
53688 int res1 = 0 ;
53689 PyObject *swig_obj[1] ;
53690
53691 if (!args) SWIG_fail;
53692 swig_obj[0] = args;
53693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53694 if (!SWIG_IsOK(res1)) {
53695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53696 }
53697 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53698 {
53699 PyThreadState* __tstate = wxPyBeginAllowThreads();
53700 result = (int)(arg1)->GetVGap();
53701 wxPyEndAllowThreads(__tstate);
53702 if (PyErr_Occurred()) SWIG_fail;
53703 }
53704 resultobj = SWIG_From_int(static_cast< int >(result));
53705 return resultobj;
53706 fail:
53707 return NULL;
53708 }
53709
53710
53711 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53712 PyObject *resultobj = 0;
53713 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53714 int result;
53715 void *argp1 = 0 ;
53716 int res1 = 0 ;
53717 PyObject *swig_obj[1] ;
53718
53719 if (!args) SWIG_fail;
53720 swig_obj[0] = args;
53721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53722 if (!SWIG_IsOK(res1)) {
53723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53724 }
53725 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53726 {
53727 PyThreadState* __tstate = wxPyBeginAllowThreads();
53728 result = (int)(arg1)->GetHGap();
53729 wxPyEndAllowThreads(__tstate);
53730 if (PyErr_Occurred()) SWIG_fail;
53731 }
53732 resultobj = SWIG_From_int(static_cast< int >(result));
53733 return resultobj;
53734 fail:
53735 return NULL;
53736 }
53737
53738
53739 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53740 PyObject *obj;
53741 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53742 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
53743 return SWIG_Py_Void();
53744 }
53745
53746 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53747 return SWIG_Python_InitShadowInstance(args);
53748 }
53749
53750 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53751 PyObject *resultobj = 0;
53752 int arg1 = (int) 1 ;
53753 int arg2 = (int) 0 ;
53754 int arg3 = (int) 0 ;
53755 int arg4 = (int) 0 ;
53756 wxFlexGridSizer *result = 0 ;
53757 int val1 ;
53758 int ecode1 = 0 ;
53759 int val2 ;
53760 int ecode2 = 0 ;
53761 int val3 ;
53762 int ecode3 = 0 ;
53763 int val4 ;
53764 int ecode4 = 0 ;
53765 PyObject * obj0 = 0 ;
53766 PyObject * obj1 = 0 ;
53767 PyObject * obj2 = 0 ;
53768 PyObject * obj3 = 0 ;
53769 char * kwnames[] = {
53770 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
53771 };
53772
53773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53774 if (obj0) {
53775 ecode1 = SWIG_AsVal_int(obj0, &val1);
53776 if (!SWIG_IsOK(ecode1)) {
53777 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
53778 }
53779 arg1 = static_cast< int >(val1);
53780 }
53781 if (obj1) {
53782 ecode2 = SWIG_AsVal_int(obj1, &val2);
53783 if (!SWIG_IsOK(ecode2)) {
53784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
53785 }
53786 arg2 = static_cast< int >(val2);
53787 }
53788 if (obj2) {
53789 ecode3 = SWIG_AsVal_int(obj2, &val3);
53790 if (!SWIG_IsOK(ecode3)) {
53791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
53792 }
53793 arg3 = static_cast< int >(val3);
53794 }
53795 if (obj3) {
53796 ecode4 = SWIG_AsVal_int(obj3, &val4);
53797 if (!SWIG_IsOK(ecode4)) {
53798 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
53799 }
53800 arg4 = static_cast< int >(val4);
53801 }
53802 {
53803 PyThreadState* __tstate = wxPyBeginAllowThreads();
53804 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
53805 wxPyEndAllowThreads(__tstate);
53806 if (PyErr_Occurred()) SWIG_fail;
53807 }
53808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
53809 return resultobj;
53810 fail:
53811 return NULL;
53812 }
53813
53814
53815 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53816 PyObject *resultobj = 0;
53817 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53818 size_t arg2 ;
53819 int arg3 = (int) 0 ;
53820 void *argp1 = 0 ;
53821 int res1 = 0 ;
53822 size_t val2 ;
53823 int ecode2 = 0 ;
53824 int val3 ;
53825 int ecode3 = 0 ;
53826 PyObject * obj0 = 0 ;
53827 PyObject * obj1 = 0 ;
53828 PyObject * obj2 = 0 ;
53829 char * kwnames[] = {
53830 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53831 };
53832
53833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53835 if (!SWIG_IsOK(res1)) {
53836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53837 }
53838 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53839 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53840 if (!SWIG_IsOK(ecode2)) {
53841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53842 }
53843 arg2 = static_cast< size_t >(val2);
53844 if (obj2) {
53845 ecode3 = SWIG_AsVal_int(obj2, &val3);
53846 if (!SWIG_IsOK(ecode3)) {
53847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
53848 }
53849 arg3 = static_cast< int >(val3);
53850 }
53851 {
53852 PyThreadState* __tstate = wxPyBeginAllowThreads();
53853 (arg1)->AddGrowableRow(arg2,arg3);
53854 wxPyEndAllowThreads(__tstate);
53855 if (PyErr_Occurred()) SWIG_fail;
53856 }
53857 resultobj = SWIG_Py_Void();
53858 return resultobj;
53859 fail:
53860 return NULL;
53861 }
53862
53863
53864 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53865 PyObject *resultobj = 0;
53866 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53867 size_t arg2 ;
53868 void *argp1 = 0 ;
53869 int res1 = 0 ;
53870 size_t val2 ;
53871 int ecode2 = 0 ;
53872 PyObject * obj0 = 0 ;
53873 PyObject * obj1 = 0 ;
53874 char * kwnames[] = {
53875 (char *) "self",(char *) "idx", NULL
53876 };
53877
53878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
53879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53880 if (!SWIG_IsOK(res1)) {
53881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53882 }
53883 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53884 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53885 if (!SWIG_IsOK(ecode2)) {
53886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53887 }
53888 arg2 = static_cast< size_t >(val2);
53889 {
53890 PyThreadState* __tstate = wxPyBeginAllowThreads();
53891 (arg1)->RemoveGrowableRow(arg2);
53892 wxPyEndAllowThreads(__tstate);
53893 if (PyErr_Occurred()) SWIG_fail;
53894 }
53895 resultobj = SWIG_Py_Void();
53896 return resultobj;
53897 fail:
53898 return NULL;
53899 }
53900
53901
53902 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53903 PyObject *resultobj = 0;
53904 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53905 size_t arg2 ;
53906 int arg3 = (int) 0 ;
53907 void *argp1 = 0 ;
53908 int res1 = 0 ;
53909 size_t val2 ;
53910 int ecode2 = 0 ;
53911 int val3 ;
53912 int ecode3 = 0 ;
53913 PyObject * obj0 = 0 ;
53914 PyObject * obj1 = 0 ;
53915 PyObject * obj2 = 0 ;
53916 char * kwnames[] = {
53917 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53918 };
53919
53920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53922 if (!SWIG_IsOK(res1)) {
53923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53924 }
53925 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53926 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53927 if (!SWIG_IsOK(ecode2)) {
53928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53929 }
53930 arg2 = static_cast< size_t >(val2);
53931 if (obj2) {
53932 ecode3 = SWIG_AsVal_int(obj2, &val3);
53933 if (!SWIG_IsOK(ecode3)) {
53934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
53935 }
53936 arg3 = static_cast< int >(val3);
53937 }
53938 {
53939 PyThreadState* __tstate = wxPyBeginAllowThreads();
53940 (arg1)->AddGrowableCol(arg2,arg3);
53941 wxPyEndAllowThreads(__tstate);
53942 if (PyErr_Occurred()) SWIG_fail;
53943 }
53944 resultobj = SWIG_Py_Void();
53945 return resultobj;
53946 fail:
53947 return NULL;
53948 }
53949
53950
53951 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53952 PyObject *resultobj = 0;
53953 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53954 size_t arg2 ;
53955 void *argp1 = 0 ;
53956 int res1 = 0 ;
53957 size_t val2 ;
53958 int ecode2 = 0 ;
53959 PyObject * obj0 = 0 ;
53960 PyObject * obj1 = 0 ;
53961 char * kwnames[] = {
53962 (char *) "self",(char *) "idx", NULL
53963 };
53964
53965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
53966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53967 if (!SWIG_IsOK(res1)) {
53968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53969 }
53970 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53971 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53972 if (!SWIG_IsOK(ecode2)) {
53973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53974 }
53975 arg2 = static_cast< size_t >(val2);
53976 {
53977 PyThreadState* __tstate = wxPyBeginAllowThreads();
53978 (arg1)->RemoveGrowableCol(arg2);
53979 wxPyEndAllowThreads(__tstate);
53980 if (PyErr_Occurred()) SWIG_fail;
53981 }
53982 resultobj = SWIG_Py_Void();
53983 return resultobj;
53984 fail:
53985 return NULL;
53986 }
53987
53988
53989 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53990 PyObject *resultobj = 0;
53991 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53992 int arg2 ;
53993 void *argp1 = 0 ;
53994 int res1 = 0 ;
53995 int val2 ;
53996 int ecode2 = 0 ;
53997 PyObject * obj0 = 0 ;
53998 PyObject * obj1 = 0 ;
53999 char * kwnames[] = {
54000 (char *) "self",(char *) "direction", NULL
54001 };
54002
54003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
54004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54005 if (!SWIG_IsOK(res1)) {
54006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
54007 }
54008 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54009 ecode2 = SWIG_AsVal_int(obj1, &val2);
54010 if (!SWIG_IsOK(ecode2)) {
54011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
54012 }
54013 arg2 = static_cast< int >(val2);
54014 {
54015 PyThreadState* __tstate = wxPyBeginAllowThreads();
54016 (arg1)->SetFlexibleDirection(arg2);
54017 wxPyEndAllowThreads(__tstate);
54018 if (PyErr_Occurred()) SWIG_fail;
54019 }
54020 resultobj = SWIG_Py_Void();
54021 return resultobj;
54022 fail:
54023 return NULL;
54024 }
54025
54026
54027 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54028 PyObject *resultobj = 0;
54029 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54030 int result;
54031 void *argp1 = 0 ;
54032 int res1 = 0 ;
54033 PyObject *swig_obj[1] ;
54034
54035 if (!args) SWIG_fail;
54036 swig_obj[0] = args;
54037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54038 if (!SWIG_IsOK(res1)) {
54039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
54040 }
54041 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54042 {
54043 PyThreadState* __tstate = wxPyBeginAllowThreads();
54044 result = (int)(arg1)->GetFlexibleDirection();
54045 wxPyEndAllowThreads(__tstate);
54046 if (PyErr_Occurred()) SWIG_fail;
54047 }
54048 resultobj = SWIG_From_int(static_cast< int >(result));
54049 return resultobj;
54050 fail:
54051 return NULL;
54052 }
54053
54054
54055 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54056 PyObject *resultobj = 0;
54057 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54058 wxFlexSizerGrowMode arg2 ;
54059 void *argp1 = 0 ;
54060 int res1 = 0 ;
54061 int val2 ;
54062 int ecode2 = 0 ;
54063 PyObject * obj0 = 0 ;
54064 PyObject * obj1 = 0 ;
54065 char * kwnames[] = {
54066 (char *) "self",(char *) "mode", NULL
54067 };
54068
54069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
54070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54071 if (!SWIG_IsOK(res1)) {
54072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
54073 }
54074 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54075 ecode2 = SWIG_AsVal_int(obj1, &val2);
54076 if (!SWIG_IsOK(ecode2)) {
54077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
54078 }
54079 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
54080 {
54081 PyThreadState* __tstate = wxPyBeginAllowThreads();
54082 (arg1)->SetNonFlexibleGrowMode(arg2);
54083 wxPyEndAllowThreads(__tstate);
54084 if (PyErr_Occurred()) SWIG_fail;
54085 }
54086 resultobj = SWIG_Py_Void();
54087 return resultobj;
54088 fail:
54089 return NULL;
54090 }
54091
54092
54093 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54094 PyObject *resultobj = 0;
54095 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54096 wxFlexSizerGrowMode result;
54097 void *argp1 = 0 ;
54098 int res1 = 0 ;
54099 PyObject *swig_obj[1] ;
54100
54101 if (!args) SWIG_fail;
54102 swig_obj[0] = args;
54103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54104 if (!SWIG_IsOK(res1)) {
54105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
54106 }
54107 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54108 {
54109 PyThreadState* __tstate = wxPyBeginAllowThreads();
54110 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
54111 wxPyEndAllowThreads(__tstate);
54112 if (PyErr_Occurred()) SWIG_fail;
54113 }
54114 resultobj = SWIG_From_int(static_cast< int >(result));
54115 return resultobj;
54116 fail:
54117 return NULL;
54118 }
54119
54120
54121 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54122 PyObject *resultobj = 0;
54123 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54124 wxArrayInt *result = 0 ;
54125 void *argp1 = 0 ;
54126 int res1 = 0 ;
54127 PyObject *swig_obj[1] ;
54128
54129 if (!args) SWIG_fail;
54130 swig_obj[0] = args;
54131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54132 if (!SWIG_IsOK(res1)) {
54133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
54134 }
54135 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54136 {
54137 PyThreadState* __tstate = wxPyBeginAllowThreads();
54138 {
54139 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
54140 result = (wxArrayInt *) &_result_ref;
54141 }
54142 wxPyEndAllowThreads(__tstate);
54143 if (PyErr_Occurred()) SWIG_fail;
54144 }
54145 {
54146 resultobj = wxArrayInt2PyList_helper(*result);
54147 }
54148 return resultobj;
54149 fail:
54150 return NULL;
54151 }
54152
54153
54154 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54155 PyObject *resultobj = 0;
54156 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54157 wxArrayInt *result = 0 ;
54158 void *argp1 = 0 ;
54159 int res1 = 0 ;
54160 PyObject *swig_obj[1] ;
54161
54162 if (!args) SWIG_fail;
54163 swig_obj[0] = args;
54164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54165 if (!SWIG_IsOK(res1)) {
54166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
54167 }
54168 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54169 {
54170 PyThreadState* __tstate = wxPyBeginAllowThreads();
54171 {
54172 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
54173 result = (wxArrayInt *) &_result_ref;
54174 }
54175 wxPyEndAllowThreads(__tstate);
54176 if (PyErr_Occurred()) SWIG_fail;
54177 }
54178 {
54179 resultobj = wxArrayInt2PyList_helper(*result);
54180 }
54181 return resultobj;
54182 fail:
54183 return NULL;
54184 }
54185
54186
54187 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54188 PyObject *obj;
54189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54190 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
54191 return SWIG_Py_Void();
54192 }
54193
54194 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54195 return SWIG_Python_InitShadowInstance(args);
54196 }
54197
54198 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54199 PyObject *resultobj = 0;
54200 wxStdDialogButtonSizer *result = 0 ;
54201
54202 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
54203 {
54204 PyThreadState* __tstate = wxPyBeginAllowThreads();
54205 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
54206 wxPyEndAllowThreads(__tstate);
54207 if (PyErr_Occurred()) SWIG_fail;
54208 }
54209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
54210 return resultobj;
54211 fail:
54212 return NULL;
54213 }
54214
54215
54216 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54217 PyObject *resultobj = 0;
54218 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54219 wxButton *arg2 = (wxButton *) 0 ;
54220 void *argp1 = 0 ;
54221 int res1 = 0 ;
54222 void *argp2 = 0 ;
54223 int res2 = 0 ;
54224 PyObject * obj0 = 0 ;
54225 PyObject * obj1 = 0 ;
54226 char * kwnames[] = {
54227 (char *) "self",(char *) "button", NULL
54228 };
54229
54230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
54231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54232 if (!SWIG_IsOK(res1)) {
54233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54234 }
54235 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54236 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54237 if (!SWIG_IsOK(res2)) {
54238 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
54239 }
54240 arg2 = reinterpret_cast< wxButton * >(argp2);
54241 {
54242 PyThreadState* __tstate = wxPyBeginAllowThreads();
54243 (arg1)->AddButton(arg2);
54244 wxPyEndAllowThreads(__tstate);
54245 if (PyErr_Occurred()) SWIG_fail;
54246 }
54247 resultobj = SWIG_Py_Void();
54248 return resultobj;
54249 fail:
54250 return NULL;
54251 }
54252
54253
54254 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54255 PyObject *resultobj = 0;
54256 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54257 void *argp1 = 0 ;
54258 int res1 = 0 ;
54259 PyObject *swig_obj[1] ;
54260
54261 if (!args) SWIG_fail;
54262 swig_obj[0] = args;
54263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54264 if (!SWIG_IsOK(res1)) {
54265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54266 }
54267 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54268 {
54269 PyThreadState* __tstate = wxPyBeginAllowThreads();
54270 (arg1)->Realize();
54271 wxPyEndAllowThreads(__tstate);
54272 if (PyErr_Occurred()) SWIG_fail;
54273 }
54274 resultobj = SWIG_Py_Void();
54275 return resultobj;
54276 fail:
54277 return NULL;
54278 }
54279
54280
54281 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54282 PyObject *resultobj = 0;
54283 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54284 wxButton *arg2 = (wxButton *) 0 ;
54285 void *argp1 = 0 ;
54286 int res1 = 0 ;
54287 void *argp2 = 0 ;
54288 int res2 = 0 ;
54289 PyObject * obj0 = 0 ;
54290 PyObject * obj1 = 0 ;
54291 char * kwnames[] = {
54292 (char *) "self",(char *) "button", NULL
54293 };
54294
54295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
54296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54297 if (!SWIG_IsOK(res1)) {
54298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54299 }
54300 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54301 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54302 if (!SWIG_IsOK(res2)) {
54303 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
54304 }
54305 arg2 = reinterpret_cast< wxButton * >(argp2);
54306 {
54307 PyThreadState* __tstate = wxPyBeginAllowThreads();
54308 (arg1)->SetAffirmativeButton(arg2);
54309 wxPyEndAllowThreads(__tstate);
54310 if (PyErr_Occurred()) SWIG_fail;
54311 }
54312 resultobj = SWIG_Py_Void();
54313 return resultobj;
54314 fail:
54315 return NULL;
54316 }
54317
54318
54319 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54320 PyObject *resultobj = 0;
54321 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54322 wxButton *arg2 = (wxButton *) 0 ;
54323 void *argp1 = 0 ;
54324 int res1 = 0 ;
54325 void *argp2 = 0 ;
54326 int res2 = 0 ;
54327 PyObject * obj0 = 0 ;
54328 PyObject * obj1 = 0 ;
54329 char * kwnames[] = {
54330 (char *) "self",(char *) "button", NULL
54331 };
54332
54333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
54334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54335 if (!SWIG_IsOK(res1)) {
54336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54337 }
54338 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54339 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54340 if (!SWIG_IsOK(res2)) {
54341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
54342 }
54343 arg2 = reinterpret_cast< wxButton * >(argp2);
54344 {
54345 PyThreadState* __tstate = wxPyBeginAllowThreads();
54346 (arg1)->SetNegativeButton(arg2);
54347 wxPyEndAllowThreads(__tstate);
54348 if (PyErr_Occurred()) SWIG_fail;
54349 }
54350 resultobj = SWIG_Py_Void();
54351 return resultobj;
54352 fail:
54353 return NULL;
54354 }
54355
54356
54357 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54358 PyObject *resultobj = 0;
54359 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54360 wxButton *arg2 = (wxButton *) 0 ;
54361 void *argp1 = 0 ;
54362 int res1 = 0 ;
54363 void *argp2 = 0 ;
54364 int res2 = 0 ;
54365 PyObject * obj0 = 0 ;
54366 PyObject * obj1 = 0 ;
54367 char * kwnames[] = {
54368 (char *) "self",(char *) "button", NULL
54369 };
54370
54371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
54372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54373 if (!SWIG_IsOK(res1)) {
54374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54375 }
54376 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54378 if (!SWIG_IsOK(res2)) {
54379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
54380 }
54381 arg2 = reinterpret_cast< wxButton * >(argp2);
54382 {
54383 PyThreadState* __tstate = wxPyBeginAllowThreads();
54384 (arg1)->SetCancelButton(arg2);
54385 wxPyEndAllowThreads(__tstate);
54386 if (PyErr_Occurred()) SWIG_fail;
54387 }
54388 resultobj = SWIG_Py_Void();
54389 return resultobj;
54390 fail:
54391 return NULL;
54392 }
54393
54394
54395 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54396 PyObject *resultobj = 0;
54397 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54398 wxButton *result = 0 ;
54399 void *argp1 = 0 ;
54400 int res1 = 0 ;
54401 PyObject *swig_obj[1] ;
54402
54403 if (!args) SWIG_fail;
54404 swig_obj[0] = args;
54405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54406 if (!SWIG_IsOK(res1)) {
54407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54408 }
54409 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54410 {
54411 PyThreadState* __tstate = wxPyBeginAllowThreads();
54412 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
54413 wxPyEndAllowThreads(__tstate);
54414 if (PyErr_Occurred()) SWIG_fail;
54415 }
54416 {
54417 resultobj = wxPyMake_wxObject(result, (bool)0);
54418 }
54419 return resultobj;
54420 fail:
54421 return NULL;
54422 }
54423
54424
54425 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54426 PyObject *resultobj = 0;
54427 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54428 wxButton *result = 0 ;
54429 void *argp1 = 0 ;
54430 int res1 = 0 ;
54431 PyObject *swig_obj[1] ;
54432
54433 if (!args) SWIG_fail;
54434 swig_obj[0] = args;
54435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54436 if (!SWIG_IsOK(res1)) {
54437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54438 }
54439 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54440 {
54441 PyThreadState* __tstate = wxPyBeginAllowThreads();
54442 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
54443 wxPyEndAllowThreads(__tstate);
54444 if (PyErr_Occurred()) SWIG_fail;
54445 }
54446 {
54447 resultobj = wxPyMake_wxObject(result, (bool)0);
54448 }
54449 return resultobj;
54450 fail:
54451 return NULL;
54452 }
54453
54454
54455 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54456 PyObject *resultobj = 0;
54457 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54458 wxButton *result = 0 ;
54459 void *argp1 = 0 ;
54460 int res1 = 0 ;
54461 PyObject *swig_obj[1] ;
54462
54463 if (!args) SWIG_fail;
54464 swig_obj[0] = args;
54465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54466 if (!SWIG_IsOK(res1)) {
54467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54468 }
54469 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54470 {
54471 PyThreadState* __tstate = wxPyBeginAllowThreads();
54472 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
54473 wxPyEndAllowThreads(__tstate);
54474 if (PyErr_Occurred()) SWIG_fail;
54475 }
54476 {
54477 resultobj = wxPyMake_wxObject(result, (bool)0);
54478 }
54479 return resultobj;
54480 fail:
54481 return NULL;
54482 }
54483
54484
54485 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54486 PyObject *resultobj = 0;
54487 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54488 wxButton *result = 0 ;
54489 void *argp1 = 0 ;
54490 int res1 = 0 ;
54491 PyObject *swig_obj[1] ;
54492
54493 if (!args) SWIG_fail;
54494 swig_obj[0] = args;
54495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54496 if (!SWIG_IsOK(res1)) {
54497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54498 }
54499 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54500 {
54501 PyThreadState* __tstate = wxPyBeginAllowThreads();
54502 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
54503 wxPyEndAllowThreads(__tstate);
54504 if (PyErr_Occurred()) SWIG_fail;
54505 }
54506 {
54507 resultobj = wxPyMake_wxObject(result, (bool)0);
54508 }
54509 return resultobj;
54510 fail:
54511 return NULL;
54512 }
54513
54514
54515 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54516 PyObject *resultobj = 0;
54517 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54518 wxButton *result = 0 ;
54519 void *argp1 = 0 ;
54520 int res1 = 0 ;
54521 PyObject *swig_obj[1] ;
54522
54523 if (!args) SWIG_fail;
54524 swig_obj[0] = args;
54525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54526 if (!SWIG_IsOK(res1)) {
54527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54528 }
54529 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54530 {
54531 PyThreadState* __tstate = wxPyBeginAllowThreads();
54532 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
54533 wxPyEndAllowThreads(__tstate);
54534 if (PyErr_Occurred()) SWIG_fail;
54535 }
54536 {
54537 resultobj = wxPyMake_wxObject(result, (bool)0);
54538 }
54539 return resultobj;
54540 fail:
54541 return NULL;
54542 }
54543
54544
54545 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54546 PyObject *obj;
54547 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54548 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
54549 return SWIG_Py_Void();
54550 }
54551
54552 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54553 return SWIG_Python_InitShadowInstance(args);
54554 }
54555
54556 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54557 PyObject *resultobj = 0;
54558 int arg1 = (int) 0 ;
54559 int arg2 = (int) 0 ;
54560 wxGBPosition *result = 0 ;
54561 int val1 ;
54562 int ecode1 = 0 ;
54563 int val2 ;
54564 int ecode2 = 0 ;
54565 PyObject * obj0 = 0 ;
54566 PyObject * obj1 = 0 ;
54567 char * kwnames[] = {
54568 (char *) "row",(char *) "col", NULL
54569 };
54570
54571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54572 if (obj0) {
54573 ecode1 = SWIG_AsVal_int(obj0, &val1);
54574 if (!SWIG_IsOK(ecode1)) {
54575 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
54576 }
54577 arg1 = static_cast< int >(val1);
54578 }
54579 if (obj1) {
54580 ecode2 = SWIG_AsVal_int(obj1, &val2);
54581 if (!SWIG_IsOK(ecode2)) {
54582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
54583 }
54584 arg2 = static_cast< int >(val2);
54585 }
54586 {
54587 PyThreadState* __tstate = wxPyBeginAllowThreads();
54588 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
54589 wxPyEndAllowThreads(__tstate);
54590 if (PyErr_Occurred()) SWIG_fail;
54591 }
54592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
54593 return resultobj;
54594 fail:
54595 return NULL;
54596 }
54597
54598
54599 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54600 PyObject *resultobj = 0;
54601 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54602 void *argp1 = 0 ;
54603 int res1 = 0 ;
54604 PyObject *swig_obj[1] ;
54605
54606 if (!args) SWIG_fail;
54607 swig_obj[0] = args;
54608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
54609 if (!SWIG_IsOK(res1)) {
54610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54611 }
54612 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54613 {
54614 PyThreadState* __tstate = wxPyBeginAllowThreads();
54615 delete arg1;
54616
54617 wxPyEndAllowThreads(__tstate);
54618 if (PyErr_Occurred()) SWIG_fail;
54619 }
54620 resultobj = SWIG_Py_Void();
54621 return resultobj;
54622 fail:
54623 return NULL;
54624 }
54625
54626
54627 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54628 PyObject *resultobj = 0;
54629 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54630 int result;
54631 void *argp1 = 0 ;
54632 int res1 = 0 ;
54633 PyObject *swig_obj[1] ;
54634
54635 if (!args) SWIG_fail;
54636 swig_obj[0] = args;
54637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54638 if (!SWIG_IsOK(res1)) {
54639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
54640 }
54641 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54642 {
54643 PyThreadState* __tstate = wxPyBeginAllowThreads();
54644 result = (int)((wxGBPosition const *)arg1)->GetRow();
54645 wxPyEndAllowThreads(__tstate);
54646 if (PyErr_Occurred()) SWIG_fail;
54647 }
54648 resultobj = SWIG_From_int(static_cast< int >(result));
54649 return resultobj;
54650 fail:
54651 return NULL;
54652 }
54653
54654
54655 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54656 PyObject *resultobj = 0;
54657 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54658 int result;
54659 void *argp1 = 0 ;
54660 int res1 = 0 ;
54661 PyObject *swig_obj[1] ;
54662
54663 if (!args) SWIG_fail;
54664 swig_obj[0] = args;
54665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54666 if (!SWIG_IsOK(res1)) {
54667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
54668 }
54669 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54670 {
54671 PyThreadState* __tstate = wxPyBeginAllowThreads();
54672 result = (int)((wxGBPosition const *)arg1)->GetCol();
54673 wxPyEndAllowThreads(__tstate);
54674 if (PyErr_Occurred()) SWIG_fail;
54675 }
54676 resultobj = SWIG_From_int(static_cast< int >(result));
54677 return resultobj;
54678 fail:
54679 return NULL;
54680 }
54681
54682
54683 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54684 PyObject *resultobj = 0;
54685 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54686 int arg2 ;
54687 void *argp1 = 0 ;
54688 int res1 = 0 ;
54689 int val2 ;
54690 int ecode2 = 0 ;
54691 PyObject * obj0 = 0 ;
54692 PyObject * obj1 = 0 ;
54693 char * kwnames[] = {
54694 (char *) "self",(char *) "row", NULL
54695 };
54696
54697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
54698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54699 if (!SWIG_IsOK(res1)) {
54700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54701 }
54702 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54703 ecode2 = SWIG_AsVal_int(obj1, &val2);
54704 if (!SWIG_IsOK(ecode2)) {
54705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
54706 }
54707 arg2 = static_cast< int >(val2);
54708 {
54709 PyThreadState* __tstate = wxPyBeginAllowThreads();
54710 (arg1)->SetRow(arg2);
54711 wxPyEndAllowThreads(__tstate);
54712 if (PyErr_Occurred()) SWIG_fail;
54713 }
54714 resultobj = SWIG_Py_Void();
54715 return resultobj;
54716 fail:
54717 return NULL;
54718 }
54719
54720
54721 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54722 PyObject *resultobj = 0;
54723 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54724 int arg2 ;
54725 void *argp1 = 0 ;
54726 int res1 = 0 ;
54727 int val2 ;
54728 int ecode2 = 0 ;
54729 PyObject * obj0 = 0 ;
54730 PyObject * obj1 = 0 ;
54731 char * kwnames[] = {
54732 (char *) "self",(char *) "col", NULL
54733 };
54734
54735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
54736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54737 if (!SWIG_IsOK(res1)) {
54738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54739 }
54740 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54741 ecode2 = SWIG_AsVal_int(obj1, &val2);
54742 if (!SWIG_IsOK(ecode2)) {
54743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
54744 }
54745 arg2 = static_cast< int >(val2);
54746 {
54747 PyThreadState* __tstate = wxPyBeginAllowThreads();
54748 (arg1)->SetCol(arg2);
54749 wxPyEndAllowThreads(__tstate);
54750 if (PyErr_Occurred()) SWIG_fail;
54751 }
54752 resultobj = SWIG_Py_Void();
54753 return resultobj;
54754 fail:
54755 return NULL;
54756 }
54757
54758
54759 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54760 PyObject *resultobj = 0;
54761 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54762 PyObject *arg2 = (PyObject *) 0 ;
54763 bool result;
54764 void *argp1 = 0 ;
54765 int res1 = 0 ;
54766 PyObject * obj0 = 0 ;
54767 PyObject * obj1 = 0 ;
54768 char * kwnames[] = {
54769 (char *) "self",(char *) "other", NULL
54770 };
54771
54772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
54773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54774 if (!SWIG_IsOK(res1)) {
54775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54776 }
54777 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54778 arg2 = obj1;
54779 {
54780 result = (bool)wxGBPosition___eq__(arg1,arg2);
54781 if (PyErr_Occurred()) SWIG_fail;
54782 }
54783 {
54784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54785 }
54786 return resultobj;
54787 fail:
54788 return NULL;
54789 }
54790
54791
54792 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54793 PyObject *resultobj = 0;
54794 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54795 PyObject *arg2 = (PyObject *) 0 ;
54796 bool result;
54797 void *argp1 = 0 ;
54798 int res1 = 0 ;
54799 PyObject * obj0 = 0 ;
54800 PyObject * obj1 = 0 ;
54801 char * kwnames[] = {
54802 (char *) "self",(char *) "other", NULL
54803 };
54804
54805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
54806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54807 if (!SWIG_IsOK(res1)) {
54808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54809 }
54810 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54811 arg2 = obj1;
54812 {
54813 result = (bool)wxGBPosition___ne__(arg1,arg2);
54814 if (PyErr_Occurred()) SWIG_fail;
54815 }
54816 {
54817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54818 }
54819 return resultobj;
54820 fail:
54821 return NULL;
54822 }
54823
54824
54825 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54826 PyObject *resultobj = 0;
54827 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54828 int arg2 = (int) 0 ;
54829 int arg3 = (int) 0 ;
54830 void *argp1 = 0 ;
54831 int res1 = 0 ;
54832 int val2 ;
54833 int ecode2 = 0 ;
54834 int val3 ;
54835 int ecode3 = 0 ;
54836 PyObject * obj0 = 0 ;
54837 PyObject * obj1 = 0 ;
54838 PyObject * obj2 = 0 ;
54839 char * kwnames[] = {
54840 (char *) "self",(char *) "row",(char *) "col", NULL
54841 };
54842
54843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54845 if (!SWIG_IsOK(res1)) {
54846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54847 }
54848 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54849 if (obj1) {
54850 ecode2 = SWIG_AsVal_int(obj1, &val2);
54851 if (!SWIG_IsOK(ecode2)) {
54852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
54853 }
54854 arg2 = static_cast< int >(val2);
54855 }
54856 if (obj2) {
54857 ecode3 = SWIG_AsVal_int(obj2, &val3);
54858 if (!SWIG_IsOK(ecode3)) {
54859 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
54860 }
54861 arg3 = static_cast< int >(val3);
54862 }
54863 {
54864 PyThreadState* __tstate = wxPyBeginAllowThreads();
54865 wxGBPosition_Set(arg1,arg2,arg3);
54866 wxPyEndAllowThreads(__tstate);
54867 if (PyErr_Occurred()) SWIG_fail;
54868 }
54869 resultobj = SWIG_Py_Void();
54870 return resultobj;
54871 fail:
54872 return NULL;
54873 }
54874
54875
54876 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54877 PyObject *resultobj = 0;
54878 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54879 PyObject *result = 0 ;
54880 void *argp1 = 0 ;
54881 int res1 = 0 ;
54882 PyObject *swig_obj[1] ;
54883
54884 if (!args) SWIG_fail;
54885 swig_obj[0] = args;
54886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54887 if (!SWIG_IsOK(res1)) {
54888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54889 }
54890 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54891 {
54892 PyThreadState* __tstate = wxPyBeginAllowThreads();
54893 result = (PyObject *)wxGBPosition_Get(arg1);
54894 wxPyEndAllowThreads(__tstate);
54895 if (PyErr_Occurred()) SWIG_fail;
54896 }
54897 resultobj = result;
54898 return resultobj;
54899 fail:
54900 return NULL;
54901 }
54902
54903
54904 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54905 PyObject *obj;
54906 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54907 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
54908 return SWIG_Py_Void();
54909 }
54910
54911 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54912 return SWIG_Python_InitShadowInstance(args);
54913 }
54914
54915 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54916 PyObject *resultobj = 0;
54917 int arg1 = (int) 1 ;
54918 int arg2 = (int) 1 ;
54919 wxGBSpan *result = 0 ;
54920 int val1 ;
54921 int ecode1 = 0 ;
54922 int val2 ;
54923 int ecode2 = 0 ;
54924 PyObject * obj0 = 0 ;
54925 PyObject * obj1 = 0 ;
54926 char * kwnames[] = {
54927 (char *) "rowspan",(char *) "colspan", NULL
54928 };
54929
54930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
54931 if (obj0) {
54932 ecode1 = SWIG_AsVal_int(obj0, &val1);
54933 if (!SWIG_IsOK(ecode1)) {
54934 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
54935 }
54936 arg1 = static_cast< int >(val1);
54937 }
54938 if (obj1) {
54939 ecode2 = SWIG_AsVal_int(obj1, &val2);
54940 if (!SWIG_IsOK(ecode2)) {
54941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
54942 }
54943 arg2 = static_cast< int >(val2);
54944 }
54945 {
54946 PyThreadState* __tstate = wxPyBeginAllowThreads();
54947 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
54948 wxPyEndAllowThreads(__tstate);
54949 if (PyErr_Occurred()) SWIG_fail;
54950 }
54951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
54952 return resultobj;
54953 fail:
54954 return NULL;
54955 }
54956
54957
54958 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54959 PyObject *resultobj = 0;
54960 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54961 void *argp1 = 0 ;
54962 int res1 = 0 ;
54963 PyObject *swig_obj[1] ;
54964
54965 if (!args) SWIG_fail;
54966 swig_obj[0] = args;
54967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
54968 if (!SWIG_IsOK(res1)) {
54969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54970 }
54971 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54972 {
54973 PyThreadState* __tstate = wxPyBeginAllowThreads();
54974 delete arg1;
54975
54976 wxPyEndAllowThreads(__tstate);
54977 if (PyErr_Occurred()) SWIG_fail;
54978 }
54979 resultobj = SWIG_Py_Void();
54980 return resultobj;
54981 fail:
54982 return NULL;
54983 }
54984
54985
54986 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54987 PyObject *resultobj = 0;
54988 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54989 int result;
54990 void *argp1 = 0 ;
54991 int res1 = 0 ;
54992 PyObject *swig_obj[1] ;
54993
54994 if (!args) SWIG_fail;
54995 swig_obj[0] = args;
54996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54997 if (!SWIG_IsOK(res1)) {
54998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54999 }
55000 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55001 {
55002 PyThreadState* __tstate = wxPyBeginAllowThreads();
55003 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
55004 wxPyEndAllowThreads(__tstate);
55005 if (PyErr_Occurred()) SWIG_fail;
55006 }
55007 resultobj = SWIG_From_int(static_cast< int >(result));
55008 return resultobj;
55009 fail:
55010 return NULL;
55011 }
55012
55013
55014 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55015 PyObject *resultobj = 0;
55016 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55017 int result;
55018 void *argp1 = 0 ;
55019 int res1 = 0 ;
55020 PyObject *swig_obj[1] ;
55021
55022 if (!args) SWIG_fail;
55023 swig_obj[0] = args;
55024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55025 if (!SWIG_IsOK(res1)) {
55026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
55027 }
55028 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55029 {
55030 PyThreadState* __tstate = wxPyBeginAllowThreads();
55031 result = (int)((wxGBSpan const *)arg1)->GetColspan();
55032 wxPyEndAllowThreads(__tstate);
55033 if (PyErr_Occurred()) SWIG_fail;
55034 }
55035 resultobj = SWIG_From_int(static_cast< int >(result));
55036 return resultobj;
55037 fail:
55038 return NULL;
55039 }
55040
55041
55042 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55043 PyObject *resultobj = 0;
55044 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55045 int arg2 ;
55046 void *argp1 = 0 ;
55047 int res1 = 0 ;
55048 int val2 ;
55049 int ecode2 = 0 ;
55050 PyObject * obj0 = 0 ;
55051 PyObject * obj1 = 0 ;
55052 char * kwnames[] = {
55053 (char *) "self",(char *) "rowspan", NULL
55054 };
55055
55056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
55057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55058 if (!SWIG_IsOK(res1)) {
55059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55060 }
55061 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55062 ecode2 = SWIG_AsVal_int(obj1, &val2);
55063 if (!SWIG_IsOK(ecode2)) {
55064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
55065 }
55066 arg2 = static_cast< int >(val2);
55067 {
55068 PyThreadState* __tstate = wxPyBeginAllowThreads();
55069 (arg1)->SetRowspan(arg2);
55070 wxPyEndAllowThreads(__tstate);
55071 if (PyErr_Occurred()) SWIG_fail;
55072 }
55073 resultobj = SWIG_Py_Void();
55074 return resultobj;
55075 fail:
55076 return NULL;
55077 }
55078
55079
55080 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55081 PyObject *resultobj = 0;
55082 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55083 int arg2 ;
55084 void *argp1 = 0 ;
55085 int res1 = 0 ;
55086 int val2 ;
55087 int ecode2 = 0 ;
55088 PyObject * obj0 = 0 ;
55089 PyObject * obj1 = 0 ;
55090 char * kwnames[] = {
55091 (char *) "self",(char *) "colspan", NULL
55092 };
55093
55094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
55095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55096 if (!SWIG_IsOK(res1)) {
55097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55098 }
55099 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55100 ecode2 = SWIG_AsVal_int(obj1, &val2);
55101 if (!SWIG_IsOK(ecode2)) {
55102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
55103 }
55104 arg2 = static_cast< int >(val2);
55105 {
55106 PyThreadState* __tstate = wxPyBeginAllowThreads();
55107 (arg1)->SetColspan(arg2);
55108 wxPyEndAllowThreads(__tstate);
55109 if (PyErr_Occurred()) SWIG_fail;
55110 }
55111 resultobj = SWIG_Py_Void();
55112 return resultobj;
55113 fail:
55114 return NULL;
55115 }
55116
55117
55118 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55119 PyObject *resultobj = 0;
55120 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55121 PyObject *arg2 = (PyObject *) 0 ;
55122 bool result;
55123 void *argp1 = 0 ;
55124 int res1 = 0 ;
55125 PyObject * obj0 = 0 ;
55126 PyObject * obj1 = 0 ;
55127 char * kwnames[] = {
55128 (char *) "self",(char *) "other", NULL
55129 };
55130
55131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
55132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55133 if (!SWIG_IsOK(res1)) {
55134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55135 }
55136 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55137 arg2 = obj1;
55138 {
55139 result = (bool)wxGBSpan___eq__(arg1,arg2);
55140 if (PyErr_Occurred()) SWIG_fail;
55141 }
55142 {
55143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55144 }
55145 return resultobj;
55146 fail:
55147 return NULL;
55148 }
55149
55150
55151 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55152 PyObject *resultobj = 0;
55153 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55154 PyObject *arg2 = (PyObject *) 0 ;
55155 bool result;
55156 void *argp1 = 0 ;
55157 int res1 = 0 ;
55158 PyObject * obj0 = 0 ;
55159 PyObject * obj1 = 0 ;
55160 char * kwnames[] = {
55161 (char *) "self",(char *) "other", NULL
55162 };
55163
55164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
55165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55166 if (!SWIG_IsOK(res1)) {
55167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55168 }
55169 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55170 arg2 = obj1;
55171 {
55172 result = (bool)wxGBSpan___ne__(arg1,arg2);
55173 if (PyErr_Occurred()) SWIG_fail;
55174 }
55175 {
55176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55177 }
55178 return resultobj;
55179 fail:
55180 return NULL;
55181 }
55182
55183
55184 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55185 PyObject *resultobj = 0;
55186 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55187 int arg2 = (int) 1 ;
55188 int arg3 = (int) 1 ;
55189 void *argp1 = 0 ;
55190 int res1 = 0 ;
55191 int val2 ;
55192 int ecode2 = 0 ;
55193 int val3 ;
55194 int ecode3 = 0 ;
55195 PyObject * obj0 = 0 ;
55196 PyObject * obj1 = 0 ;
55197 PyObject * obj2 = 0 ;
55198 char * kwnames[] = {
55199 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
55200 };
55201
55202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55204 if (!SWIG_IsOK(res1)) {
55205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55206 }
55207 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55208 if (obj1) {
55209 ecode2 = SWIG_AsVal_int(obj1, &val2);
55210 if (!SWIG_IsOK(ecode2)) {
55211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
55212 }
55213 arg2 = static_cast< int >(val2);
55214 }
55215 if (obj2) {
55216 ecode3 = SWIG_AsVal_int(obj2, &val3);
55217 if (!SWIG_IsOK(ecode3)) {
55218 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
55219 }
55220 arg3 = static_cast< int >(val3);
55221 }
55222 {
55223 PyThreadState* __tstate = wxPyBeginAllowThreads();
55224 wxGBSpan_Set(arg1,arg2,arg3);
55225 wxPyEndAllowThreads(__tstate);
55226 if (PyErr_Occurred()) SWIG_fail;
55227 }
55228 resultobj = SWIG_Py_Void();
55229 return resultobj;
55230 fail:
55231 return NULL;
55232 }
55233
55234
55235 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55236 PyObject *resultobj = 0;
55237 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55238 PyObject *result = 0 ;
55239 void *argp1 = 0 ;
55240 int res1 = 0 ;
55241 PyObject *swig_obj[1] ;
55242
55243 if (!args) SWIG_fail;
55244 swig_obj[0] = args;
55245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55246 if (!SWIG_IsOK(res1)) {
55247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55248 }
55249 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55250 {
55251 PyThreadState* __tstate = wxPyBeginAllowThreads();
55252 result = (PyObject *)wxGBSpan_Get(arg1);
55253 wxPyEndAllowThreads(__tstate);
55254 if (PyErr_Occurred()) SWIG_fail;
55255 }
55256 resultobj = result;
55257 return resultobj;
55258 fail:
55259 return NULL;
55260 }
55261
55262
55263 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55264 PyObject *obj;
55265 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55266 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
55267 return SWIG_Py_Void();
55268 }
55269
55270 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55271 return SWIG_Python_InitShadowInstance(args);
55272 }
55273
55274 SWIGINTERN int DefaultSpan_set(PyObject *) {
55275 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
55276 return 1;
55277 }
55278
55279
55280 SWIGINTERN PyObject *DefaultSpan_get(void) {
55281 PyObject *pyobj = 0;
55282
55283 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
55284 return pyobj;
55285 }
55286
55287
55288 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55289 PyObject *resultobj = 0;
55290 wxGBSizerItem *result = 0 ;
55291
55292 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
55293 {
55294 PyThreadState* __tstate = wxPyBeginAllowThreads();
55295 result = (wxGBSizerItem *)new wxGBSizerItem();
55296 wxPyEndAllowThreads(__tstate);
55297 if (PyErr_Occurred()) SWIG_fail;
55298 }
55299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
55300 return resultobj;
55301 fail:
55302 return NULL;
55303 }
55304
55305
55306 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55307 PyObject *resultobj = 0;
55308 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55309 void *argp1 = 0 ;
55310 int res1 = 0 ;
55311 PyObject *swig_obj[1] ;
55312
55313 if (!args) SWIG_fail;
55314 swig_obj[0] = args;
55315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
55316 if (!SWIG_IsOK(res1)) {
55317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55318 }
55319 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55320 {
55321 PyThreadState* __tstate = wxPyBeginAllowThreads();
55322 delete arg1;
55323
55324 wxPyEndAllowThreads(__tstate);
55325 if (PyErr_Occurred()) SWIG_fail;
55326 }
55327 resultobj = SWIG_Py_Void();
55328 return resultobj;
55329 fail:
55330 return NULL;
55331 }
55332
55333
55334 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55335 PyObject *resultobj = 0;
55336 wxWindow *arg1 = (wxWindow *) 0 ;
55337 wxGBPosition *arg2 = 0 ;
55338 wxGBSpan *arg3 = 0 ;
55339 int arg4 ;
55340 int arg5 ;
55341 PyObject *arg6 = (PyObject *) NULL ;
55342 wxGBSizerItem *result = 0 ;
55343 void *argp1 = 0 ;
55344 int res1 = 0 ;
55345 wxGBPosition temp2 ;
55346 wxGBSpan temp3 ;
55347 int val4 ;
55348 int ecode4 = 0 ;
55349 int val5 ;
55350 int ecode5 = 0 ;
55351 PyObject * obj0 = 0 ;
55352 PyObject * obj1 = 0 ;
55353 PyObject * obj2 = 0 ;
55354 PyObject * obj3 = 0 ;
55355 PyObject * obj4 = 0 ;
55356 PyObject * obj5 = 0 ;
55357 char * kwnames[] = {
55358 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55359 };
55360
55361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
55363 if (!SWIG_IsOK(res1)) {
55364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
55365 }
55366 arg1 = reinterpret_cast< wxWindow * >(argp1);
55367 {
55368 arg2 = &temp2;
55369 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55370 }
55371 {
55372 arg3 = &temp3;
55373 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55374 }
55375 ecode4 = SWIG_AsVal_int(obj3, &val4);
55376 if (!SWIG_IsOK(ecode4)) {
55377 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
55378 }
55379 arg4 = static_cast< int >(val4);
55380 ecode5 = SWIG_AsVal_int(obj4, &val5);
55381 if (!SWIG_IsOK(ecode5)) {
55382 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
55383 }
55384 arg5 = static_cast< int >(val5);
55385 if (obj5) {
55386 arg6 = obj5;
55387 }
55388 {
55389 PyThreadState* __tstate = wxPyBeginAllowThreads();
55390 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
55391 wxPyEndAllowThreads(__tstate);
55392 if (PyErr_Occurred()) SWIG_fail;
55393 }
55394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
55395 return resultobj;
55396 fail:
55397 return NULL;
55398 }
55399
55400
55401 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55402 PyObject *resultobj = 0;
55403 wxSizer *arg1 = (wxSizer *) 0 ;
55404 wxGBPosition *arg2 = 0 ;
55405 wxGBSpan *arg3 = 0 ;
55406 int arg4 ;
55407 int arg5 ;
55408 PyObject *arg6 = (PyObject *) NULL ;
55409 wxGBSizerItem *result = 0 ;
55410 int res1 = 0 ;
55411 wxGBPosition temp2 ;
55412 wxGBSpan temp3 ;
55413 int val4 ;
55414 int ecode4 = 0 ;
55415 int val5 ;
55416 int ecode5 = 0 ;
55417 PyObject * obj0 = 0 ;
55418 PyObject * obj1 = 0 ;
55419 PyObject * obj2 = 0 ;
55420 PyObject * obj3 = 0 ;
55421 PyObject * obj4 = 0 ;
55422 PyObject * obj5 = 0 ;
55423 char * kwnames[] = {
55424 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55425 };
55426
55427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55428 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
55429 if (!SWIG_IsOK(res1)) {
55430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
55431 }
55432 {
55433 arg2 = &temp2;
55434 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55435 }
55436 {
55437 arg3 = &temp3;
55438 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55439 }
55440 ecode4 = SWIG_AsVal_int(obj3, &val4);
55441 if (!SWIG_IsOK(ecode4)) {
55442 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
55443 }
55444 arg4 = static_cast< int >(val4);
55445 ecode5 = SWIG_AsVal_int(obj4, &val5);
55446 if (!SWIG_IsOK(ecode5)) {
55447 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
55448 }
55449 arg5 = static_cast< int >(val5);
55450 if (obj5) {
55451 arg6 = obj5;
55452 }
55453 {
55454 PyThreadState* __tstate = wxPyBeginAllowThreads();
55455 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
55456 wxPyEndAllowThreads(__tstate);
55457 if (PyErr_Occurred()) SWIG_fail;
55458 }
55459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
55460 return resultobj;
55461 fail:
55462 return NULL;
55463 }
55464
55465
55466 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55467 PyObject *resultobj = 0;
55468 int arg1 ;
55469 int arg2 ;
55470 wxGBPosition *arg3 = 0 ;
55471 wxGBSpan *arg4 = 0 ;
55472 int arg5 ;
55473 int arg6 ;
55474 PyObject *arg7 = (PyObject *) NULL ;
55475 wxGBSizerItem *result = 0 ;
55476 int val1 ;
55477 int ecode1 = 0 ;
55478 int val2 ;
55479 int ecode2 = 0 ;
55480 wxGBPosition temp3 ;
55481 wxGBSpan temp4 ;
55482 int val5 ;
55483 int ecode5 = 0 ;
55484 int val6 ;
55485 int ecode6 = 0 ;
55486 PyObject * obj0 = 0 ;
55487 PyObject * obj1 = 0 ;
55488 PyObject * obj2 = 0 ;
55489 PyObject * obj3 = 0 ;
55490 PyObject * obj4 = 0 ;
55491 PyObject * obj5 = 0 ;
55492 PyObject * obj6 = 0 ;
55493 char * kwnames[] = {
55494 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55495 };
55496
55497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
55498 ecode1 = SWIG_AsVal_int(obj0, &val1);
55499 if (!SWIG_IsOK(ecode1)) {
55500 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
55501 }
55502 arg1 = static_cast< int >(val1);
55503 ecode2 = SWIG_AsVal_int(obj1, &val2);
55504 if (!SWIG_IsOK(ecode2)) {
55505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
55506 }
55507 arg2 = static_cast< int >(val2);
55508 {
55509 arg3 = &temp3;
55510 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
55511 }
55512 {
55513 arg4 = &temp4;
55514 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
55515 }
55516 ecode5 = SWIG_AsVal_int(obj4, &val5);
55517 if (!SWIG_IsOK(ecode5)) {
55518 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
55519 }
55520 arg5 = static_cast< int >(val5);
55521 ecode6 = SWIG_AsVal_int(obj5, &val6);
55522 if (!SWIG_IsOK(ecode6)) {
55523 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
55524 }
55525 arg6 = static_cast< int >(val6);
55526 if (obj6) {
55527 arg7 = obj6;
55528 }
55529 {
55530 PyThreadState* __tstate = wxPyBeginAllowThreads();
55531 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
55532 wxPyEndAllowThreads(__tstate);
55533 if (PyErr_Occurred()) SWIG_fail;
55534 }
55535 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
55536 return resultobj;
55537 fail:
55538 return NULL;
55539 }
55540
55541
55542 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55543 PyObject *resultobj = 0;
55544 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55545 wxGBPosition result;
55546 void *argp1 = 0 ;
55547 int res1 = 0 ;
55548 PyObject *swig_obj[1] ;
55549
55550 if (!args) SWIG_fail;
55551 swig_obj[0] = args;
55552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55553 if (!SWIG_IsOK(res1)) {
55554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55555 }
55556 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55557 {
55558 PyThreadState* __tstate = wxPyBeginAllowThreads();
55559 result = ((wxGBSizerItem const *)arg1)->GetPos();
55560 wxPyEndAllowThreads(__tstate);
55561 if (PyErr_Occurred()) SWIG_fail;
55562 }
55563 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55564 return resultobj;
55565 fail:
55566 return NULL;
55567 }
55568
55569
55570 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55571 PyObject *resultobj = 0;
55572 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55573 wxGBSpan result;
55574 void *argp1 = 0 ;
55575 int res1 = 0 ;
55576 PyObject *swig_obj[1] ;
55577
55578 if (!args) SWIG_fail;
55579 swig_obj[0] = args;
55580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55581 if (!SWIG_IsOK(res1)) {
55582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55583 }
55584 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55585 {
55586 PyThreadState* __tstate = wxPyBeginAllowThreads();
55587 result = ((wxGBSizerItem const *)arg1)->GetSpan();
55588 wxPyEndAllowThreads(__tstate);
55589 if (PyErr_Occurred()) SWIG_fail;
55590 }
55591 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55592 return resultobj;
55593 fail:
55594 return NULL;
55595 }
55596
55597
55598 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55599 PyObject *resultobj = 0;
55600 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55601 wxGBPosition *arg2 = 0 ;
55602 bool result;
55603 void *argp1 = 0 ;
55604 int res1 = 0 ;
55605 wxGBPosition temp2 ;
55606 PyObject * obj0 = 0 ;
55607 PyObject * obj1 = 0 ;
55608 char * kwnames[] = {
55609 (char *) "self",(char *) "pos", NULL
55610 };
55611
55612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
55613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55614 if (!SWIG_IsOK(res1)) {
55615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55616 }
55617 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55618 {
55619 arg2 = &temp2;
55620 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55621 }
55622 {
55623 PyThreadState* __tstate = wxPyBeginAllowThreads();
55624 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
55625 wxPyEndAllowThreads(__tstate);
55626 if (PyErr_Occurred()) SWIG_fail;
55627 }
55628 {
55629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55630 }
55631 return resultobj;
55632 fail:
55633 return NULL;
55634 }
55635
55636
55637 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55638 PyObject *resultobj = 0;
55639 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55640 wxGBSpan *arg2 = 0 ;
55641 bool result;
55642 void *argp1 = 0 ;
55643 int res1 = 0 ;
55644 wxGBSpan temp2 ;
55645 PyObject * obj0 = 0 ;
55646 PyObject * obj1 = 0 ;
55647 char * kwnames[] = {
55648 (char *) "self",(char *) "span", NULL
55649 };
55650
55651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
55652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55653 if (!SWIG_IsOK(res1)) {
55654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55655 }
55656 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55657 {
55658 arg2 = &temp2;
55659 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
55660 }
55661 {
55662 PyThreadState* __tstate = wxPyBeginAllowThreads();
55663 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
55664 wxPyEndAllowThreads(__tstate);
55665 if (PyErr_Occurred()) SWIG_fail;
55666 }
55667 {
55668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55669 }
55670 return resultobj;
55671 fail:
55672 return NULL;
55673 }
55674
55675
55676 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55677 PyObject *resultobj = 0;
55678 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55679 wxGBSizerItem *arg2 = 0 ;
55680 bool result;
55681 void *argp1 = 0 ;
55682 int res1 = 0 ;
55683 void *argp2 = 0 ;
55684 int res2 = 0 ;
55685 PyObject * obj0 = 0 ;
55686 PyObject * obj1 = 0 ;
55687 char * kwnames[] = {
55688 (char *) "self",(char *) "other", NULL
55689 };
55690
55691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
55692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55693 if (!SWIG_IsOK(res1)) {
55694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55695 }
55696 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55697 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
55698 if (!SWIG_IsOK(res2)) {
55699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55700 }
55701 if (!argp2) {
55702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55703 }
55704 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
55705 {
55706 PyThreadState* __tstate = wxPyBeginAllowThreads();
55707 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
55708 wxPyEndAllowThreads(__tstate);
55709 if (PyErr_Occurred()) SWIG_fail;
55710 }
55711 {
55712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55713 }
55714 return resultobj;
55715 fail:
55716 return NULL;
55717 }
55718
55719
55720 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55721 PyObject *resultobj = 0;
55722 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55723 wxGBPosition *arg2 = 0 ;
55724 wxGBSpan *arg3 = 0 ;
55725 bool result;
55726 void *argp1 = 0 ;
55727 int res1 = 0 ;
55728 wxGBPosition temp2 ;
55729 wxGBSpan temp3 ;
55730 PyObject * obj0 = 0 ;
55731 PyObject * obj1 = 0 ;
55732 PyObject * obj2 = 0 ;
55733 char * kwnames[] = {
55734 (char *) "self",(char *) "pos",(char *) "span", NULL
55735 };
55736
55737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55739 if (!SWIG_IsOK(res1)) {
55740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55741 }
55742 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55743 {
55744 arg2 = &temp2;
55745 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55746 }
55747 {
55748 arg3 = &temp3;
55749 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55750 }
55751 {
55752 PyThreadState* __tstate = wxPyBeginAllowThreads();
55753 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
55754 wxPyEndAllowThreads(__tstate);
55755 if (PyErr_Occurred()) SWIG_fail;
55756 }
55757 {
55758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55759 }
55760 return resultobj;
55761 fail:
55762 return NULL;
55763 }
55764
55765
55766 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55767 PyObject *resultobj = 0;
55768 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55769 wxGBPosition result;
55770 void *argp1 = 0 ;
55771 int res1 = 0 ;
55772 PyObject *swig_obj[1] ;
55773
55774 if (!args) SWIG_fail;
55775 swig_obj[0] = args;
55776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55777 if (!SWIG_IsOK(res1)) {
55778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55779 }
55780 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55781 {
55782 PyThreadState* __tstate = wxPyBeginAllowThreads();
55783 result = wxGBSizerItem_GetEndPos(arg1);
55784 wxPyEndAllowThreads(__tstate);
55785 if (PyErr_Occurred()) SWIG_fail;
55786 }
55787 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55788 return resultobj;
55789 fail:
55790 return NULL;
55791 }
55792
55793
55794 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55795 PyObject *resultobj = 0;
55796 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55797 wxGridBagSizer *result = 0 ;
55798 void *argp1 = 0 ;
55799 int res1 = 0 ;
55800 PyObject *swig_obj[1] ;
55801
55802 if (!args) SWIG_fail;
55803 swig_obj[0] = args;
55804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55805 if (!SWIG_IsOK(res1)) {
55806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55807 }
55808 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55809 {
55810 PyThreadState* __tstate = wxPyBeginAllowThreads();
55811 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
55812 wxPyEndAllowThreads(__tstate);
55813 if (PyErr_Occurred()) SWIG_fail;
55814 }
55815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55816 return resultobj;
55817 fail:
55818 return NULL;
55819 }
55820
55821
55822 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55823 PyObject *resultobj = 0;
55824 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55825 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
55826 void *argp1 = 0 ;
55827 int res1 = 0 ;
55828 void *argp2 = 0 ;
55829 int res2 = 0 ;
55830 PyObject * obj0 = 0 ;
55831 PyObject * obj1 = 0 ;
55832 char * kwnames[] = {
55833 (char *) "self",(char *) "sizer", NULL
55834 };
55835
55836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55838 if (!SWIG_IsOK(res1)) {
55839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55840 }
55841 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55842 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55843 if (!SWIG_IsOK(res2)) {
55844 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
55845 }
55846 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
55847 {
55848 PyThreadState* __tstate = wxPyBeginAllowThreads();
55849 (arg1)->SetGBSizer(arg2);
55850 wxPyEndAllowThreads(__tstate);
55851 if (PyErr_Occurred()) SWIG_fail;
55852 }
55853 resultobj = SWIG_Py_Void();
55854 return resultobj;
55855 fail:
55856 return NULL;
55857 }
55858
55859
55860 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55861 PyObject *obj;
55862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55863 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
55864 return SWIG_Py_Void();
55865 }
55866
55867 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55868 return SWIG_Python_InitShadowInstance(args);
55869 }
55870
55871 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55872 PyObject *resultobj = 0;
55873 int arg1 = (int) 0 ;
55874 int arg2 = (int) 0 ;
55875 wxGridBagSizer *result = 0 ;
55876 int val1 ;
55877 int ecode1 = 0 ;
55878 int val2 ;
55879 int ecode2 = 0 ;
55880 PyObject * obj0 = 0 ;
55881 PyObject * obj1 = 0 ;
55882 char * kwnames[] = {
55883 (char *) "vgap",(char *) "hgap", NULL
55884 };
55885
55886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55887 if (obj0) {
55888 ecode1 = SWIG_AsVal_int(obj0, &val1);
55889 if (!SWIG_IsOK(ecode1)) {
55890 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
55891 }
55892 arg1 = static_cast< int >(val1);
55893 }
55894 if (obj1) {
55895 ecode2 = SWIG_AsVal_int(obj1, &val2);
55896 if (!SWIG_IsOK(ecode2)) {
55897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
55898 }
55899 arg2 = static_cast< int >(val2);
55900 }
55901 {
55902 PyThreadState* __tstate = wxPyBeginAllowThreads();
55903 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
55904 wxPyEndAllowThreads(__tstate);
55905 if (PyErr_Occurred()) SWIG_fail;
55906 }
55907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
55908 return resultobj;
55909 fail:
55910 return NULL;
55911 }
55912
55913
55914 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55915 PyObject *resultobj = 0;
55916 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55917 PyObject *arg2 = (PyObject *) 0 ;
55918 wxGBPosition *arg3 = 0 ;
55919 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
55920 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
55921 int arg5 = (int) 0 ;
55922 int arg6 = (int) 0 ;
55923 PyObject *arg7 = (PyObject *) NULL ;
55924 wxGBSizerItem *result = 0 ;
55925 void *argp1 = 0 ;
55926 int res1 = 0 ;
55927 wxGBPosition temp3 ;
55928 wxGBSpan temp4 ;
55929 int val5 ;
55930 int ecode5 = 0 ;
55931 int val6 ;
55932 int ecode6 = 0 ;
55933 PyObject * obj0 = 0 ;
55934 PyObject * obj1 = 0 ;
55935 PyObject * obj2 = 0 ;
55936 PyObject * obj3 = 0 ;
55937 PyObject * obj4 = 0 ;
55938 PyObject * obj5 = 0 ;
55939 PyObject * obj6 = 0 ;
55940 char * kwnames[] = {
55941 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55942 };
55943
55944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
55945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55946 if (!SWIG_IsOK(res1)) {
55947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55948 }
55949 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55950 arg2 = obj1;
55951 {
55952 arg3 = &temp3;
55953 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
55954 }
55955 if (obj3) {
55956 {
55957 arg4 = &temp4;
55958 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
55959 }
55960 }
55961 if (obj4) {
55962 ecode5 = SWIG_AsVal_int(obj4, &val5);
55963 if (!SWIG_IsOK(ecode5)) {
55964 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
55965 }
55966 arg5 = static_cast< int >(val5);
55967 }
55968 if (obj5) {
55969 ecode6 = SWIG_AsVal_int(obj5, &val6);
55970 if (!SWIG_IsOK(ecode6)) {
55971 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
55972 }
55973 arg6 = static_cast< int >(val6);
55974 }
55975 if (obj6) {
55976 arg7 = obj6;
55977 }
55978 {
55979 PyThreadState* __tstate = wxPyBeginAllowThreads();
55980 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
55981 wxPyEndAllowThreads(__tstate);
55982 if (PyErr_Occurred()) SWIG_fail;
55983 }
55984 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55985 return resultobj;
55986 fail:
55987 return NULL;
55988 }
55989
55990
55991 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55992 PyObject *resultobj = 0;
55993 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55994 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
55995 wxGBSizerItem *result = 0 ;
55996 void *argp1 = 0 ;
55997 int res1 = 0 ;
55998 int res2 = 0 ;
55999 PyObject * obj0 = 0 ;
56000 PyObject * obj1 = 0 ;
56001 char * kwnames[] = {
56002 (char *) "self",(char *) "item", NULL
56003 };
56004
56005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
56006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56007 if (!SWIG_IsOK(res1)) {
56008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56009 }
56010 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56011 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
56012 if (!SWIG_IsOK(res2)) {
56013 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
56014 }
56015 {
56016 PyThreadState* __tstate = wxPyBeginAllowThreads();
56017 result = (wxGBSizerItem *)(arg1)->Add(arg2);
56018 wxPyEndAllowThreads(__tstate);
56019 if (PyErr_Occurred()) SWIG_fail;
56020 }
56021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56022 return resultobj;
56023 fail:
56024 return NULL;
56025 }
56026
56027
56028 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56029 PyObject *resultobj = 0;
56030 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56031 int arg2 ;
56032 int arg3 ;
56033 wxSize result;
56034 void *argp1 = 0 ;
56035 int res1 = 0 ;
56036 int val2 ;
56037 int ecode2 = 0 ;
56038 int val3 ;
56039 int ecode3 = 0 ;
56040 PyObject * obj0 = 0 ;
56041 PyObject * obj1 = 0 ;
56042 PyObject * obj2 = 0 ;
56043 char * kwnames[] = {
56044 (char *) "self",(char *) "row",(char *) "col", NULL
56045 };
56046
56047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56049 if (!SWIG_IsOK(res1)) {
56050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
56051 }
56052 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56053 ecode2 = SWIG_AsVal_int(obj1, &val2);
56054 if (!SWIG_IsOK(ecode2)) {
56055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
56056 }
56057 arg2 = static_cast< int >(val2);
56058 ecode3 = SWIG_AsVal_int(obj2, &val3);
56059 if (!SWIG_IsOK(ecode3)) {
56060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
56061 }
56062 arg3 = static_cast< int >(val3);
56063 {
56064 PyThreadState* __tstate = wxPyBeginAllowThreads();
56065 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
56066 wxPyEndAllowThreads(__tstate);
56067 if (PyErr_Occurred()) SWIG_fail;
56068 }
56069 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
56070 return resultobj;
56071 fail:
56072 return NULL;
56073 }
56074
56075
56076 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56077 PyObject *resultobj = 0;
56078 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56079 wxSize result;
56080 void *argp1 = 0 ;
56081 int res1 = 0 ;
56082 PyObject *swig_obj[1] ;
56083
56084 if (!args) SWIG_fail;
56085 swig_obj[0] = args;
56086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56087 if (!SWIG_IsOK(res1)) {
56088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
56089 }
56090 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56091 {
56092 PyThreadState* __tstate = wxPyBeginAllowThreads();
56093 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
56094 wxPyEndAllowThreads(__tstate);
56095 if (PyErr_Occurred()) SWIG_fail;
56096 }
56097 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
56098 return resultobj;
56099 fail:
56100 return NULL;
56101 }
56102
56103
56104 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56105 PyObject *resultobj = 0;
56106 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56107 wxSize *arg2 = 0 ;
56108 void *argp1 = 0 ;
56109 int res1 = 0 ;
56110 wxSize temp2 ;
56111 PyObject * obj0 = 0 ;
56112 PyObject * obj1 = 0 ;
56113 char * kwnames[] = {
56114 (char *) "self",(char *) "sz", NULL
56115 };
56116
56117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
56118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56119 if (!SWIG_IsOK(res1)) {
56120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56121 }
56122 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56123 {
56124 arg2 = &temp2;
56125 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
56126 }
56127 {
56128 PyThreadState* __tstate = wxPyBeginAllowThreads();
56129 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
56130 wxPyEndAllowThreads(__tstate);
56131 if (PyErr_Occurred()) SWIG_fail;
56132 }
56133 resultobj = SWIG_Py_Void();
56134 return resultobj;
56135 fail:
56136 return NULL;
56137 }
56138
56139
56140 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56141 PyObject *resultobj = 0;
56142 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56143 wxWindow *arg2 = (wxWindow *) 0 ;
56144 wxGBPosition result;
56145 void *argp1 = 0 ;
56146 int res1 = 0 ;
56147 void *argp2 = 0 ;
56148 int res2 = 0 ;
56149
56150 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56152 if (!SWIG_IsOK(res1)) {
56153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56154 }
56155 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56156 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56157 if (!SWIG_IsOK(res2)) {
56158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
56159 }
56160 arg2 = reinterpret_cast< wxWindow * >(argp2);
56161 {
56162 PyThreadState* __tstate = wxPyBeginAllowThreads();
56163 result = (arg1)->GetItemPosition(arg2);
56164 wxPyEndAllowThreads(__tstate);
56165 if (PyErr_Occurred()) SWIG_fail;
56166 }
56167 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
56168 return resultobj;
56169 fail:
56170 return NULL;
56171 }
56172
56173
56174 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56175 PyObject *resultobj = 0;
56176 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56177 wxSizer *arg2 = (wxSizer *) 0 ;
56178 wxGBPosition result;
56179 void *argp1 = 0 ;
56180 int res1 = 0 ;
56181 void *argp2 = 0 ;
56182 int res2 = 0 ;
56183
56184 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56186 if (!SWIG_IsOK(res1)) {
56187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56188 }
56189 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56190 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56191 if (!SWIG_IsOK(res2)) {
56192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
56193 }
56194 arg2 = reinterpret_cast< wxSizer * >(argp2);
56195 {
56196 PyThreadState* __tstate = wxPyBeginAllowThreads();
56197 result = (arg1)->GetItemPosition(arg2);
56198 wxPyEndAllowThreads(__tstate);
56199 if (PyErr_Occurred()) SWIG_fail;
56200 }
56201 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
56202 return resultobj;
56203 fail:
56204 return NULL;
56205 }
56206
56207
56208 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56209 PyObject *resultobj = 0;
56210 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56211 size_t arg2 ;
56212 wxGBPosition result;
56213 void *argp1 = 0 ;
56214 int res1 = 0 ;
56215 size_t val2 ;
56216 int ecode2 = 0 ;
56217
56218 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56220 if (!SWIG_IsOK(res1)) {
56221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56222 }
56223 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56224 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56225 if (!SWIG_IsOK(ecode2)) {
56226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
56227 }
56228 arg2 = static_cast< size_t >(val2);
56229 {
56230 PyThreadState* __tstate = wxPyBeginAllowThreads();
56231 result = (arg1)->GetItemPosition(arg2);
56232 wxPyEndAllowThreads(__tstate);
56233 if (PyErr_Occurred()) SWIG_fail;
56234 }
56235 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
56236 return resultobj;
56237 fail:
56238 return NULL;
56239 }
56240
56241
56242 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
56243 int argc;
56244 PyObject *argv[3];
56245
56246 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
56247 --argc;
56248 if (argc == 2) {
56249 int _v = 0;
56250 {
56251 void *vptr = 0;
56252 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56253 _v = SWIG_CheckState(res);
56254 }
56255 if (!_v) goto check_1;
56256 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
56257 }
56258 check_1:
56259
56260 if (argc == 2) {
56261 int _v = 0;
56262 {
56263 void *vptr = 0;
56264 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56265 _v = SWIG_CheckState(res);
56266 }
56267 if (!_v) goto check_2;
56268 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
56269 }
56270 check_2:
56271
56272 if (argc == 2) {
56273 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
56274 }
56275
56276 fail:
56277 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
56278 return NULL;
56279 }
56280
56281
56282 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56283 PyObject *resultobj = 0;
56284 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56285 wxWindow *arg2 = (wxWindow *) 0 ;
56286 wxGBPosition *arg3 = 0 ;
56287 bool result;
56288 void *argp1 = 0 ;
56289 int res1 = 0 ;
56290 void *argp2 = 0 ;
56291 int res2 = 0 ;
56292 wxGBPosition temp3 ;
56293
56294 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56296 if (!SWIG_IsOK(res1)) {
56297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56298 }
56299 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56300 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56301 if (!SWIG_IsOK(res2)) {
56302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
56303 }
56304 arg2 = reinterpret_cast< wxWindow * >(argp2);
56305 {
56306 arg3 = &temp3;
56307 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
56308 }
56309 {
56310 PyThreadState* __tstate = wxPyBeginAllowThreads();
56311 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
56312 wxPyEndAllowThreads(__tstate);
56313 if (PyErr_Occurred()) SWIG_fail;
56314 }
56315 {
56316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56317 }
56318 return resultobj;
56319 fail:
56320 return NULL;
56321 }
56322
56323
56324 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56325 PyObject *resultobj = 0;
56326 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56327 wxSizer *arg2 = (wxSizer *) 0 ;
56328 wxGBPosition *arg3 = 0 ;
56329 bool result;
56330 void *argp1 = 0 ;
56331 int res1 = 0 ;
56332 void *argp2 = 0 ;
56333 int res2 = 0 ;
56334 wxGBPosition temp3 ;
56335
56336 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56338 if (!SWIG_IsOK(res1)) {
56339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56340 }
56341 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56342 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56343 if (!SWIG_IsOK(res2)) {
56344 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
56345 }
56346 arg2 = reinterpret_cast< wxSizer * >(argp2);
56347 {
56348 arg3 = &temp3;
56349 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
56350 }
56351 {
56352 PyThreadState* __tstate = wxPyBeginAllowThreads();
56353 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
56354 wxPyEndAllowThreads(__tstate);
56355 if (PyErr_Occurred()) SWIG_fail;
56356 }
56357 {
56358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56359 }
56360 return resultobj;
56361 fail:
56362 return NULL;
56363 }
56364
56365
56366 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56367 PyObject *resultobj = 0;
56368 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56369 size_t arg2 ;
56370 wxGBPosition *arg3 = 0 ;
56371 bool result;
56372 void *argp1 = 0 ;
56373 int res1 = 0 ;
56374 size_t val2 ;
56375 int ecode2 = 0 ;
56376 wxGBPosition temp3 ;
56377
56378 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56380 if (!SWIG_IsOK(res1)) {
56381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56382 }
56383 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56384 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56385 if (!SWIG_IsOK(ecode2)) {
56386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
56387 }
56388 arg2 = static_cast< size_t >(val2);
56389 {
56390 arg3 = &temp3;
56391 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
56392 }
56393 {
56394 PyThreadState* __tstate = wxPyBeginAllowThreads();
56395 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
56396 wxPyEndAllowThreads(__tstate);
56397 if (PyErr_Occurred()) SWIG_fail;
56398 }
56399 {
56400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56401 }
56402 return resultobj;
56403 fail:
56404 return NULL;
56405 }
56406
56407
56408 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
56409 int argc;
56410 PyObject *argv[4];
56411
56412 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
56413 --argc;
56414 if (argc == 3) {
56415 int _v = 0;
56416 {
56417 void *vptr = 0;
56418 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56419 _v = SWIG_CheckState(res);
56420 }
56421 if (!_v) goto check_1;
56422 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
56423 }
56424 check_1:
56425
56426 if (argc == 3) {
56427 int _v = 0;
56428 {
56429 void *vptr = 0;
56430 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56431 _v = SWIG_CheckState(res);
56432 }
56433 if (!_v) goto check_2;
56434 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
56435 }
56436 check_2:
56437
56438 if (argc == 3) {
56439 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
56440 }
56441
56442 fail:
56443 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
56444 return NULL;
56445 }
56446
56447
56448 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56449 PyObject *resultobj = 0;
56450 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56451 wxWindow *arg2 = (wxWindow *) 0 ;
56452 wxGBSpan result;
56453 void *argp1 = 0 ;
56454 int res1 = 0 ;
56455 void *argp2 = 0 ;
56456 int res2 = 0 ;
56457
56458 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56460 if (!SWIG_IsOK(res1)) {
56461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56462 }
56463 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56464 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56465 if (!SWIG_IsOK(res2)) {
56466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
56467 }
56468 arg2 = reinterpret_cast< wxWindow * >(argp2);
56469 {
56470 PyThreadState* __tstate = wxPyBeginAllowThreads();
56471 result = (arg1)->GetItemSpan(arg2);
56472 wxPyEndAllowThreads(__tstate);
56473 if (PyErr_Occurred()) SWIG_fail;
56474 }
56475 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
56476 return resultobj;
56477 fail:
56478 return NULL;
56479 }
56480
56481
56482 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56483 PyObject *resultobj = 0;
56484 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56485 wxSizer *arg2 = (wxSizer *) 0 ;
56486 wxGBSpan result;
56487 void *argp1 = 0 ;
56488 int res1 = 0 ;
56489 void *argp2 = 0 ;
56490 int res2 = 0 ;
56491
56492 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56494 if (!SWIG_IsOK(res1)) {
56495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56496 }
56497 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56498 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56499 if (!SWIG_IsOK(res2)) {
56500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
56501 }
56502 arg2 = reinterpret_cast< wxSizer * >(argp2);
56503 {
56504 PyThreadState* __tstate = wxPyBeginAllowThreads();
56505 result = (arg1)->GetItemSpan(arg2);
56506 wxPyEndAllowThreads(__tstate);
56507 if (PyErr_Occurred()) SWIG_fail;
56508 }
56509 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
56510 return resultobj;
56511 fail:
56512 return NULL;
56513 }
56514
56515
56516 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56517 PyObject *resultobj = 0;
56518 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56519 size_t arg2 ;
56520 wxGBSpan result;
56521 void *argp1 = 0 ;
56522 int res1 = 0 ;
56523 size_t val2 ;
56524 int ecode2 = 0 ;
56525
56526 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56528 if (!SWIG_IsOK(res1)) {
56529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56530 }
56531 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56532 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56533 if (!SWIG_IsOK(ecode2)) {
56534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
56535 }
56536 arg2 = static_cast< size_t >(val2);
56537 {
56538 PyThreadState* __tstate = wxPyBeginAllowThreads();
56539 result = (arg1)->GetItemSpan(arg2);
56540 wxPyEndAllowThreads(__tstate);
56541 if (PyErr_Occurred()) SWIG_fail;
56542 }
56543 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
56544 return resultobj;
56545 fail:
56546 return NULL;
56547 }
56548
56549
56550 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
56551 int argc;
56552 PyObject *argv[3];
56553
56554 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
56555 --argc;
56556 if (argc == 2) {
56557 int _v = 0;
56558 {
56559 void *vptr = 0;
56560 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56561 _v = SWIG_CheckState(res);
56562 }
56563 if (!_v) goto check_1;
56564 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
56565 }
56566 check_1:
56567
56568 if (argc == 2) {
56569 int _v = 0;
56570 {
56571 void *vptr = 0;
56572 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56573 _v = SWIG_CheckState(res);
56574 }
56575 if (!_v) goto check_2;
56576 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
56577 }
56578 check_2:
56579
56580 if (argc == 2) {
56581 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
56582 }
56583
56584 fail:
56585 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
56586 return NULL;
56587 }
56588
56589
56590 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56591 PyObject *resultobj = 0;
56592 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56593 wxWindow *arg2 = (wxWindow *) 0 ;
56594 wxGBSpan *arg3 = 0 ;
56595 bool result;
56596 void *argp1 = 0 ;
56597 int res1 = 0 ;
56598 void *argp2 = 0 ;
56599 int res2 = 0 ;
56600 wxGBSpan temp3 ;
56601
56602 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56604 if (!SWIG_IsOK(res1)) {
56605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56606 }
56607 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56608 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56609 if (!SWIG_IsOK(res2)) {
56610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
56611 }
56612 arg2 = reinterpret_cast< wxWindow * >(argp2);
56613 {
56614 arg3 = &temp3;
56615 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56616 }
56617 {
56618 PyThreadState* __tstate = wxPyBeginAllowThreads();
56619 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56620 wxPyEndAllowThreads(__tstate);
56621 if (PyErr_Occurred()) SWIG_fail;
56622 }
56623 {
56624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56625 }
56626 return resultobj;
56627 fail:
56628 return NULL;
56629 }
56630
56631
56632 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56633 PyObject *resultobj = 0;
56634 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56635 wxSizer *arg2 = (wxSizer *) 0 ;
56636 wxGBSpan *arg3 = 0 ;
56637 bool result;
56638 void *argp1 = 0 ;
56639 int res1 = 0 ;
56640 void *argp2 = 0 ;
56641 int res2 = 0 ;
56642 wxGBSpan temp3 ;
56643
56644 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56646 if (!SWIG_IsOK(res1)) {
56647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56648 }
56649 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56650 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56651 if (!SWIG_IsOK(res2)) {
56652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
56653 }
56654 arg2 = reinterpret_cast< wxSizer * >(argp2);
56655 {
56656 arg3 = &temp3;
56657 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56658 }
56659 {
56660 PyThreadState* __tstate = wxPyBeginAllowThreads();
56661 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56662 wxPyEndAllowThreads(__tstate);
56663 if (PyErr_Occurred()) SWIG_fail;
56664 }
56665 {
56666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56667 }
56668 return resultobj;
56669 fail:
56670 return NULL;
56671 }
56672
56673
56674 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56675 PyObject *resultobj = 0;
56676 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56677 size_t arg2 ;
56678 wxGBSpan *arg3 = 0 ;
56679 bool result;
56680 void *argp1 = 0 ;
56681 int res1 = 0 ;
56682 size_t val2 ;
56683 int ecode2 = 0 ;
56684 wxGBSpan temp3 ;
56685
56686 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56688 if (!SWIG_IsOK(res1)) {
56689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56690 }
56691 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56692 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56693 if (!SWIG_IsOK(ecode2)) {
56694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
56695 }
56696 arg2 = static_cast< size_t >(val2);
56697 {
56698 arg3 = &temp3;
56699 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56700 }
56701 {
56702 PyThreadState* __tstate = wxPyBeginAllowThreads();
56703 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56704 wxPyEndAllowThreads(__tstate);
56705 if (PyErr_Occurred()) SWIG_fail;
56706 }
56707 {
56708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56709 }
56710 return resultobj;
56711 fail:
56712 return NULL;
56713 }
56714
56715
56716 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
56717 int argc;
56718 PyObject *argv[4];
56719
56720 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
56721 --argc;
56722 if (argc == 3) {
56723 int _v = 0;
56724 {
56725 void *vptr = 0;
56726 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56727 _v = SWIG_CheckState(res);
56728 }
56729 if (!_v) goto check_1;
56730 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
56731 }
56732 check_1:
56733
56734 if (argc == 3) {
56735 int _v = 0;
56736 {
56737 void *vptr = 0;
56738 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56739 _v = SWIG_CheckState(res);
56740 }
56741 if (!_v) goto check_2;
56742 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
56743 }
56744 check_2:
56745
56746 if (argc == 3) {
56747 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
56748 }
56749
56750 fail:
56751 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
56752 return NULL;
56753 }
56754
56755
56756 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56757 PyObject *resultobj = 0;
56758 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56759 wxWindow *arg2 = (wxWindow *) 0 ;
56760 wxGBSizerItem *result = 0 ;
56761 void *argp1 = 0 ;
56762 int res1 = 0 ;
56763 void *argp2 = 0 ;
56764 int res2 = 0 ;
56765
56766 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56768 if (!SWIG_IsOK(res1)) {
56769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56770 }
56771 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56772 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56773 if (!SWIG_IsOK(res2)) {
56774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
56775 }
56776 arg2 = reinterpret_cast< wxWindow * >(argp2);
56777 {
56778 PyThreadState* __tstate = wxPyBeginAllowThreads();
56779 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56780 wxPyEndAllowThreads(__tstate);
56781 if (PyErr_Occurred()) SWIG_fail;
56782 }
56783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56784 return resultobj;
56785 fail:
56786 return NULL;
56787 }
56788
56789
56790 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56791 PyObject *resultobj = 0;
56792 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56793 wxSizer *arg2 = (wxSizer *) 0 ;
56794 wxGBSizerItem *result = 0 ;
56795 void *argp1 = 0 ;
56796 int res1 = 0 ;
56797 void *argp2 = 0 ;
56798 int res2 = 0 ;
56799
56800 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56802 if (!SWIG_IsOK(res1)) {
56803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56804 }
56805 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56806 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56807 if (!SWIG_IsOK(res2)) {
56808 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
56809 }
56810 arg2 = reinterpret_cast< wxSizer * >(argp2);
56811 {
56812 PyThreadState* __tstate = wxPyBeginAllowThreads();
56813 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56814 wxPyEndAllowThreads(__tstate);
56815 if (PyErr_Occurred()) SWIG_fail;
56816 }
56817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56818 return resultobj;
56819 fail:
56820 return NULL;
56821 }
56822
56823
56824 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
56825 int argc;
56826 PyObject *argv[3];
56827
56828 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
56829 --argc;
56830 if (argc == 2) {
56831 int _v = 0;
56832 {
56833 void *vptr = 0;
56834 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56835 _v = SWIG_CheckState(res);
56836 }
56837 if (!_v) goto check_1;
56838 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
56839 }
56840 check_1:
56841
56842 if (argc == 2) {
56843 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
56844 }
56845
56846 fail:
56847 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
56848 return NULL;
56849 }
56850
56851
56852 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56853 PyObject *resultobj = 0;
56854 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56855 wxGBPosition *arg2 = 0 ;
56856 wxGBSizerItem *result = 0 ;
56857 void *argp1 = 0 ;
56858 int res1 = 0 ;
56859 wxGBPosition temp2 ;
56860 PyObject * obj0 = 0 ;
56861 PyObject * obj1 = 0 ;
56862 char * kwnames[] = {
56863 (char *) "self",(char *) "pos", NULL
56864 };
56865
56866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
56867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56868 if (!SWIG_IsOK(res1)) {
56869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56870 }
56871 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56872 {
56873 arg2 = &temp2;
56874 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56875 }
56876 {
56877 PyThreadState* __tstate = wxPyBeginAllowThreads();
56878 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
56879 wxPyEndAllowThreads(__tstate);
56880 if (PyErr_Occurred()) SWIG_fail;
56881 }
56882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56883 return resultobj;
56884 fail:
56885 return NULL;
56886 }
56887
56888
56889 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56890 PyObject *resultobj = 0;
56891 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56892 wxPoint *arg2 = 0 ;
56893 wxGBSizerItem *result = 0 ;
56894 void *argp1 = 0 ;
56895 int res1 = 0 ;
56896 wxPoint temp2 ;
56897 PyObject * obj0 = 0 ;
56898 PyObject * obj1 = 0 ;
56899 char * kwnames[] = {
56900 (char *) "self",(char *) "pt", NULL
56901 };
56902
56903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
56904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56905 if (!SWIG_IsOK(res1)) {
56906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56907 }
56908 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56909 {
56910 arg2 = &temp2;
56911 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
56912 }
56913 {
56914 PyThreadState* __tstate = wxPyBeginAllowThreads();
56915 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
56916 wxPyEndAllowThreads(__tstate);
56917 if (PyErr_Occurred()) SWIG_fail;
56918 }
56919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56920 return resultobj;
56921 fail:
56922 return NULL;
56923 }
56924
56925
56926 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56927 PyObject *resultobj = 0;
56928 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56929 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
56930 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
56931 bool result;
56932 void *argp1 = 0 ;
56933 int res1 = 0 ;
56934 void *argp2 = 0 ;
56935 int res2 = 0 ;
56936 void *argp3 = 0 ;
56937 int res3 = 0 ;
56938 PyObject * obj0 = 0 ;
56939 PyObject * obj1 = 0 ;
56940 PyObject * obj2 = 0 ;
56941 char * kwnames[] = {
56942 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
56943 };
56944
56945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56947 if (!SWIG_IsOK(res1)) {
56948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56949 }
56950 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56951 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56952 if (!SWIG_IsOK(res2)) {
56953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
56954 }
56955 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
56956 if (obj2) {
56957 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56958 if (!SWIG_IsOK(res3)) {
56959 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
56960 }
56961 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
56962 }
56963 {
56964 PyThreadState* __tstate = wxPyBeginAllowThreads();
56965 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
56966 wxPyEndAllowThreads(__tstate);
56967 if (PyErr_Occurred()) SWIG_fail;
56968 }
56969 {
56970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56971 }
56972 return resultobj;
56973 fail:
56974 return NULL;
56975 }
56976
56977
56978 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56979 PyObject *resultobj = 0;
56980 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56981 wxGBPosition *arg2 = 0 ;
56982 wxGBSpan *arg3 = 0 ;
56983 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
56984 bool result;
56985 void *argp1 = 0 ;
56986 int res1 = 0 ;
56987 wxGBPosition temp2 ;
56988 wxGBSpan temp3 ;
56989 void *argp4 = 0 ;
56990 int res4 = 0 ;
56991 PyObject * obj0 = 0 ;
56992 PyObject * obj1 = 0 ;
56993 PyObject * obj2 = 0 ;
56994 PyObject * obj3 = 0 ;
56995 char * kwnames[] = {
56996 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
56997 };
56998
56999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
57001 if (!SWIG_IsOK(res1)) {
57002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
57003 }
57004 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
57005 {
57006 arg2 = &temp2;
57007 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
57008 }
57009 {
57010 arg3 = &temp3;
57011 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
57012 }
57013 if (obj3) {
57014 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
57015 if (!SWIG_IsOK(res4)) {
57016 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
57017 }
57018 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
57019 }
57020 {
57021 PyThreadState* __tstate = wxPyBeginAllowThreads();
57022 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
57023 wxPyEndAllowThreads(__tstate);
57024 if (PyErr_Occurred()) SWIG_fail;
57025 }
57026 {
57027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57028 }
57029 return resultobj;
57030 fail:
57031 return NULL;
57032 }
57033
57034
57035 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57036 PyObject *obj;
57037 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
57038 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
57039 return SWIG_Py_Void();
57040 }
57041
57042 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57043 return SWIG_Python_InitShadowInstance(args);
57044 }
57045
57046 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57047 PyObject *resultobj = 0;
57048 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57049 wxRelationship arg2 ;
57050 wxWindow *arg3 = (wxWindow *) 0 ;
57051 wxEdge arg4 ;
57052 int arg5 = (int) 0 ;
57053 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
57054 void *argp1 = 0 ;
57055 int res1 = 0 ;
57056 int val2 ;
57057 int ecode2 = 0 ;
57058 void *argp3 = 0 ;
57059 int res3 = 0 ;
57060 int val4 ;
57061 int ecode4 = 0 ;
57062 int val5 ;
57063 int ecode5 = 0 ;
57064 int val6 ;
57065 int ecode6 = 0 ;
57066 PyObject * obj0 = 0 ;
57067 PyObject * obj1 = 0 ;
57068 PyObject * obj2 = 0 ;
57069 PyObject * obj3 = 0 ;
57070 PyObject * obj4 = 0 ;
57071 PyObject * obj5 = 0 ;
57072 char * kwnames[] = {
57073 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
57074 };
57075
57076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
57077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57078 if (!SWIG_IsOK(res1)) {
57079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57080 }
57081 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57082 ecode2 = SWIG_AsVal_int(obj1, &val2);
57083 if (!SWIG_IsOK(ecode2)) {
57084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
57085 }
57086 arg2 = static_cast< wxRelationship >(val2);
57087 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57088 if (!SWIG_IsOK(res3)) {
57089 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
57090 }
57091 arg3 = reinterpret_cast< wxWindow * >(argp3);
57092 ecode4 = SWIG_AsVal_int(obj3, &val4);
57093 if (!SWIG_IsOK(ecode4)) {
57094 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
57095 }
57096 arg4 = static_cast< wxEdge >(val4);
57097 if (obj4) {
57098 ecode5 = SWIG_AsVal_int(obj4, &val5);
57099 if (!SWIG_IsOK(ecode5)) {
57100 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
57101 }
57102 arg5 = static_cast< int >(val5);
57103 }
57104 if (obj5) {
57105 ecode6 = SWIG_AsVal_int(obj5, &val6);
57106 if (!SWIG_IsOK(ecode6)) {
57107 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
57108 }
57109 arg6 = static_cast< int >(val6);
57110 }
57111 {
57112 PyThreadState* __tstate = wxPyBeginAllowThreads();
57113 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
57114 wxPyEndAllowThreads(__tstate);
57115 if (PyErr_Occurred()) SWIG_fail;
57116 }
57117 resultobj = SWIG_Py_Void();
57118 return resultobj;
57119 fail:
57120 return NULL;
57121 }
57122
57123
57124 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57125 PyObject *resultobj = 0;
57126 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57127 wxWindow *arg2 = (wxWindow *) 0 ;
57128 int arg3 = (int) 0 ;
57129 void *argp1 = 0 ;
57130 int res1 = 0 ;
57131 void *argp2 = 0 ;
57132 int res2 = 0 ;
57133 int val3 ;
57134 int ecode3 = 0 ;
57135 PyObject * obj0 = 0 ;
57136 PyObject * obj1 = 0 ;
57137 PyObject * obj2 = 0 ;
57138 char * kwnames[] = {
57139 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57140 };
57141
57142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57144 if (!SWIG_IsOK(res1)) {
57145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57146 }
57147 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57148 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57149 if (!SWIG_IsOK(res2)) {
57150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
57151 }
57152 arg2 = reinterpret_cast< wxWindow * >(argp2);
57153 if (obj2) {
57154 ecode3 = SWIG_AsVal_int(obj2, &val3);
57155 if (!SWIG_IsOK(ecode3)) {
57156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
57157 }
57158 arg3 = static_cast< int >(val3);
57159 }
57160 {
57161 PyThreadState* __tstate = wxPyBeginAllowThreads();
57162 (arg1)->LeftOf(arg2,arg3);
57163 wxPyEndAllowThreads(__tstate);
57164 if (PyErr_Occurred()) SWIG_fail;
57165 }
57166 resultobj = SWIG_Py_Void();
57167 return resultobj;
57168 fail:
57169 return NULL;
57170 }
57171
57172
57173 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57174 PyObject *resultobj = 0;
57175 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57176 wxWindow *arg2 = (wxWindow *) 0 ;
57177 int arg3 = (int) 0 ;
57178 void *argp1 = 0 ;
57179 int res1 = 0 ;
57180 void *argp2 = 0 ;
57181 int res2 = 0 ;
57182 int val3 ;
57183 int ecode3 = 0 ;
57184 PyObject * obj0 = 0 ;
57185 PyObject * obj1 = 0 ;
57186 PyObject * obj2 = 0 ;
57187 char * kwnames[] = {
57188 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57189 };
57190
57191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57193 if (!SWIG_IsOK(res1)) {
57194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57195 }
57196 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57197 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57198 if (!SWIG_IsOK(res2)) {
57199 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
57200 }
57201 arg2 = reinterpret_cast< wxWindow * >(argp2);
57202 if (obj2) {
57203 ecode3 = SWIG_AsVal_int(obj2, &val3);
57204 if (!SWIG_IsOK(ecode3)) {
57205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
57206 }
57207 arg3 = static_cast< int >(val3);
57208 }
57209 {
57210 PyThreadState* __tstate = wxPyBeginAllowThreads();
57211 (arg1)->RightOf(arg2,arg3);
57212 wxPyEndAllowThreads(__tstate);
57213 if (PyErr_Occurred()) SWIG_fail;
57214 }
57215 resultobj = SWIG_Py_Void();
57216 return resultobj;
57217 fail:
57218 return NULL;
57219 }
57220
57221
57222 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57223 PyObject *resultobj = 0;
57224 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57225 wxWindow *arg2 = (wxWindow *) 0 ;
57226 int arg3 = (int) 0 ;
57227 void *argp1 = 0 ;
57228 int res1 = 0 ;
57229 void *argp2 = 0 ;
57230 int res2 = 0 ;
57231 int val3 ;
57232 int ecode3 = 0 ;
57233 PyObject * obj0 = 0 ;
57234 PyObject * obj1 = 0 ;
57235 PyObject * obj2 = 0 ;
57236 char * kwnames[] = {
57237 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57238 };
57239
57240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57242 if (!SWIG_IsOK(res1)) {
57243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57244 }
57245 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57246 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57247 if (!SWIG_IsOK(res2)) {
57248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
57249 }
57250 arg2 = reinterpret_cast< wxWindow * >(argp2);
57251 if (obj2) {
57252 ecode3 = SWIG_AsVal_int(obj2, &val3);
57253 if (!SWIG_IsOK(ecode3)) {
57254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
57255 }
57256 arg3 = static_cast< int >(val3);
57257 }
57258 {
57259 PyThreadState* __tstate = wxPyBeginAllowThreads();
57260 (arg1)->Above(arg2,arg3);
57261 wxPyEndAllowThreads(__tstate);
57262 if (PyErr_Occurred()) SWIG_fail;
57263 }
57264 resultobj = SWIG_Py_Void();
57265 return resultobj;
57266 fail:
57267 return NULL;
57268 }
57269
57270
57271 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57272 PyObject *resultobj = 0;
57273 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57274 wxWindow *arg2 = (wxWindow *) 0 ;
57275 int arg3 = (int) 0 ;
57276 void *argp1 = 0 ;
57277 int res1 = 0 ;
57278 void *argp2 = 0 ;
57279 int res2 = 0 ;
57280 int val3 ;
57281 int ecode3 = 0 ;
57282 PyObject * obj0 = 0 ;
57283 PyObject * obj1 = 0 ;
57284 PyObject * obj2 = 0 ;
57285 char * kwnames[] = {
57286 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57287 };
57288
57289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57291 if (!SWIG_IsOK(res1)) {
57292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57293 }
57294 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57295 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57296 if (!SWIG_IsOK(res2)) {
57297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
57298 }
57299 arg2 = reinterpret_cast< wxWindow * >(argp2);
57300 if (obj2) {
57301 ecode3 = SWIG_AsVal_int(obj2, &val3);
57302 if (!SWIG_IsOK(ecode3)) {
57303 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
57304 }
57305 arg3 = static_cast< int >(val3);
57306 }
57307 {
57308 PyThreadState* __tstate = wxPyBeginAllowThreads();
57309 (arg1)->Below(arg2,arg3);
57310 wxPyEndAllowThreads(__tstate);
57311 if (PyErr_Occurred()) SWIG_fail;
57312 }
57313 resultobj = SWIG_Py_Void();
57314 return resultobj;
57315 fail:
57316 return NULL;
57317 }
57318
57319
57320 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57321 PyObject *resultobj = 0;
57322 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57323 wxWindow *arg2 = (wxWindow *) 0 ;
57324 wxEdge arg3 ;
57325 int arg4 = (int) 0 ;
57326 void *argp1 = 0 ;
57327 int res1 = 0 ;
57328 void *argp2 = 0 ;
57329 int res2 = 0 ;
57330 int val3 ;
57331 int ecode3 = 0 ;
57332 int val4 ;
57333 int ecode4 = 0 ;
57334 PyObject * obj0 = 0 ;
57335 PyObject * obj1 = 0 ;
57336 PyObject * obj2 = 0 ;
57337 PyObject * obj3 = 0 ;
57338 char * kwnames[] = {
57339 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
57340 };
57341
57342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57344 if (!SWIG_IsOK(res1)) {
57345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57346 }
57347 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57348 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57349 if (!SWIG_IsOK(res2)) {
57350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
57351 }
57352 arg2 = reinterpret_cast< wxWindow * >(argp2);
57353 ecode3 = SWIG_AsVal_int(obj2, &val3);
57354 if (!SWIG_IsOK(ecode3)) {
57355 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
57356 }
57357 arg3 = static_cast< wxEdge >(val3);
57358 if (obj3) {
57359 ecode4 = SWIG_AsVal_int(obj3, &val4);
57360 if (!SWIG_IsOK(ecode4)) {
57361 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
57362 }
57363 arg4 = static_cast< int >(val4);
57364 }
57365 {
57366 PyThreadState* __tstate = wxPyBeginAllowThreads();
57367 (arg1)->SameAs(arg2,arg3,arg4);
57368 wxPyEndAllowThreads(__tstate);
57369 if (PyErr_Occurred()) SWIG_fail;
57370 }
57371 resultobj = SWIG_Py_Void();
57372 return resultobj;
57373 fail:
57374 return NULL;
57375 }
57376
57377
57378 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57379 PyObject *resultobj = 0;
57380 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57381 wxWindow *arg2 = (wxWindow *) 0 ;
57382 wxEdge arg3 ;
57383 int arg4 ;
57384 void *argp1 = 0 ;
57385 int res1 = 0 ;
57386 void *argp2 = 0 ;
57387 int res2 = 0 ;
57388 int val3 ;
57389 int ecode3 = 0 ;
57390 int val4 ;
57391 int ecode4 = 0 ;
57392 PyObject * obj0 = 0 ;
57393 PyObject * obj1 = 0 ;
57394 PyObject * obj2 = 0 ;
57395 PyObject * obj3 = 0 ;
57396 char * kwnames[] = {
57397 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
57398 };
57399
57400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57402 if (!SWIG_IsOK(res1)) {
57403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57404 }
57405 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57406 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57407 if (!SWIG_IsOK(res2)) {
57408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
57409 }
57410 arg2 = reinterpret_cast< wxWindow * >(argp2);
57411 ecode3 = SWIG_AsVal_int(obj2, &val3);
57412 if (!SWIG_IsOK(ecode3)) {
57413 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
57414 }
57415 arg3 = static_cast< wxEdge >(val3);
57416 ecode4 = SWIG_AsVal_int(obj3, &val4);
57417 if (!SWIG_IsOK(ecode4)) {
57418 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
57419 }
57420 arg4 = static_cast< int >(val4);
57421 {
57422 PyThreadState* __tstate = wxPyBeginAllowThreads();
57423 (arg1)->PercentOf(arg2,arg3,arg4);
57424 wxPyEndAllowThreads(__tstate);
57425 if (PyErr_Occurred()) SWIG_fail;
57426 }
57427 resultobj = SWIG_Py_Void();
57428 return resultobj;
57429 fail:
57430 return NULL;
57431 }
57432
57433
57434 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57435 PyObject *resultobj = 0;
57436 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57437 int arg2 ;
57438 void *argp1 = 0 ;
57439 int res1 = 0 ;
57440 int val2 ;
57441 int ecode2 = 0 ;
57442 PyObject * obj0 = 0 ;
57443 PyObject * obj1 = 0 ;
57444 char * kwnames[] = {
57445 (char *) "self",(char *) "val", NULL
57446 };
57447
57448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
57449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57450 if (!SWIG_IsOK(res1)) {
57451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57452 }
57453 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57454 ecode2 = SWIG_AsVal_int(obj1, &val2);
57455 if (!SWIG_IsOK(ecode2)) {
57456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
57457 }
57458 arg2 = static_cast< int >(val2);
57459 {
57460 PyThreadState* __tstate = wxPyBeginAllowThreads();
57461 (arg1)->Absolute(arg2);
57462 wxPyEndAllowThreads(__tstate);
57463 if (PyErr_Occurred()) SWIG_fail;
57464 }
57465 resultobj = SWIG_Py_Void();
57466 return resultobj;
57467 fail:
57468 return NULL;
57469 }
57470
57471
57472 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57473 PyObject *resultobj = 0;
57474 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57475 void *argp1 = 0 ;
57476 int res1 = 0 ;
57477 PyObject *swig_obj[1] ;
57478
57479 if (!args) SWIG_fail;
57480 swig_obj[0] = args;
57481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57482 if (!SWIG_IsOK(res1)) {
57483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57484 }
57485 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57486 {
57487 PyThreadState* __tstate = wxPyBeginAllowThreads();
57488 (arg1)->Unconstrained();
57489 wxPyEndAllowThreads(__tstate);
57490 if (PyErr_Occurred()) SWIG_fail;
57491 }
57492 resultobj = SWIG_Py_Void();
57493 return resultobj;
57494 fail:
57495 return NULL;
57496 }
57497
57498
57499 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57500 PyObject *resultobj = 0;
57501 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57502 void *argp1 = 0 ;
57503 int res1 = 0 ;
57504 PyObject *swig_obj[1] ;
57505
57506 if (!args) SWIG_fail;
57507 swig_obj[0] = args;
57508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57509 if (!SWIG_IsOK(res1)) {
57510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57511 }
57512 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57513 {
57514 PyThreadState* __tstate = wxPyBeginAllowThreads();
57515 (arg1)->AsIs();
57516 wxPyEndAllowThreads(__tstate);
57517 if (PyErr_Occurred()) SWIG_fail;
57518 }
57519 resultobj = SWIG_Py_Void();
57520 return resultobj;
57521 fail:
57522 return NULL;
57523 }
57524
57525
57526 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57527 PyObject *resultobj = 0;
57528 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57529 wxWindow *result = 0 ;
57530 void *argp1 = 0 ;
57531 int res1 = 0 ;
57532 PyObject *swig_obj[1] ;
57533
57534 if (!args) SWIG_fail;
57535 swig_obj[0] = args;
57536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57537 if (!SWIG_IsOK(res1)) {
57538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57539 }
57540 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57541 {
57542 PyThreadState* __tstate = wxPyBeginAllowThreads();
57543 result = (wxWindow *)(arg1)->GetOtherWindow();
57544 wxPyEndAllowThreads(__tstate);
57545 if (PyErr_Occurred()) SWIG_fail;
57546 }
57547 {
57548 resultobj = wxPyMake_wxObject(result, 0);
57549 }
57550 return resultobj;
57551 fail:
57552 return NULL;
57553 }
57554
57555
57556 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57557 PyObject *resultobj = 0;
57558 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57559 wxEdge result;
57560 void *argp1 = 0 ;
57561 int res1 = 0 ;
57562 PyObject *swig_obj[1] ;
57563
57564 if (!args) SWIG_fail;
57565 swig_obj[0] = args;
57566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57567 if (!SWIG_IsOK(res1)) {
57568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57569 }
57570 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57571 {
57572 PyThreadState* __tstate = wxPyBeginAllowThreads();
57573 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
57574 wxPyEndAllowThreads(__tstate);
57575 if (PyErr_Occurred()) SWIG_fail;
57576 }
57577 resultobj = SWIG_From_int(static_cast< int >(result));
57578 return resultobj;
57579 fail:
57580 return NULL;
57581 }
57582
57583
57584 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57585 PyObject *resultobj = 0;
57586 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57587 wxEdge arg2 ;
57588 void *argp1 = 0 ;
57589 int res1 = 0 ;
57590 int val2 ;
57591 int ecode2 = 0 ;
57592 PyObject * obj0 = 0 ;
57593 PyObject * obj1 = 0 ;
57594 char * kwnames[] = {
57595 (char *) "self",(char *) "which", NULL
57596 };
57597
57598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
57599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57600 if (!SWIG_IsOK(res1)) {
57601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57602 }
57603 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57604 ecode2 = SWIG_AsVal_int(obj1, &val2);
57605 if (!SWIG_IsOK(ecode2)) {
57606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
57607 }
57608 arg2 = static_cast< wxEdge >(val2);
57609 {
57610 PyThreadState* __tstate = wxPyBeginAllowThreads();
57611 (arg1)->SetEdge(arg2);
57612 wxPyEndAllowThreads(__tstate);
57613 if (PyErr_Occurred()) SWIG_fail;
57614 }
57615 resultobj = SWIG_Py_Void();
57616 return resultobj;
57617 fail:
57618 return NULL;
57619 }
57620
57621
57622 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57623 PyObject *resultobj = 0;
57624 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57625 int arg2 ;
57626 void *argp1 = 0 ;
57627 int res1 = 0 ;
57628 int val2 ;
57629 int ecode2 = 0 ;
57630 PyObject * obj0 = 0 ;
57631 PyObject * obj1 = 0 ;
57632 char * kwnames[] = {
57633 (char *) "self",(char *) "v", NULL
57634 };
57635
57636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
57637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57638 if (!SWIG_IsOK(res1)) {
57639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57640 }
57641 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57642 ecode2 = SWIG_AsVal_int(obj1, &val2);
57643 if (!SWIG_IsOK(ecode2)) {
57644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
57645 }
57646 arg2 = static_cast< int >(val2);
57647 {
57648 PyThreadState* __tstate = wxPyBeginAllowThreads();
57649 (arg1)->SetValue(arg2);
57650 wxPyEndAllowThreads(__tstate);
57651 if (PyErr_Occurred()) SWIG_fail;
57652 }
57653 resultobj = SWIG_Py_Void();
57654 return resultobj;
57655 fail:
57656 return NULL;
57657 }
57658
57659
57660 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57661 PyObject *resultobj = 0;
57662 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57663 int result;
57664 void *argp1 = 0 ;
57665 int res1 = 0 ;
57666 PyObject *swig_obj[1] ;
57667
57668 if (!args) SWIG_fail;
57669 swig_obj[0] = args;
57670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57671 if (!SWIG_IsOK(res1)) {
57672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57673 }
57674 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57675 {
57676 PyThreadState* __tstate = wxPyBeginAllowThreads();
57677 result = (int)(arg1)->GetMargin();
57678 wxPyEndAllowThreads(__tstate);
57679 if (PyErr_Occurred()) SWIG_fail;
57680 }
57681 resultobj = SWIG_From_int(static_cast< int >(result));
57682 return resultobj;
57683 fail:
57684 return NULL;
57685 }
57686
57687
57688 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57689 PyObject *resultobj = 0;
57690 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57691 int arg2 ;
57692 void *argp1 = 0 ;
57693 int res1 = 0 ;
57694 int val2 ;
57695 int ecode2 = 0 ;
57696 PyObject * obj0 = 0 ;
57697 PyObject * obj1 = 0 ;
57698 char * kwnames[] = {
57699 (char *) "self",(char *) "m", NULL
57700 };
57701
57702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
57703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57704 if (!SWIG_IsOK(res1)) {
57705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57706 }
57707 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57708 ecode2 = SWIG_AsVal_int(obj1, &val2);
57709 if (!SWIG_IsOK(ecode2)) {
57710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
57711 }
57712 arg2 = static_cast< int >(val2);
57713 {
57714 PyThreadState* __tstate = wxPyBeginAllowThreads();
57715 (arg1)->SetMargin(arg2);
57716 wxPyEndAllowThreads(__tstate);
57717 if (PyErr_Occurred()) SWIG_fail;
57718 }
57719 resultobj = SWIG_Py_Void();
57720 return resultobj;
57721 fail:
57722 return NULL;
57723 }
57724
57725
57726 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57727 PyObject *resultobj = 0;
57728 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57729 int result;
57730 void *argp1 = 0 ;
57731 int res1 = 0 ;
57732 PyObject *swig_obj[1] ;
57733
57734 if (!args) SWIG_fail;
57735 swig_obj[0] = args;
57736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57737 if (!SWIG_IsOK(res1)) {
57738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57739 }
57740 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57741 {
57742 PyThreadState* __tstate = wxPyBeginAllowThreads();
57743 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
57744 wxPyEndAllowThreads(__tstate);
57745 if (PyErr_Occurred()) SWIG_fail;
57746 }
57747 resultobj = SWIG_From_int(static_cast< int >(result));
57748 return resultobj;
57749 fail:
57750 return NULL;
57751 }
57752
57753
57754 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57755 PyObject *resultobj = 0;
57756 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57757 int result;
57758 void *argp1 = 0 ;
57759 int res1 = 0 ;
57760 PyObject *swig_obj[1] ;
57761
57762 if (!args) SWIG_fail;
57763 swig_obj[0] = args;
57764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57765 if (!SWIG_IsOK(res1)) {
57766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57767 }
57768 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57769 {
57770 PyThreadState* __tstate = wxPyBeginAllowThreads();
57771 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
57772 wxPyEndAllowThreads(__tstate);
57773 if (PyErr_Occurred()) SWIG_fail;
57774 }
57775 resultobj = SWIG_From_int(static_cast< int >(result));
57776 return resultobj;
57777 fail:
57778 return NULL;
57779 }
57780
57781
57782 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57783 PyObject *resultobj = 0;
57784 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57785 int result;
57786 void *argp1 = 0 ;
57787 int res1 = 0 ;
57788 PyObject *swig_obj[1] ;
57789
57790 if (!args) SWIG_fail;
57791 swig_obj[0] = args;
57792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57793 if (!SWIG_IsOK(res1)) {
57794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57795 }
57796 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57797 {
57798 PyThreadState* __tstate = wxPyBeginAllowThreads();
57799 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
57800 wxPyEndAllowThreads(__tstate);
57801 if (PyErr_Occurred()) SWIG_fail;
57802 }
57803 resultobj = SWIG_From_int(static_cast< int >(result));
57804 return resultobj;
57805 fail:
57806 return NULL;
57807 }
57808
57809
57810 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57811 PyObject *resultobj = 0;
57812 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57813 bool result;
57814 void *argp1 = 0 ;
57815 int res1 = 0 ;
57816 PyObject *swig_obj[1] ;
57817
57818 if (!args) SWIG_fail;
57819 swig_obj[0] = args;
57820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57821 if (!SWIG_IsOK(res1)) {
57822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57823 }
57824 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57825 {
57826 PyThreadState* __tstate = wxPyBeginAllowThreads();
57827 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
57828 wxPyEndAllowThreads(__tstate);
57829 if (PyErr_Occurred()) SWIG_fail;
57830 }
57831 {
57832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57833 }
57834 return resultobj;
57835 fail:
57836 return NULL;
57837 }
57838
57839
57840 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57841 PyObject *resultobj = 0;
57842 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57843 bool arg2 ;
57844 void *argp1 = 0 ;
57845 int res1 = 0 ;
57846 bool val2 ;
57847 int ecode2 = 0 ;
57848 PyObject * obj0 = 0 ;
57849 PyObject * obj1 = 0 ;
57850 char * kwnames[] = {
57851 (char *) "self",(char *) "d", NULL
57852 };
57853
57854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
57855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57856 if (!SWIG_IsOK(res1)) {
57857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57858 }
57859 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57860 ecode2 = SWIG_AsVal_bool(obj1, &val2);
57861 if (!SWIG_IsOK(ecode2)) {
57862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
57863 }
57864 arg2 = static_cast< bool >(val2);
57865 {
57866 PyThreadState* __tstate = wxPyBeginAllowThreads();
57867 (arg1)->SetDone(arg2);
57868 wxPyEndAllowThreads(__tstate);
57869 if (PyErr_Occurred()) SWIG_fail;
57870 }
57871 resultobj = SWIG_Py_Void();
57872 return resultobj;
57873 fail:
57874 return NULL;
57875 }
57876
57877
57878 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57879 PyObject *resultobj = 0;
57880 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57881 wxRelationship result;
57882 void *argp1 = 0 ;
57883 int res1 = 0 ;
57884 PyObject *swig_obj[1] ;
57885
57886 if (!args) SWIG_fail;
57887 swig_obj[0] = args;
57888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57889 if (!SWIG_IsOK(res1)) {
57890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57891 }
57892 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57893 {
57894 PyThreadState* __tstate = wxPyBeginAllowThreads();
57895 result = (wxRelationship)(arg1)->GetRelationship();
57896 wxPyEndAllowThreads(__tstate);
57897 if (PyErr_Occurred()) SWIG_fail;
57898 }
57899 resultobj = SWIG_From_int(static_cast< int >(result));
57900 return resultobj;
57901 fail:
57902 return NULL;
57903 }
57904
57905
57906 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57907 PyObject *resultobj = 0;
57908 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57909 wxRelationship arg2 ;
57910 void *argp1 = 0 ;
57911 int res1 = 0 ;
57912 int val2 ;
57913 int ecode2 = 0 ;
57914 PyObject * obj0 = 0 ;
57915 PyObject * obj1 = 0 ;
57916 char * kwnames[] = {
57917 (char *) "self",(char *) "r", NULL
57918 };
57919
57920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
57921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57922 if (!SWIG_IsOK(res1)) {
57923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57924 }
57925 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57926 ecode2 = SWIG_AsVal_int(obj1, &val2);
57927 if (!SWIG_IsOK(ecode2)) {
57928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
57929 }
57930 arg2 = static_cast< wxRelationship >(val2);
57931 {
57932 PyThreadState* __tstate = wxPyBeginAllowThreads();
57933 (arg1)->SetRelationship(arg2);
57934 wxPyEndAllowThreads(__tstate);
57935 if (PyErr_Occurred()) SWIG_fail;
57936 }
57937 resultobj = SWIG_Py_Void();
57938 return resultobj;
57939 fail:
57940 return NULL;
57941 }
57942
57943
57944 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57945 PyObject *resultobj = 0;
57946 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57947 wxWindow *arg2 = (wxWindow *) 0 ;
57948 bool result;
57949 void *argp1 = 0 ;
57950 int res1 = 0 ;
57951 void *argp2 = 0 ;
57952 int res2 = 0 ;
57953 PyObject * obj0 = 0 ;
57954 PyObject * obj1 = 0 ;
57955 char * kwnames[] = {
57956 (char *) "self",(char *) "otherW", NULL
57957 };
57958
57959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
57960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57961 if (!SWIG_IsOK(res1)) {
57962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57963 }
57964 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57965 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57966 if (!SWIG_IsOK(res2)) {
57967 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
57968 }
57969 arg2 = reinterpret_cast< wxWindow * >(argp2);
57970 {
57971 PyThreadState* __tstate = wxPyBeginAllowThreads();
57972 result = (bool)(arg1)->ResetIfWin(arg2);
57973 wxPyEndAllowThreads(__tstate);
57974 if (PyErr_Occurred()) SWIG_fail;
57975 }
57976 {
57977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57978 }
57979 return resultobj;
57980 fail:
57981 return NULL;
57982 }
57983
57984
57985 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57986 PyObject *resultobj = 0;
57987 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57988 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
57989 wxWindow *arg3 = (wxWindow *) 0 ;
57990 bool result;
57991 void *argp1 = 0 ;
57992 int res1 = 0 ;
57993 void *argp2 = 0 ;
57994 int res2 = 0 ;
57995 void *argp3 = 0 ;
57996 int res3 = 0 ;
57997 PyObject * obj0 = 0 ;
57998 PyObject * obj1 = 0 ;
57999 PyObject * obj2 = 0 ;
58000 char * kwnames[] = {
58001 (char *) "self",(char *) "constraints",(char *) "win", NULL
58002 };
58003
58004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
58005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58006 if (!SWIG_IsOK(res1)) {
58007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
58008 }
58009 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
58010 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58011 if (!SWIG_IsOK(res2)) {
58012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
58013 }
58014 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
58015 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
58016 if (!SWIG_IsOK(res3)) {
58017 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
58018 }
58019 arg3 = reinterpret_cast< wxWindow * >(argp3);
58020 {
58021 PyThreadState* __tstate = wxPyBeginAllowThreads();
58022 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
58023 wxPyEndAllowThreads(__tstate);
58024 if (PyErr_Occurred()) SWIG_fail;
58025 }
58026 {
58027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
58028 }
58029 return resultobj;
58030 fail:
58031 return NULL;
58032 }
58033
58034
58035 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
58036 PyObject *resultobj = 0;
58037 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
58038 wxEdge arg2 ;
58039 wxWindow *arg3 = (wxWindow *) 0 ;
58040 wxWindow *arg4 = (wxWindow *) 0 ;
58041 int result;
58042 void *argp1 = 0 ;
58043 int res1 = 0 ;
58044 int val2 ;
58045 int ecode2 = 0 ;
58046 void *argp3 = 0 ;
58047 int res3 = 0 ;
58048 void *argp4 = 0 ;
58049 int res4 = 0 ;
58050 PyObject * obj0 = 0 ;
58051 PyObject * obj1 = 0 ;
58052 PyObject * obj2 = 0 ;
58053 PyObject * obj3 = 0 ;
58054 char * kwnames[] = {
58055 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
58056 };
58057
58058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
58059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58060 if (!SWIG_IsOK(res1)) {
58061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
58062 }
58063 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
58064 ecode2 = SWIG_AsVal_int(obj1, &val2);
58065 if (!SWIG_IsOK(ecode2)) {
58066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
58067 }
58068 arg2 = static_cast< wxEdge >(val2);
58069 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
58070 if (!SWIG_IsOK(res3)) {
58071 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
58072 }
58073 arg3 = reinterpret_cast< wxWindow * >(argp3);
58074 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
58075 if (!SWIG_IsOK(res4)) {
58076 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
58077 }
58078 arg4 = reinterpret_cast< wxWindow * >(argp4);
58079 {
58080 PyThreadState* __tstate = wxPyBeginAllowThreads();
58081 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
58082 wxPyEndAllowThreads(__tstate);
58083 if (PyErr_Occurred()) SWIG_fail;
58084 }
58085 resultobj = SWIG_From_int(static_cast< int >(result));
58086 return resultobj;
58087 fail:
58088 return NULL;
58089 }
58090
58091
58092 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58093 PyObject *obj;
58094 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
58095 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
58096 return SWIG_Py_Void();
58097 }
58098
58099 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58100 PyObject *resultobj = 0;
58101 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58102 wxIndividualLayoutConstraint *result = 0 ;
58103 void *argp1 = 0 ;
58104 int res1 = 0 ;
58105 PyObject *swig_obj[1] ;
58106
58107 if (!args) SWIG_fail;
58108 swig_obj[0] = args;
58109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58110 if (!SWIG_IsOK(res1)) {
58111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58112 }
58113 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58114 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
58115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58116 return resultobj;
58117 fail:
58118 return NULL;
58119 }
58120
58121
58122 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58123 PyObject *resultobj = 0;
58124 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58125 wxIndividualLayoutConstraint *result = 0 ;
58126 void *argp1 = 0 ;
58127 int res1 = 0 ;
58128 PyObject *swig_obj[1] ;
58129
58130 if (!args) SWIG_fail;
58131 swig_obj[0] = args;
58132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58133 if (!SWIG_IsOK(res1)) {
58134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58135 }
58136 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58137 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
58138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58139 return resultobj;
58140 fail:
58141 return NULL;
58142 }
58143
58144
58145 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58146 PyObject *resultobj = 0;
58147 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58148 wxIndividualLayoutConstraint *result = 0 ;
58149 void *argp1 = 0 ;
58150 int res1 = 0 ;
58151 PyObject *swig_obj[1] ;
58152
58153 if (!args) SWIG_fail;
58154 swig_obj[0] = args;
58155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58156 if (!SWIG_IsOK(res1)) {
58157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58158 }
58159 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58160 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
58161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58162 return resultobj;
58163 fail:
58164 return NULL;
58165 }
58166
58167
58168 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58169 PyObject *resultobj = 0;
58170 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58171 wxIndividualLayoutConstraint *result = 0 ;
58172 void *argp1 = 0 ;
58173 int res1 = 0 ;
58174 PyObject *swig_obj[1] ;
58175
58176 if (!args) SWIG_fail;
58177 swig_obj[0] = args;
58178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58179 if (!SWIG_IsOK(res1)) {
58180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58181 }
58182 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58183 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
58184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58185 return resultobj;
58186 fail:
58187 return NULL;
58188 }
58189
58190
58191 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58192 PyObject *resultobj = 0;
58193 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58194 wxIndividualLayoutConstraint *result = 0 ;
58195 void *argp1 = 0 ;
58196 int res1 = 0 ;
58197 PyObject *swig_obj[1] ;
58198
58199 if (!args) SWIG_fail;
58200 swig_obj[0] = args;
58201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58202 if (!SWIG_IsOK(res1)) {
58203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58204 }
58205 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58206 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
58207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58208 return resultobj;
58209 fail:
58210 return NULL;
58211 }
58212
58213
58214 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58215 PyObject *resultobj = 0;
58216 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58217 wxIndividualLayoutConstraint *result = 0 ;
58218 void *argp1 = 0 ;
58219 int res1 = 0 ;
58220 PyObject *swig_obj[1] ;
58221
58222 if (!args) SWIG_fail;
58223 swig_obj[0] = args;
58224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58225 if (!SWIG_IsOK(res1)) {
58226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58227 }
58228 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58229 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
58230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58231 return resultobj;
58232 fail:
58233 return NULL;
58234 }
58235
58236
58237 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58238 PyObject *resultobj = 0;
58239 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58240 wxIndividualLayoutConstraint *result = 0 ;
58241 void *argp1 = 0 ;
58242 int res1 = 0 ;
58243 PyObject *swig_obj[1] ;
58244
58245 if (!args) SWIG_fail;
58246 swig_obj[0] = args;
58247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58248 if (!SWIG_IsOK(res1)) {
58249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58250 }
58251 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58252 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
58253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58254 return resultobj;
58255 fail:
58256 return NULL;
58257 }
58258
58259
58260 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58261 PyObject *resultobj = 0;
58262 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58263 wxIndividualLayoutConstraint *result = 0 ;
58264 void *argp1 = 0 ;
58265 int res1 = 0 ;
58266 PyObject *swig_obj[1] ;
58267
58268 if (!args) SWIG_fail;
58269 swig_obj[0] = args;
58270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58271 if (!SWIG_IsOK(res1)) {
58272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58273 }
58274 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58275 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
58276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58277 return resultobj;
58278 fail:
58279 return NULL;
58280 }
58281
58282
58283 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58284 PyObject *resultobj = 0;
58285 wxLayoutConstraints *result = 0 ;
58286
58287 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
58288 {
58289 PyThreadState* __tstate = wxPyBeginAllowThreads();
58290 result = (wxLayoutConstraints *)new wxLayoutConstraints();
58291 wxPyEndAllowThreads(__tstate);
58292 if (PyErr_Occurred()) SWIG_fail;
58293 }
58294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
58295 return resultobj;
58296 fail:
58297 return NULL;
58298 }
58299
58300
58301 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58302 PyObject *resultobj = 0;
58303 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58304 void *argp1 = 0 ;
58305 int res1 = 0 ;
58306 PyObject *swig_obj[1] ;
58307
58308 if (!args) SWIG_fail;
58309 swig_obj[0] = args;
58310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
58311 if (!SWIG_IsOK(res1)) {
58312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58313 }
58314 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58315 {
58316 PyThreadState* __tstate = wxPyBeginAllowThreads();
58317 delete arg1;
58318
58319 wxPyEndAllowThreads(__tstate);
58320 if (PyErr_Occurred()) SWIG_fail;
58321 }
58322 resultobj = SWIG_Py_Void();
58323 return resultobj;
58324 fail:
58325 return NULL;
58326 }
58327
58328
58329 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
58330 PyObject *resultobj = 0;
58331 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58332 wxWindow *arg2 = (wxWindow *) 0 ;
58333 int *arg3 = (int *) 0 ;
58334 bool result;
58335 void *argp1 = 0 ;
58336 int res1 = 0 ;
58337 void *argp2 = 0 ;
58338 int res2 = 0 ;
58339 int temp3 ;
58340 int res3 = SWIG_TMPOBJ ;
58341 PyObject * obj0 = 0 ;
58342 PyObject * obj1 = 0 ;
58343 char * kwnames[] = {
58344 (char *) "self",(char *) "win", NULL
58345 };
58346
58347 arg3 = &temp3;
58348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
58349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58350 if (!SWIG_IsOK(res1)) {
58351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58352 }
58353 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58354 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
58355 if (!SWIG_IsOK(res2)) {
58356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
58357 }
58358 arg2 = reinterpret_cast< wxWindow * >(argp2);
58359 {
58360 PyThreadState* __tstate = wxPyBeginAllowThreads();
58361 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
58362 wxPyEndAllowThreads(__tstate);
58363 if (PyErr_Occurred()) SWIG_fail;
58364 }
58365 {
58366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
58367 }
58368 if (SWIG_IsTmpObj(res3)) {
58369 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
58370 } else {
58371 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
58372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
58373 }
58374 return resultobj;
58375 fail:
58376 return NULL;
58377 }
58378
58379
58380 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58381 PyObject *resultobj = 0;
58382 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58383 bool result;
58384 void *argp1 = 0 ;
58385 int res1 = 0 ;
58386 PyObject *swig_obj[1] ;
58387
58388 if (!args) SWIG_fail;
58389 swig_obj[0] = args;
58390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58391 if (!SWIG_IsOK(res1)) {
58392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
58393 }
58394 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58395 {
58396 PyThreadState* __tstate = wxPyBeginAllowThreads();
58397 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
58398 wxPyEndAllowThreads(__tstate);
58399 if (PyErr_Occurred()) SWIG_fail;
58400 }
58401 {
58402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
58403 }
58404 return resultobj;
58405 fail:
58406 return NULL;
58407 }
58408
58409
58410 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58411 PyObject *obj;
58412 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
58413 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
58414 return SWIG_Py_Void();
58415 }
58416
58417 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58418 return SWIG_Python_InitShadowInstance(args);
58419 }
58420
58421 static PyMethodDef SwigMethods[] = {
58422 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
58423 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
58424 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
58425 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
58426 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
58427 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
58428 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
58429 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
58430 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
58431 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
58432 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
58433 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58434 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58435 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58436 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
58437 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
58438 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
58439 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
58440 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
58441 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
58442 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58443 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
58444 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
58445 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
58446 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
58447 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
58448 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
58449 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
58450 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
58451 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
58452 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
58453 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
58454 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
58455 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
58456 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58457 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
58458 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58459 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58460 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58461 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
58462 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58463 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
58464 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
58465 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
58466 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
58467 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
58468 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
58469 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
58470 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
58471 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
58472 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58473 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58474 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58475 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
58476 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58477 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
58478 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58479 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
58480 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
58481 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
58482 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
58483 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
58484 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
58485 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
58486 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
58487 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
58488 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
58489 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
58490 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
58491 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
58492 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
58493 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
58494 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
58495 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
58496 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58497 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
58498 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
58499 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
58500 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
58501 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58502 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
58503 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
58504 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
58505 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
58506 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
58507 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58508 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
58509 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
58510 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
58511 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
58512 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58513 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
58514 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
58515 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58516 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
58517 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
58518 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
58519 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
58520 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
58521 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
58522 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58523 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58524 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58525 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58526 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
58527 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
58528 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
58529 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
58530 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
58531 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
58532 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
58533 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
58534 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
58535 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
58536 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
58537 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
58538 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
58539 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58540 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
58541 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
58542 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
58543 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
58544 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
58545 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
58546 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58547 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
58548 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
58549 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
58550 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
58551 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
58552 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
58553 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
58554 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
58555 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
58556 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
58557 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
58558 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
58559 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58560 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
58561 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
58562 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
58563 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58564 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58565 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
58566 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
58567 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
58568 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
58569 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58570 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
58571 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
58572 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
58573 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
58574 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
58575 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
58576 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
58577 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
58578 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58579 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
58580 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
58581 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
58582 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58583 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
58584 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58585 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58586 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
58587 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
58588 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
58589 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
58590 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
58591 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58592 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
58593 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58594 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58595 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
58596 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
58597 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58598 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
58599 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58600 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58601 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
58602 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
58603 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
58604 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
58605 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
58606 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
58607 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
58608 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
58609 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
58610 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
58611 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
58612 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
58613 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
58614 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
58615 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
58616 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
58617 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
58618 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
58619 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58620 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58621 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
58622 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
58623 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
58624 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
58625 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
58626 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
58627 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
58628 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
58629 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58630 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
58631 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
58632 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
58633 { (char *)"new_Position", (PyCFunction) _wrap_new_Position, METH_VARARGS | METH_KEYWORDS, NULL},
58634 { (char *)"delete_Position", (PyCFunction)_wrap_delete_Position, METH_O, NULL},
58635 { (char *)"Position_GetRow", (PyCFunction)_wrap_Position_GetRow, METH_O, NULL},
58636 { (char *)"Position_GetColumn", (PyCFunction)_wrap_Position_GetColumn, METH_O, NULL},
58637 { (char *)"Position_GetCol", (PyCFunction)_wrap_Position_GetCol, METH_O, NULL},
58638 { (char *)"Position_SetRow", (PyCFunction) _wrap_Position_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
58639 { (char *)"Position_SetColumn", (PyCFunction) _wrap_Position_SetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
58640 { (char *)"Position_SetCol", (PyCFunction) _wrap_Position_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
58641 { (char *)"Position___eq__", (PyCFunction) _wrap_Position___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58642 { (char *)"Position___ne__", (PyCFunction) _wrap_Position___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58643 { (char *)"Position___add__", _wrap_Position___add__, METH_VARARGS, NULL},
58644 { (char *)"Position___sub__", _wrap_Position___sub__, METH_VARARGS, NULL},
58645 { (char *)"Position_swigregister", Position_swigregister, METH_VARARGS, NULL},
58646 { (char *)"Position_swiginit", Position_swiginit, METH_VARARGS, NULL},
58647 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
58648 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
58649 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
58650 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
58651 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
58652 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
58653 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
58654 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
58655 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
58656 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
58657 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
58658 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
58659 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
58660 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
58661 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
58662 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
58663 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
58664 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
58665 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
58666 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
58667 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
58668 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
58669 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
58670 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
58671 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
58672 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
58673 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
58674 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
58675 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
58676 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
58677 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
58678 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
58679 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
58680 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
58681 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
58682 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
58683 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58684 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58685 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58686 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58687 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
58688 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
58689 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
58690 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
58691 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
58692 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
58693 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
58694 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
58695 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
58696 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
58697 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
58698 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
58699 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58700 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58701 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
58702 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58703 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58704 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
58705 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
58706 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
58707 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
58708 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
58709 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
58710 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58711 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58712 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
58713 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
58714 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
58715 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58716 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58717 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58718 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
58719 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
58720 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
58721 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
58722 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58723 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
58724 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
58725 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58726 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58727 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58728 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58729 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
58730 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
58731 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
58732 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
58733 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
58734 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
58735 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
58736 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58737 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58738 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
58739 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
58740 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
58741 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
58742 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
58743 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
58744 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58745 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
58746 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
58747 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
58748 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58749 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58750 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
58751 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58752 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
58753 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
58754 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
58755 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
58756 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
58757 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
58758 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
58759 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
58760 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
58761 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
58762 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
58763 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
58764 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
58765 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
58766 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
58767 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
58768 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
58769 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
58770 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
58771 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
58772 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
58773 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
58774 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
58775 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
58776 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
58777 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
58778 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
58779 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58780 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
58781 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58782 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58783 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
58784 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
58785 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
58786 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
58787 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
58788 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
58789 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
58790 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
58791 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
58792 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
58793 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58794 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
58795 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
58796 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
58797 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
58798 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58799 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58800 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
58801 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
58802 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
58803 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58804 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
58805 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58806 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
58807 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58808 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
58809 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
58810 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58811 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58812 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58813 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58814 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58815 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
58816 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
58817 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
58818 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
58819 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
58820 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
58821 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
58822 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
58823 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
58824 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
58825 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
58826 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
58827 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58828 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
58829 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
58830 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
58831 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58832 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
58833 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
58834 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
58835 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
58836 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
58837 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
58838 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
58839 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
58840 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
58841 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
58842 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
58843 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
58844 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
58845 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58846 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58847 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58848 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58849 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
58850 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
58851 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
58852 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58853 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58854 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58855 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
58856 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
58857 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58858 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58859 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
58860 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
58861 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58862 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
58863 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
58864 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58865 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
58866 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
58867 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
58868 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
58869 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
58870 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
58871 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
58872 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
58873 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
58874 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
58875 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
58876 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
58877 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
58878 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
58879 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
58880 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
58881 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
58882 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
58883 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
58884 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
58885 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
58886 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
58887 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
58888 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
58889 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
58890 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
58891 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
58892 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
58893 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
58894 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
58895 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
58896 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
58897 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
58898 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
58899 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
58900 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
58901 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
58902 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
58903 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
58904 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
58905 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
58906 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58907 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58908 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
58909 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58910 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58911 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58912 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
58913 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
58914 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
58915 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58916 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
58917 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
58918 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
58919 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
58920 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
58921 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
58922 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
58923 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
58924 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
58925 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
58926 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
58927 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58928 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
58929 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
58930 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
58931 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
58932 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
58933 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
58934 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
58935 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
58936 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
58937 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
58938 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
58939 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
58940 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
58941 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
58942 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
58943 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
58944 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58945 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
58946 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
58947 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
58948 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
58949 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
58950 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
58951 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
58952 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
58953 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
58954 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
58955 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
58956 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
58957 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
58958 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
58959 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58960 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
58961 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
58962 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
58963 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
58964 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
58965 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58966 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
58967 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
58968 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58969 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58970 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
58971 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
58972 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58973 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
58974 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
58975 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58976 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58977 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
58978 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
58979 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58980 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
58981 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
58982 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
58983 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
58984 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
58985 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
58986 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
58987 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
58988 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
58989 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
58990 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
58991 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
58992 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
58993 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
58994 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
58995 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
58996 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
58997 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
58998 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
58999 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
59000 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
59001 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
59002 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
59003 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
59004 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
59005 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
59006 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
59007 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
59008 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
59009 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
59010 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59011 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
59012 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
59013 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
59014 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
59015 { (char *)"MouseEvent_GetWheelAxis", (PyCFunction)_wrap_MouseEvent_GetWheelAxis, METH_O, NULL},
59016 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
59017 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
59018 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
59019 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
59020 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
59021 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
59022 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
59023 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
59024 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
59025 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
59026 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
59027 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
59028 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
59029 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
59030 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
59031 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
59032 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
59033 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
59034 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
59035 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
59036 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
59037 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
59038 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
59039 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
59040 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
59041 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
59042 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
59043 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
59044 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59045 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
59046 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
59047 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
59048 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
59049 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
59050 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
59051 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
59052 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59053 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
59054 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
59055 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
59056 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
59057 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
59058 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
59059 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
59060 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
59061 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
59062 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
59063 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
59064 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
59065 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
59066 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
59067 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
59068 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
59069 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
59070 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
59071 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
59072 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
59073 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
59074 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
59075 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
59076 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
59077 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
59078 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
59079 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
59080 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
59081 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
59082 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
59083 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
59084 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
59085 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
59086 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
59087 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
59088 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
59089 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
59090 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
59091 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59092 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
59093 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
59094 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
59095 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
59096 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
59097 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
59098 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
59099 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
59100 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
59101 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
59102 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59103 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
59104 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
59105 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
59106 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59107 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
59108 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
59109 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59110 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
59111 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
59112 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59113 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
59114 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
59115 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59116 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
59117 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
59118 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
59119 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59120 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
59121 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59122 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
59123 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
59124 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59125 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
59126 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
59127 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
59128 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59129 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
59130 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
59131 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
59132 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59133 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
59134 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
59135 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59136 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
59137 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
59138 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
59139 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
59140 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
59141 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59142 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
59143 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
59144 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
59145 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
59146 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
59147 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
59148 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
59149 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
59150 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59151 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
59152 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
59153 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
59154 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
59155 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59156 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
59157 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
59158 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
59159 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59160 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
59161 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
59162 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
59163 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
59164 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
59165 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
59166 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59167 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
59168 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
59169 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
59170 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
59171 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
59172 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
59173 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
59174 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
59175 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59176 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59177 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59178 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
59179 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
59180 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
59181 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
59182 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
59183 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
59184 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
59185 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
59186 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
59187 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
59188 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
59189 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
59190 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59191 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
59192 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
59193 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
59194 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59195 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
59196 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
59197 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
59198 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
59199 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
59200 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59201 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59202 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
59203 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
59204 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
59205 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59206 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
59207 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
59208 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
59209 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
59210 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
59211 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
59212 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59213 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
59214 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
59215 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
59216 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
59217 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
59218 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
59219 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
59220 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
59221 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
59222 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59223 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
59224 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
59225 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
59226 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59227 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
59228 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
59229 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
59230 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59231 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
59232 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59233 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
59234 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
59235 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
59236 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
59237 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
59238 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
59239 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
59240 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
59241 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
59242 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
59243 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59244 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
59245 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
59246 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59247 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
59248 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
59249 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
59250 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
59251 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
59252 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59253 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
59254 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
59255 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
59256 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
59257 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
59258 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59259 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
59260 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
59261 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
59262 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
59263 { (char *)"new_EventBlocker", (PyCFunction) _wrap_new_EventBlocker, METH_VARARGS | METH_KEYWORDS, NULL},
59264 { (char *)"delete_EventBlocker", (PyCFunction)_wrap_delete_EventBlocker, METH_O, NULL},
59265 { (char *)"EventBlocker_Block", (PyCFunction) _wrap_EventBlocker_Block, METH_VARARGS | METH_KEYWORDS, NULL},
59266 { (char *)"EventBlocker_swigregister", EventBlocker_swigregister, METH_VARARGS, NULL},
59267 { (char *)"EventBlocker_swiginit", EventBlocker_swiginit, METH_VARARGS, NULL},
59268 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
59269 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
59270 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59271 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
59272 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
59273 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
59274 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
59275 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
59276 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
59277 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
59278 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
59279 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
59280 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
59281 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
59282 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
59283 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
59284 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
59285 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
59286 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
59287 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
59288 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
59289 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
59290 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
59291 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59292 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
59293 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
59294 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
59295 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
59296 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
59297 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
59298 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
59299 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
59300 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
59301 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
59302 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
59303 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
59304 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
59305 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
59306 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
59307 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
59308 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
59309 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
59310 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
59311 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
59312 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
59313 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
59314 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
59315 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
59316 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
59317 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
59318 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
59319 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
59320 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
59321 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59322 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
59323 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
59324 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
59325 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
59326 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
59327 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
59328 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
59329 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
59330 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
59331 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
59332 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
59333 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
59334 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
59335 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
59336 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
59337 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
59338 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
59339 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
59340 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
59341 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
59342 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
59343 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59344 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59345 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
59346 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
59347 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
59348 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
59349 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
59350 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
59351 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
59352 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
59353 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
59354 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
59355 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
59356 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
59357 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
59358 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
59359 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
59360 { (char *)"VisualAttributes__get_font", (PyCFunction)_wrap_VisualAttributes__get_font, METH_O, NULL},
59361 { (char *)"VisualAttributes__get_colFg", (PyCFunction)_wrap_VisualAttributes__get_colFg, METH_O, NULL},
59362 { (char *)"VisualAttributes__get_colBg", (PyCFunction)_wrap_VisualAttributes__get_colBg, METH_O, NULL},
59363 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
59364 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
59365 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
59366 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
59367 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59368 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
59369 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
59370 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
59371 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
59372 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59373 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
59374 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
59375 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
59376 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
59377 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
59378 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
59379 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
59380 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
59381 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
59382 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
59383 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
59384 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59385 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59386 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
59387 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
59388 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
59389 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
59390 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
59391 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
59392 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
59393 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
59394 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
59395 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
59396 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
59397 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
59398 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
59399 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
59400 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
59401 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
59402 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
59403 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
59404 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
59405 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
59406 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
59407 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
59408 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
59409 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
59410 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
59411 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
59412 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
59413 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
59414 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
59415 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
59416 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
59417 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
59418 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
59419 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59420 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
59421 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59422 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
59423 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
59424 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
59425 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59426 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
59427 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
59428 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
59429 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
59430 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
59431 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
59432 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
59433 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
59434 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
59435 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
59436 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
59437 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59438 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
59439 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59440 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
59441 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
59442 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
59443 { (char *)"Window_IsThisEnabled", (PyCFunction)_wrap_Window_IsThisEnabled, METH_O, NULL},
59444 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
59445 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59446 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
59447 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59448 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
59449 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59450 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59451 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
59452 { (char *)"Window_HasExtraStyle", (PyCFunction) _wrap_Window_HasExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59453 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
59454 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59455 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
59456 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
59457 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
59458 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
59459 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
59460 { (char *)"Window_CanAcceptFocus", (PyCFunction)_wrap_Window_CanAcceptFocus, METH_O, NULL},
59461 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
59462 { (char *)"Window_CanAcceptFocusFromKeyboard", (PyCFunction)_wrap_Window_CanAcceptFocusFromKeyboard, METH_O, NULL},
59463 { (char *)"Window_SetCanFocus", (PyCFunction) _wrap_Window_SetCanFocus, METH_VARARGS | METH_KEYWORDS, NULL},
59464 { (char *)"Window_NavigateIn", (PyCFunction) _wrap_Window_NavigateIn, METH_VARARGS | METH_KEYWORDS, NULL},
59465 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
59466 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
59467 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
59468 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
59469 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
59470 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
59471 { (char *)"Window_GetTopLevelParent", (PyCFunction)_wrap_Window_GetTopLevelParent, METH_O, NULL},
59472 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
59473 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
59474 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
59475 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
59476 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
59477 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
59478 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
59479 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
59480 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59481 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59482 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59483 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59484 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
59485 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
59486 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
59487 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
59488 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
59489 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
59490 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
59491 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
59492 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
59493 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
59494 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
59495 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
59496 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
59497 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
59498 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
59499 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
59500 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
59501 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
59502 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
59503 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
59504 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
59505 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
59506 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
59507 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
59508 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
59509 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
59510 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
59511 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
59512 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
59513 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
59514 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
59515 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
59516 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
59517 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59518 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
59519 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
59520 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
59521 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59522 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59523 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59524 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59525 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
59526 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
59527 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
59528 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
59529 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59530 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
59531 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
59532 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
59533 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
59534 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
59535 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
59536 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
59537 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
59538 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
59539 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
59540 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
59541 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
59542 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
59543 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
59544 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
59545 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
59546 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
59547 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
59548 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
59549 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
59550 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
59551 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
59552 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59553 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
59554 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
59555 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
59556 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
59557 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
59558 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
59559 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
59560 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
59561 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
59562 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
59563 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59564 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
59565 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
59566 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
59567 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
59568 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
59569 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
59570 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
59571 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
59572 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59573 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
59574 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
59575 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
59576 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
59577 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
59578 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
59579 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
59580 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
59581 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
59582 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
59583 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
59584 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
59585 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59586 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
59587 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
59588 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59589 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
59590 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
59591 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
59592 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
59593 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
59594 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
59595 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
59596 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
59597 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
59598 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59599 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
59600 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
59601 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
59602 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
59603 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
59604 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
59605 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
59606 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
59607 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59608 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
59609 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
59610 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
59611 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
59612 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
59613 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59614 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
59615 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
59616 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
59617 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59618 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
59619 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59620 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59621 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59622 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59623 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
59624 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59625 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59626 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
59627 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59628 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
59629 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59630 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59631 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59632 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59633 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
59634 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59635 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59636 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59637 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59638 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
59639 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59640 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
59641 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
59642 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
59643 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
59644 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
59645 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
59646 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
59647 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
59648 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59649 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59650 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59651 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59652 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
59653 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59654 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59655 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59656 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59657 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
59658 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
59659 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59660 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
59661 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59662 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
59663 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
59664 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
59665 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
59666 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
59667 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
59668 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
59669 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
59670 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
59671 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
59672 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
59673 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
59674 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59675 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59676 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
59677 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59678 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
59679 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59680 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
59681 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
59682 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
59683 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
59684 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
59685 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
59686 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59687 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59688 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59689 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
59690 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59691 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59692 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59693 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59694 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59695 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
59696 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
59697 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
59698 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
59699 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
59700 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59701 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
59702 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
59703 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
59704 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
59705 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
59706 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
59707 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59708 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
59709 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
59710 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
59711 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
59712 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
59713 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
59714 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
59715 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
59716 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
59717 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
59718 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
59719 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
59720 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59721 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
59722 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59723 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
59724 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59725 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
59726 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
59727 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
59728 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
59729 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
59730 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
59731 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59732 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
59733 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
59734 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
59735 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
59736 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
59737 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59738 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
59739 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
59740 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59741 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
59742 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
59743 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
59744 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
59745 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
59746 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
59747 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
59748 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
59749 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
59750 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
59751 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
59752 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59753 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
59754 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
59755 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
59756 { (char *)"Control_RemoveMnemonics", (PyCFunction) _wrap_Control_RemoveMnemonics, METH_VARARGS | METH_KEYWORDS, NULL},
59757 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
59758 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
59759 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
59760 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59761 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
59762 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59763 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
59764 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59765 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59766 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59767 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
59768 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
59769 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
59770 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
59771 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
59772 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
59773 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59774 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
59775 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59776 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
59777 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
59778 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
59779 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
59780 { (char *)"new_SizerFlags", (PyCFunction) _wrap_new_SizerFlags, METH_VARARGS | METH_KEYWORDS, NULL},
59781 { (char *)"delete_SizerFlags", (PyCFunction)_wrap_delete_SizerFlags, METH_O, NULL},
59782 { (char *)"SizerFlags_Proportion", (PyCFunction) _wrap_SizerFlags_Proportion, METH_VARARGS | METH_KEYWORDS, NULL},
59783 { (char *)"SizerFlags_Align", (PyCFunction) _wrap_SizerFlags_Align, METH_VARARGS | METH_KEYWORDS, NULL},
59784 { (char *)"SizerFlags_Expand", (PyCFunction)_wrap_SizerFlags_Expand, METH_O, NULL},
59785 { (char *)"SizerFlags_Centre", (PyCFunction)_wrap_SizerFlags_Centre, METH_O, NULL},
59786 { (char *)"SizerFlags_Center", (PyCFunction)_wrap_SizerFlags_Center, METH_O, NULL},
59787 { (char *)"SizerFlags_Left", (PyCFunction)_wrap_SizerFlags_Left, METH_O, NULL},
59788 { (char *)"SizerFlags_Right", (PyCFunction)_wrap_SizerFlags_Right, METH_O, NULL},
59789 { (char *)"SizerFlags_Top", (PyCFunction)_wrap_SizerFlags_Top, METH_O, NULL},
59790 { (char *)"SizerFlags_Bottom", (PyCFunction)_wrap_SizerFlags_Bottom, METH_O, NULL},
59791 { (char *)"SizerFlags_Shaped", (PyCFunction)_wrap_SizerFlags_Shaped, METH_O, NULL},
59792 { (char *)"SizerFlags_FixedMinSize", (PyCFunction)_wrap_SizerFlags_FixedMinSize, METH_O, NULL},
59793 { (char *)"SizerFlags_Border", (PyCFunction) _wrap_SizerFlags_Border, METH_VARARGS | METH_KEYWORDS, NULL},
59794 { (char *)"SizerFlags_DoubleBorder", (PyCFunction) _wrap_SizerFlags_DoubleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59795 { (char *)"SizerFlags_TripleBorder", (PyCFunction) _wrap_SizerFlags_TripleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59796 { (char *)"SizerFlags_HorzBorder", (PyCFunction)_wrap_SizerFlags_HorzBorder, METH_O, NULL},
59797 { (char *)"SizerFlags_DoubleHorzBorder", (PyCFunction)_wrap_SizerFlags_DoubleHorzBorder, METH_O, NULL},
59798 { (char *)"SizerFlags_GetDefaultBorder", (PyCFunction)_wrap_SizerFlags_GetDefaultBorder, METH_NOARGS, NULL},
59799 { (char *)"SizerFlags_GetProportion", (PyCFunction)_wrap_SizerFlags_GetProportion, METH_O, NULL},
59800 { (char *)"SizerFlags_GetFlags", (PyCFunction)_wrap_SizerFlags_GetFlags, METH_O, NULL},
59801 { (char *)"SizerFlags_GetBorderInPixels", (PyCFunction)_wrap_SizerFlags_GetBorderInPixels, METH_O, NULL},
59802 { (char *)"SizerFlags_swigregister", SizerFlags_swigregister, METH_VARARGS, NULL},
59803 { (char *)"SizerFlags_swiginit", SizerFlags_swiginit, METH_VARARGS, NULL},
59804 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
59805 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
59806 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59807 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59808 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59809 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
59810 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
59811 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
59812 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
59813 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59814 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
59815 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
59816 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
59817 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
59818 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
59819 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
59820 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
59821 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
59822 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
59823 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
59824 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
59825 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
59826 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
59827 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59828 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
59829 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59830 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
59831 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
59832 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
59833 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
59834 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59835 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59836 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59837 { (char *)"SizerItem_AssignWindow", (PyCFunction) _wrap_SizerItem_AssignWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59838 { (char *)"SizerItem_AssignSizer", (PyCFunction) _wrap_SizerItem_AssignSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59839 { (char *)"SizerItem_AssignSpacer", (PyCFunction) _wrap_SizerItem_AssignSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59840 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59841 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
59842 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
59843 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
59844 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
59845 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
59846 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
59847 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
59848 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59849 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59850 { (char *)"Sizer_AddF", (PyCFunction) _wrap_Sizer_AddF, METH_VARARGS | METH_KEYWORDS, NULL},
59851 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59852 { (char *)"Sizer_InsertF", (PyCFunction) _wrap_Sizer_InsertF, METH_VARARGS | METH_KEYWORDS, NULL},
59853 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59854 { (char *)"Sizer_PrependF", (PyCFunction) _wrap_Sizer_PrependF, METH_VARARGS | METH_KEYWORDS, NULL},
59855 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59856 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
59857 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
59858 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59859 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
59860 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59861 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
59862 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59863 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
59864 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59865 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59866 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59867 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59868 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59869 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
59870 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
59871 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
59872 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
59873 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
59874 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
59875 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
59876 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
59877 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59878 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59879 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
59880 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
59881 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
59882 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59883 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
59884 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
59885 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
59886 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
59887 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59888 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
59889 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
59890 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59891 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
59892 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
59893 { (char *)"BoxSizer_IsVertical", (PyCFunction)_wrap_BoxSizer_IsVertical, METH_O, NULL},
59894 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
59895 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
59896 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59897 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
59898 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
59899 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
59900 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59901 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
59902 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
59903 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
59904 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
59905 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
59906 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
59907 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
59908 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
59909 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
59910 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
59911 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59912 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59913 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59914 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59915 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59916 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59917 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
59918 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
59919 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
59920 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
59921 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
59922 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
59923 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
59924 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
59925 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
59926 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
59927 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59928 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59929 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
59930 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
59931 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
59932 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
59933 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
59934 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
59935 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
59936 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
59937 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59938 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
59939 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
59940 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
59941 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
59942 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
59943 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59944 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59945 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59946 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
59947 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
59948 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
59949 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59950 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
59951 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
59952 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
59953 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
59954 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
59955 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59956 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59957 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59958 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
59959 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
59960 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
59961 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
59962 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
59963 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59964 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59965 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59966 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
59967 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
59968 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
59969 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59970 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
59971 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
59972 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
59973 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
59974 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59975 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
59976 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
59977 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59978 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59979 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59980 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59981 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
59982 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59983 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
59984 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
59985 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
59986 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
59987 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
59988 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59989 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59990 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
59991 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
59992 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
59993 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
59994 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59995 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
59996 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
59997 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
59998 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
59999 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
60000 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
60001 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
60002 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
60003 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
60004 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
60005 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
60006 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
60007 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
60008 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
60009 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
60010 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
60011 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
60012 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
60013 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
60014 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
60015 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
60016 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
60017 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
60018 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
60019 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
60020 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
60021 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
60022 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
60023 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
60024 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
60025 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
60026 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
60027 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
60028 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
60029 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
60030 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
60031 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
60032 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
60033 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
60034 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
60035 { NULL, NULL, 0, NULL }
60036 };
60037
60038
60039 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
60040
60041 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
60042 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
60043 }
60044 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
60045 return (void *)((wxEvent *) ((wxMenuEvent *) x));
60046 }
60047 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
60048 return (void *)((wxEvent *) ((wxCloseEvent *) x));
60049 }
60050 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
60051 return (void *)((wxEvent *) ((wxMouseEvent *) x));
60052 }
60053 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
60054 return (void *)((wxEvent *) ((wxEraseEvent *) x));
60055 }
60056 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
60057 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
60058 }
60059 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
60060 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
60061 }
60062 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
60063 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
60064 }
60065 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
60066 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
60067 }
60068 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
60069 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
60070 }
60071 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
60072 return (void *)((wxEvent *) ((wxPyEvent *) x));
60073 }
60074 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
60075 return (void *)((wxEvent *) ((wxIdleEvent *) x));
60076 }
60077 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
60078 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
60079 }
60080 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
60081 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
60082 }
60083 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
60084 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
60085 }
60086 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
60087 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
60088 }
60089 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
60090 return (void *)((wxEvent *) ((wxActivateEvent *) x));
60091 }
60092 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
60093 return (void *)((wxEvent *) ((wxSizeEvent *) x));
60094 }
60095 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
60096 return (void *)((wxEvent *) ((wxMoveEvent *) x));
60097 }
60098 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
60099 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
60100 }
60101 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
60102 return (void *)((wxEvent *) ((wxPaintEvent *) x));
60103 }
60104 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
60105 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
60106 }
60107 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
60108 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
60109 }
60110 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
60111 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
60112 }
60113 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
60114 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
60115 }
60116 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
60117 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
60118 }
60119 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
60120 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
60121 }
60122 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
60123 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
60124 }
60125 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
60126 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
60127 }
60128 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
60129 return (void *)((wxEvent *) ((wxFocusEvent *) x));
60130 }
60131 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
60132 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
60133 }
60134 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
60135 return (void *)((wxEvent *) ((wxShowEvent *) x));
60136 }
60137 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
60138 return (void *)((wxEvent *) ((wxCommandEvent *) x));
60139 }
60140 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
60141 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
60142 }
60143 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
60144 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60145 }
60146 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
60147 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
60148 }
60149 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
60150 return (void *)((wxEvent *) ((wxKeyEvent *) x));
60151 }
60152 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
60153 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
60154 }
60155 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
60156 return (void *)((wxValidator *) ((wxPyValidator *) x));
60157 }
60158 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
60159 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
60160 }
60161 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
60162 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
60163 }
60164 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
60165 return (void *)((wxObject *) ((wxSizerItem *) x));
60166 }
60167 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
60168 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
60169 }
60170 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
60171 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
60172 }
60173 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
60174 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
60175 }
60176 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
60177 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
60178 }
60179 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
60180 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
60181 }
60182 static void *_p_wxSizerTo_p_wxObject(void *x) {
60183 return (void *)((wxObject *) ((wxSizer *) x));
60184 }
60185 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
60186 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
60187 }
60188 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
60189 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
60190 }
60191 static void *_p_wxEventTo_p_wxObject(void *x) {
60192 return (void *)((wxObject *) ((wxEvent *) x));
60193 }
60194 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
60195 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
60196 }
60197 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
60198 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
60199 }
60200 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
60201 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
60202 }
60203 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
60204 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
60205 }
60206 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
60207 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
60208 }
60209 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
60210 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
60211 }
60212 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
60213 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
60214 }
60215 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
60216 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
60217 }
60218 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
60219 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
60220 }
60221 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
60222 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
60223 }
60224 static void *_p_wxControlTo_p_wxObject(void *x) {
60225 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
60226 }
60227 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
60228 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
60229 }
60230 static void *_p_wxFSFileTo_p_wxObject(void *x) {
60231 return (void *)((wxObject *) ((wxFSFile *) x));
60232 }
60233 static void *_p_wxPySizerTo_p_wxObject(void *x) {
60234 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
60235 }
60236 static void *_p_wxPyEventTo_p_wxObject(void *x) {
60237 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
60238 }
60239 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
60240 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
60241 }
60242 static void *_p_wxShowEventTo_p_wxObject(void *x) {
60243 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
60244 }
60245 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
60246 return (void *)((wxObject *) ((wxMenuItem *) x));
60247 }
60248 static void *_p_wxDateEventTo_p_wxObject(void *x) {
60249 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
60250 }
60251 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
60252 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
60253 }
60254 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
60255 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
60256 }
60257 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
60258 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
60259 }
60260 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
60261 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
60262 }
60263 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
60264 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
60265 }
60266 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
60267 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
60268 }
60269 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
60270 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
60271 }
60272 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
60273 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
60274 }
60275 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
60276 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
60277 }
60278 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
60279 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
60280 }
60281 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
60282 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
60283 }
60284 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
60285 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
60286 }
60287 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
60288 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
60289 }
60290 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
60291 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
60292 }
60293 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
60294 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
60295 }
60296 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
60297 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
60298 }
60299 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
60300 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
60301 }
60302 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
60303 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
60304 }
60305 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
60306 return (void *)((wxObject *) ((wxImageHandler *) x));
60307 }
60308 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
60309 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
60310 }
60311 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
60312 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
60313 }
60314 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
60315 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
60316 }
60317 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
60318 return (void *)((wxObject *) ((wxEvtHandler *) x));
60319 }
60320 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
60321 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
60322 }
60323 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
60324 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
60325 }
60326 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
60327 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
60328 }
60329 static void *_p_wxImageTo_p_wxObject(void *x) {
60330 return (void *)((wxObject *) ((wxImage *) x));
60331 }
60332 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
60333 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
60334 }
60335 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
60336 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60337 }
60338 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
60339 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
60340 }
60341 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
60342 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
60343 }
60344 static void *_p_wxWindowTo_p_wxObject(void *x) {
60345 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
60346 }
60347 static void *_p_wxMenuTo_p_wxObject(void *x) {
60348 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
60349 }
60350 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
60351 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
60352 }
60353 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
60354 return (void *)((wxObject *) ((wxFileSystem *) x));
60355 }
60356 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
60357 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
60358 }
60359 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
60360 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
60361 }
60362 static void *_p_wxPyAppTo_p_wxObject(void *x) {
60363 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
60364 }
60365 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
60366 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
60367 }
60368 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
60369 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
60370 }
60371 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
60372 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
60373 }
60374 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
60375 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
60376 }
60377 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
60378 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
60379 }
60380 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
60381 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
60382 }
60383 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
60384 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
60385 }
60386 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
60387 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
60388 }
60389 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
60390 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
60391 }
60392 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
60393 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
60394 }
60395 static void *_p_wxValidatorTo_p_wxObject(void *x) {
60396 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
60397 }
60398 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
60399 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
60400 }
60401 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
60402 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
60403 }
60404 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
60405 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
60406 }
60407 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
60408 return (void *)((wxControl *) ((wxControlWithItems *) x));
60409 }
60410 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
60411 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
60412 }
60413 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
60414 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
60415 }
60416 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
60417 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
60418 }
60419 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
60420 return (void *)((wxSizer *) ((wxBoxSizer *) x));
60421 }
60422 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
60423 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
60424 }
60425 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
60426 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
60427 }
60428 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
60429 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
60430 }
60431 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
60432 return (void *)((wxSizer *) ((wxGridSizer *) x));
60433 }
60434 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
60435 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
60436 }
60437 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
60438 return (void *)((wxSizer *) ((wxPySizer *) x));
60439 }
60440 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
60441 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
60442 }
60443 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
60444 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
60445 }
60446 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
60447 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
60448 }
60449 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
60450 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
60451 }
60452 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
60453 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
60454 }
60455 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
60456 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
60457 }
60458 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
60459 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
60460 }
60461 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
60462 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
60463 }
60464 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
60465 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
60466 }
60467 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
60468 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
60469 }
60470 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
60471 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
60472 }
60473 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
60474 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
60475 }
60476 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
60477 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
60478 }
60479 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
60480 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
60481 }
60482 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
60483 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
60484 }
60485 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
60486 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
60487 }
60488 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
60489 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
60490 }
60491 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
60492 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
60493 }
60494 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
60495 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
60496 }
60497 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
60498 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
60499 }
60500 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
60501 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
60502 }
60503 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
60504 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
60505 }
60506 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
60507 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
60508 }
60509 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
60510 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
60511 }
60512 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
60513 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
60514 }
60515 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
60516 return (void *)((wxEvtHandler *) ((wxWindow *) x));
60517 }
60518 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
60519 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
60520 }
60521 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
60522 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
60523 }
60524 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
60525 return (void *)((wxEvtHandler *) ((wxValidator *) x));
60526 }
60527 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
60528 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
60529 }
60530 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
60531 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
60532 }
60533 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
60534 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
60535 }
60536 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
60537 return (void *)((wxEvtHandler *) ((wxMenu *) x));
60538 }
60539 static void *_p_wxControlTo_p_wxWindow(void *x) {
60540 return (void *)((wxWindow *) ((wxControl *) x));
60541 }
60542 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
60543 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
60544 }
60545 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
60546 return (void *)((wxWindow *) ((wxMenuBar *) x));
60547 }
60548 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
60549 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
60550 }
60551 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
60552 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
60553 }
60554 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
60555 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
60556 }
60557 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
60558 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
60559 }
60560 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
60561 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
60562 }
60563 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
60564 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
60565 }
60566 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
60567 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60568 }
60569 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
60570 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
60571 }
60572 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
60573 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
60574 }
60575 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
60576 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
60577 }
60578 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
60579 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
60580 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};
60581 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
60582 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
60583 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
60584 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
60585 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
60586 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
60587 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
60588 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
60589 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
60590 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
60591 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
60592 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
60593 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
60594 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
60595 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
60596 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
60597 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
60598 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
60599 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
60600 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
60601 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
60602 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
60603 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
60604 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
60605 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
60606 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
60607 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
60608 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
60609 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
60610 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
60611 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
60612 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
60613 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
60614 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
60615 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
60616 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", "wxEventBlocker *", 0, 0, (void*)0, 0};
60617 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
60618 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
60619 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
60620 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
60621 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
60622 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
60623 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
60624 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
60625 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
60626 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
60627 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
60628 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
60629 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
60630 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
60631 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
60632 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
60633 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
60634 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
60635 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
60636 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
60637 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
60638 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
60639 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
60640 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
60641 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
60642 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
60643 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
60644 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
60645 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
60646 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
60647 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
60648 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
60649 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
60650 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
60651 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
60652 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
60653 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
60654 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
60655 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
60656 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
60657 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
60658 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
60659 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
60660 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
60661 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
60662 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
60663 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
60664 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
60665 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
60666 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
60667 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
60668 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
60669 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
60670 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
60671 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
60672 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
60673 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
60674 static swig_type_info _swigt__p_wxPosition = {"_p_wxPosition", "wxPosition *", 0, 0, (void*)0, 0};
60675 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
60676 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
60677 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
60678 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
60679 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
60680 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
60681 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
60682 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
60683 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
60684 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
60685 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
60686 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
60687 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
60688 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
60689 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
60690 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
60691 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
60692 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
60693 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
60694 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
60695 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
60696 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
60697 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
60698 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
60699 static swig_type_info _swigt__p_wxSizerFlags = {"_p_wxSizerFlags", "wxSizerFlags *", 0, 0, (void*)0, 0};
60700 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
60701 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
60702 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
60703 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
60704 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
60705 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
60706 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
60707 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
60708 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
60709 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
60710 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
60711 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
60712 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
60713 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
60714 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
60715 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
60716
60717 static swig_type_info *swig_type_initial[] = {
60718 &_swigt__p_buffer,
60719 &_swigt__p_char,
60720 &_swigt__p_form_ops_t,
60721 &_swigt__p_int,
60722 &_swigt__p_long,
60723 &_swigt__p_unsigned_char,
60724 &_swigt__p_unsigned_int,
60725 &_swigt__p_unsigned_long,
60726 &_swigt__p_wxANIHandler,
60727 &_swigt__p_wxAcceleratorEntry,
60728 &_swigt__p_wxAcceleratorTable,
60729 &_swigt__p_wxActivateEvent,
60730 &_swigt__p_wxAppTraits,
60731 &_swigt__p_wxArrayString,
60732 &_swigt__p_wxBMPHandler,
60733 &_swigt__p_wxBitmap,
60734 &_swigt__p_wxBoxSizer,
60735 &_swigt__p_wxButton,
60736 &_swigt__p_wxCURHandler,
60737 &_swigt__p_wxCaret,
60738 &_swigt__p_wxChildFocusEvent,
60739 &_swigt__p_wxClipboardTextEvent,
60740 &_swigt__p_wxCloseEvent,
60741 &_swigt__p_wxColour,
60742 &_swigt__p_wxCommandEvent,
60743 &_swigt__p_wxContextMenuEvent,
60744 &_swigt__p_wxControl,
60745 &_swigt__p_wxControlWithItems,
60746 &_swigt__p_wxCursor,
60747 &_swigt__p_wxDC,
60748 &_swigt__p_wxDateEvent,
60749 &_swigt__p_wxDateTime,
60750 &_swigt__p_wxDisplayChangedEvent,
60751 &_swigt__p_wxDouble,
60752 &_swigt__p_wxDropFilesEvent,
60753 &_swigt__p_wxDuplexMode,
60754 &_swigt__p_wxEraseEvent,
60755 &_swigt__p_wxEvent,
60756 &_swigt__p_wxEventBlocker,
60757 &_swigt__p_wxEventLoop,
60758 &_swigt__p_wxEventLoopActivator,
60759 &_swigt__p_wxEvtHandler,
60760 &_swigt__p_wxFSFile,
60761 &_swigt__p_wxFileSystem,
60762 &_swigt__p_wxFileSystemHandler,
60763 &_swigt__p_wxFlexGridSizer,
60764 &_swigt__p_wxFocusEvent,
60765 &_swigt__p_wxFont,
60766 &_swigt__p_wxFrame,
60767 &_swigt__p_wxGBPosition,
60768 &_swigt__p_wxGBSizerItem,
60769 &_swigt__p_wxGBSpan,
60770 &_swigt__p_wxGIFHandler,
60771 &_swigt__p_wxGridBagSizer,
60772 &_swigt__p_wxGridSizer,
60773 &_swigt__p_wxHelpEvent__Origin,
60774 &_swigt__p_wxICOHandler,
60775 &_swigt__p_wxIconizeEvent,
60776 &_swigt__p_wxIdleEvent,
60777 &_swigt__p_wxImage,
60778 &_swigt__p_wxImageHandler,
60779 &_swigt__p_wxImageHistogram,
60780 &_swigt__p_wxImage_HSVValue,
60781 &_swigt__p_wxImage_RGBValue,
60782 &_swigt__p_wxIndividualLayoutConstraint,
60783 &_swigt__p_wxInitDialogEvent,
60784 &_swigt__p_wxInputStream,
60785 &_swigt__p_wxInternetFSHandler,
60786 &_swigt__p_wxItemContainer,
60787 &_swigt__p_wxJPEGHandler,
60788 &_swigt__p_wxKeyEvent,
60789 &_swigt__p_wxLayoutConstraints,
60790 &_swigt__p_wxMaximizeEvent,
60791 &_swigt__p_wxMemoryFSHandler,
60792 &_swigt__p_wxMenu,
60793 &_swigt__p_wxMenuBar,
60794 &_swigt__p_wxMenuBarBase,
60795 &_swigt__p_wxMenuEvent,
60796 &_swigt__p_wxMenuItem,
60797 &_swigt__p_wxMouseCaptureChangedEvent,
60798 &_swigt__p_wxMouseCaptureLostEvent,
60799 &_swigt__p_wxMouseEvent,
60800 &_swigt__p_wxMoveEvent,
60801 &_swigt__p_wxNavigationKeyEvent,
60802 &_swigt__p_wxNcPaintEvent,
60803 &_swigt__p_wxNotifyEvent,
60804 &_swigt__p_wxObject,
60805 &_swigt__p_wxOutputStream,
60806 &_swigt__p_wxPCXHandler,
60807 &_swigt__p_wxPNGHandler,
60808 &_swigt__p_wxPNMHandler,
60809 &_swigt__p_wxPaintEvent,
60810 &_swigt__p_wxPaletteChangedEvent,
60811 &_swigt__p_wxPaperSize,
60812 &_swigt__p_wxPoint,
60813 &_swigt__p_wxPoint2D,
60814 &_swigt__p_wxPosition,
60815 &_swigt__p_wxPropagateOnce,
60816 &_swigt__p_wxPropagationDisabler,
60817 &_swigt__p_wxPyApp,
60818 &_swigt__p_wxPyCommandEvent,
60819 &_swigt__p_wxPyDropTarget,
60820 &_swigt__p_wxPyEvent,
60821 &_swigt__p_wxPyFileSystemHandler,
60822 &_swigt__p_wxPyImageHandler,
60823 &_swigt__p_wxPyInputStream,
60824 &_swigt__p_wxPySizer,
60825 &_swigt__p_wxPyValidator,
60826 &_swigt__p_wxQuantize,
60827 &_swigt__p_wxQueryNewPaletteEvent,
60828 &_swigt__p_wxRealPoint,
60829 &_swigt__p_wxRect,
60830 &_swigt__p_wxRect2D,
60831 &_swigt__p_wxRegion,
60832 &_swigt__p_wxScrollEvent,
60833 &_swigt__p_wxScrollWinEvent,
60834 &_swigt__p_wxSetCursorEvent,
60835 &_swigt__p_wxShowEvent,
60836 &_swigt__p_wxSize,
60837 &_swigt__p_wxSizeEvent,
60838 &_swigt__p_wxSizer,
60839 &_swigt__p_wxSizerFlags,
60840 &_swigt__p_wxSizerItem,
60841 &_swigt__p_wxStaticBox,
60842 &_swigt__p_wxStaticBoxSizer,
60843 &_swigt__p_wxStdDialogButtonSizer,
60844 &_swigt__p_wxSysColourChangedEvent,
60845 &_swigt__p_wxTGAHandler,
60846 &_swigt__p_wxTIFFHandler,
60847 &_swigt__p_wxToolTip,
60848 &_swigt__p_wxUpdateUIEvent,
60849 &_swigt__p_wxValidator,
60850 &_swigt__p_wxVisualAttributes,
60851 &_swigt__p_wxWindow,
60852 &_swigt__p_wxWindowCreateEvent,
60853 &_swigt__p_wxWindowDestroyEvent,
60854 &_swigt__p_wxXPMHandler,
60855 &_swigt__p_wxZipFSHandler,
60856 };
60857
60858 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
60859 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
60860 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
60861 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
60862 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
60863 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
60864 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
60865 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
60866 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
60867 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
60868 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
60869 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
60870 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
60871 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
60872 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}};
60873 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
60874 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}};
60875 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
60876 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}};
60877 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
60878 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60879 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
60880 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
60881 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
60882 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}};
60883 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60884 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}};
60885 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
60886 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
60887 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
60888 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
60889 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
60890 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60891 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
60892 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
60893 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
60894 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
60895 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}};
60896 static swig_cast_info _swigc__p_wxEventBlocker[] = { {&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
60897 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
60898 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
60899 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
60900 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
60901 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
60902 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}};
60903 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}};
60904 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60905 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
60906 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
60907 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
60908 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
60909 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
60910 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
60911 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
60912 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}};
60913 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
60914 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}};
60915 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60916 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
60917 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
60918 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
60919 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
60920 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
60921 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
60922 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
60923 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
60924 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
60925 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60926 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}};
60927 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
60928 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60929 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
60930 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60931 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60932 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
60933 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
60934 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
60935 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60936 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
60937 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60938 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
60939 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
60940 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
60941 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60942 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60943 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
60944 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
60945 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
60946 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
60947 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
60948 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
60949 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60950 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60951 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
60952 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
60953 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
60954 static swig_cast_info _swigc__p_wxPosition[] = { {&_swigt__p_wxPosition, 0, 0, 0},{0, 0, 0, 0}};
60955 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
60956 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
60957 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
60958 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
60959 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
60960 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
60961 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
60962 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
60963 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
60964 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
60965 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
60966 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
60967 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
60968 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
60969 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
60970 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
60971 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
60972 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
60973 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
60974 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
60975 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
60976 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
60977 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60978 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}};
60979 static swig_cast_info _swigc__p_wxSizerFlags[] = { {&_swigt__p_wxSizerFlags, 0, 0, 0},{0, 0, 0, 0}};
60980 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}};
60981 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
60982 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
60983 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
60984 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60985 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
60986 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
60987 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
60988 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
60989 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}};
60990 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
60991 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}};
60992 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
60993 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
60994 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
60995 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60996
60997 static swig_cast_info *swig_cast_initial[] = {
60998 _swigc__p_buffer,
60999 _swigc__p_char,
61000 _swigc__p_form_ops_t,
61001 _swigc__p_int,
61002 _swigc__p_long,
61003 _swigc__p_unsigned_char,
61004 _swigc__p_unsigned_int,
61005 _swigc__p_unsigned_long,
61006 _swigc__p_wxANIHandler,
61007 _swigc__p_wxAcceleratorEntry,
61008 _swigc__p_wxAcceleratorTable,
61009 _swigc__p_wxActivateEvent,
61010 _swigc__p_wxAppTraits,
61011 _swigc__p_wxArrayString,
61012 _swigc__p_wxBMPHandler,
61013 _swigc__p_wxBitmap,
61014 _swigc__p_wxBoxSizer,
61015 _swigc__p_wxButton,
61016 _swigc__p_wxCURHandler,
61017 _swigc__p_wxCaret,
61018 _swigc__p_wxChildFocusEvent,
61019 _swigc__p_wxClipboardTextEvent,
61020 _swigc__p_wxCloseEvent,
61021 _swigc__p_wxColour,
61022 _swigc__p_wxCommandEvent,
61023 _swigc__p_wxContextMenuEvent,
61024 _swigc__p_wxControl,
61025 _swigc__p_wxControlWithItems,
61026 _swigc__p_wxCursor,
61027 _swigc__p_wxDC,
61028 _swigc__p_wxDateEvent,
61029 _swigc__p_wxDateTime,
61030 _swigc__p_wxDisplayChangedEvent,
61031 _swigc__p_wxDouble,
61032 _swigc__p_wxDropFilesEvent,
61033 _swigc__p_wxDuplexMode,
61034 _swigc__p_wxEraseEvent,
61035 _swigc__p_wxEvent,
61036 _swigc__p_wxEventBlocker,
61037 _swigc__p_wxEventLoop,
61038 _swigc__p_wxEventLoopActivator,
61039 _swigc__p_wxEvtHandler,
61040 _swigc__p_wxFSFile,
61041 _swigc__p_wxFileSystem,
61042 _swigc__p_wxFileSystemHandler,
61043 _swigc__p_wxFlexGridSizer,
61044 _swigc__p_wxFocusEvent,
61045 _swigc__p_wxFont,
61046 _swigc__p_wxFrame,
61047 _swigc__p_wxGBPosition,
61048 _swigc__p_wxGBSizerItem,
61049 _swigc__p_wxGBSpan,
61050 _swigc__p_wxGIFHandler,
61051 _swigc__p_wxGridBagSizer,
61052 _swigc__p_wxGridSizer,
61053 _swigc__p_wxHelpEvent__Origin,
61054 _swigc__p_wxICOHandler,
61055 _swigc__p_wxIconizeEvent,
61056 _swigc__p_wxIdleEvent,
61057 _swigc__p_wxImage,
61058 _swigc__p_wxImageHandler,
61059 _swigc__p_wxImageHistogram,
61060 _swigc__p_wxImage_HSVValue,
61061 _swigc__p_wxImage_RGBValue,
61062 _swigc__p_wxIndividualLayoutConstraint,
61063 _swigc__p_wxInitDialogEvent,
61064 _swigc__p_wxInputStream,
61065 _swigc__p_wxInternetFSHandler,
61066 _swigc__p_wxItemContainer,
61067 _swigc__p_wxJPEGHandler,
61068 _swigc__p_wxKeyEvent,
61069 _swigc__p_wxLayoutConstraints,
61070 _swigc__p_wxMaximizeEvent,
61071 _swigc__p_wxMemoryFSHandler,
61072 _swigc__p_wxMenu,
61073 _swigc__p_wxMenuBar,
61074 _swigc__p_wxMenuBarBase,
61075 _swigc__p_wxMenuEvent,
61076 _swigc__p_wxMenuItem,
61077 _swigc__p_wxMouseCaptureChangedEvent,
61078 _swigc__p_wxMouseCaptureLostEvent,
61079 _swigc__p_wxMouseEvent,
61080 _swigc__p_wxMoveEvent,
61081 _swigc__p_wxNavigationKeyEvent,
61082 _swigc__p_wxNcPaintEvent,
61083 _swigc__p_wxNotifyEvent,
61084 _swigc__p_wxObject,
61085 _swigc__p_wxOutputStream,
61086 _swigc__p_wxPCXHandler,
61087 _swigc__p_wxPNGHandler,
61088 _swigc__p_wxPNMHandler,
61089 _swigc__p_wxPaintEvent,
61090 _swigc__p_wxPaletteChangedEvent,
61091 _swigc__p_wxPaperSize,
61092 _swigc__p_wxPoint,
61093 _swigc__p_wxPoint2D,
61094 _swigc__p_wxPosition,
61095 _swigc__p_wxPropagateOnce,
61096 _swigc__p_wxPropagationDisabler,
61097 _swigc__p_wxPyApp,
61098 _swigc__p_wxPyCommandEvent,
61099 _swigc__p_wxPyDropTarget,
61100 _swigc__p_wxPyEvent,
61101 _swigc__p_wxPyFileSystemHandler,
61102 _swigc__p_wxPyImageHandler,
61103 _swigc__p_wxPyInputStream,
61104 _swigc__p_wxPySizer,
61105 _swigc__p_wxPyValidator,
61106 _swigc__p_wxQuantize,
61107 _swigc__p_wxQueryNewPaletteEvent,
61108 _swigc__p_wxRealPoint,
61109 _swigc__p_wxRect,
61110 _swigc__p_wxRect2D,
61111 _swigc__p_wxRegion,
61112 _swigc__p_wxScrollEvent,
61113 _swigc__p_wxScrollWinEvent,
61114 _swigc__p_wxSetCursorEvent,
61115 _swigc__p_wxShowEvent,
61116 _swigc__p_wxSize,
61117 _swigc__p_wxSizeEvent,
61118 _swigc__p_wxSizer,
61119 _swigc__p_wxSizerFlags,
61120 _swigc__p_wxSizerItem,
61121 _swigc__p_wxStaticBox,
61122 _swigc__p_wxStaticBoxSizer,
61123 _swigc__p_wxStdDialogButtonSizer,
61124 _swigc__p_wxSysColourChangedEvent,
61125 _swigc__p_wxTGAHandler,
61126 _swigc__p_wxTIFFHandler,
61127 _swigc__p_wxToolTip,
61128 _swigc__p_wxUpdateUIEvent,
61129 _swigc__p_wxValidator,
61130 _swigc__p_wxVisualAttributes,
61131 _swigc__p_wxWindow,
61132 _swigc__p_wxWindowCreateEvent,
61133 _swigc__p_wxWindowDestroyEvent,
61134 _swigc__p_wxXPMHandler,
61135 _swigc__p_wxZipFSHandler,
61136 };
61137
61138
61139 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
61140
61141 static swig_const_info swig_const_table[] = {
61142 {0, 0, 0, 0.0, 0, 0}};
61143
61144 #ifdef __cplusplus
61145 }
61146 #endif
61147 /* -----------------------------------------------------------------------------
61148 * Type initialization:
61149 * This problem is tough by the requirement that no dynamic
61150 * memory is used. Also, since swig_type_info structures store pointers to
61151 * swig_cast_info structures and swig_cast_info structures store pointers back
61152 * to swig_type_info structures, we need some lookup code at initialization.
61153 * The idea is that swig generates all the structures that are needed.
61154 * The runtime then collects these partially filled structures.
61155 * The SWIG_InitializeModule function takes these initial arrays out of
61156 * swig_module, and does all the lookup, filling in the swig_module.types
61157 * array with the correct data and linking the correct swig_cast_info
61158 * structures together.
61159 *
61160 * The generated swig_type_info structures are assigned staticly to an initial
61161 * array. We just loop though that array, and handle each type individually.
61162 * First we lookup if this type has been already loaded, and if so, use the
61163 * loaded structure instead of the generated one. Then we have to fill in the
61164 * cast linked list. The cast data is initially stored in something like a
61165 * two-dimensional array. Each row corresponds to a type (there are the same
61166 * number of rows as there are in the swig_type_initial array). Each entry in
61167 * a column is one of the swig_cast_info structures for that type.
61168 * The cast_initial array is actually an array of arrays, because each row has
61169 * a variable number of columns. So to actually build the cast linked list,
61170 * we find the array of casts associated with the type, and loop through it
61171 * adding the casts to the list. The one last trick we need to do is making
61172 * sure the type pointer in the swig_cast_info struct is correct.
61173 *
61174 * First off, we lookup the cast->type name to see if it is already loaded.
61175 * There are three cases to handle:
61176 * 1) If the cast->type has already been loaded AND the type we are adding
61177 * casting info to has not been loaded (it is in this module), THEN we
61178 * replace the cast->type pointer with the type pointer that has already
61179 * been loaded.
61180 * 2) If BOTH types (the one we are adding casting info to, and the
61181 * cast->type) are loaded, THEN the cast info has already been loaded by
61182 * the previous module so we just ignore it.
61183 * 3) Finally, if cast->type has not already been loaded, then we add that
61184 * swig_cast_info to the linked list (because the cast->type) pointer will
61185 * be correct.
61186 * ----------------------------------------------------------------------------- */
61187
61188 #ifdef __cplusplus
61189 extern "C" {
61190 #if 0
61191 } /* c-mode */
61192 #endif
61193 #endif
61194
61195 #if 0
61196 #define SWIGRUNTIME_DEBUG
61197 #endif
61198
61199 SWIGRUNTIME void
61200 SWIG_InitializeModule(void *clientdata) {
61201 size_t i;
61202 swig_module_info *module_head;
61203 static int init_run = 0;
61204
61205 clientdata = clientdata;
61206
61207 if (init_run) return;
61208 init_run = 1;
61209
61210 /* Initialize the swig_module */
61211 swig_module.type_initial = swig_type_initial;
61212 swig_module.cast_initial = swig_cast_initial;
61213
61214 /* Try and load any already created modules */
61215 module_head = SWIG_GetModule(clientdata);
61216 if (module_head) {
61217 swig_module.next = module_head->next;
61218 module_head->next = &swig_module;
61219 } else {
61220 /* This is the first module loaded */
61221 swig_module.next = &swig_module;
61222 SWIG_SetModule(clientdata, &swig_module);
61223 }
61224
61225 /* Now work on filling in swig_module.types */
61226 #ifdef SWIGRUNTIME_DEBUG
61227 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
61228 #endif
61229 for (i = 0; i < swig_module.size; ++i) {
61230 swig_type_info *type = 0;
61231 swig_type_info *ret;
61232 swig_cast_info *cast;
61233
61234 #ifdef SWIGRUNTIME_DEBUG
61235 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
61236 #endif
61237
61238 /* if there is another module already loaded */
61239 if (swig_module.next != &swig_module) {
61240 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
61241 }
61242 if (type) {
61243 /* Overwrite clientdata field */
61244 #ifdef SWIGRUNTIME_DEBUG
61245 printf("SWIG_InitializeModule: found type %s\n", type->name);
61246 #endif
61247 if (swig_module.type_initial[i]->clientdata) {
61248 type->clientdata = swig_module.type_initial[i]->clientdata;
61249 #ifdef SWIGRUNTIME_DEBUG
61250 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
61251 #endif
61252 }
61253 } else {
61254 type = swig_module.type_initial[i];
61255 }
61256
61257 /* Insert casting types */
61258 cast = swig_module.cast_initial[i];
61259 while (cast->type) {
61260 /* Don't need to add information already in the list */
61261 ret = 0;
61262 #ifdef SWIGRUNTIME_DEBUG
61263 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
61264 #endif
61265 if (swig_module.next != &swig_module) {
61266 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
61267 #ifdef SWIGRUNTIME_DEBUG
61268 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
61269 #endif
61270 }
61271 if (ret) {
61272 if (type == swig_module.type_initial[i]) {
61273 #ifdef SWIGRUNTIME_DEBUG
61274 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
61275 #endif
61276 cast->type = ret;
61277 ret = 0;
61278 } else {
61279 /* Check for casting already in the list */
61280 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
61281 #ifdef SWIGRUNTIME_DEBUG
61282 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
61283 #endif
61284 if (!ocast) ret = 0;
61285 }
61286 }
61287
61288 if (!ret) {
61289 #ifdef SWIGRUNTIME_DEBUG
61290 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
61291 #endif
61292 if (type->cast) {
61293 type->cast->prev = cast;
61294 cast->next = type->cast;
61295 }
61296 type->cast = cast;
61297 }
61298 cast++;
61299 }
61300 /* Set entry in modules->types array equal to the type */
61301 swig_module.types[i] = type;
61302 }
61303 swig_module.types[i] = 0;
61304
61305 #ifdef SWIGRUNTIME_DEBUG
61306 printf("**** SWIG_InitializeModule: Cast List ******\n");
61307 for (i = 0; i < swig_module.size; ++i) {
61308 int j = 0;
61309 swig_cast_info *cast = swig_module.cast_initial[i];
61310 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
61311 while (cast->type) {
61312 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
61313 cast++;
61314 ++j;
61315 }
61316 printf("---- Total casts: %d\n",j);
61317 }
61318 printf("**** SWIG_InitializeModule: Cast List ******\n");
61319 #endif
61320 }
61321
61322 /* This function will propagate the clientdata field of type to
61323 * any new swig_type_info structures that have been added into the list
61324 * of equivalent types. It is like calling
61325 * SWIG_TypeClientData(type, clientdata) a second time.
61326 */
61327 SWIGRUNTIME void
61328 SWIG_PropagateClientData(void) {
61329 size_t i;
61330 swig_cast_info *equiv;
61331 static int init_run = 0;
61332
61333 if (init_run) return;
61334 init_run = 1;
61335
61336 for (i = 0; i < swig_module.size; i++) {
61337 if (swig_module.types[i]->clientdata) {
61338 equiv = swig_module.types[i]->cast;
61339 while (equiv) {
61340 if (!equiv->converter) {
61341 if (equiv->type && !equiv->type->clientdata)
61342 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
61343 }
61344 equiv = equiv->next;
61345 }
61346 }
61347 }
61348 }
61349
61350 #ifdef __cplusplus
61351 #if 0
61352 {
61353 /* c-mode */
61354 #endif
61355 }
61356 #endif
61357
61358
61359
61360 #ifdef __cplusplus
61361 extern "C" {
61362 #endif
61363
61364 /* Python-specific SWIG API */
61365 #define SWIG_newvarlink() SWIG_Python_newvarlink()
61366 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
61367 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
61368
61369 /* -----------------------------------------------------------------------------
61370 * global variable support code.
61371 * ----------------------------------------------------------------------------- */
61372
61373 typedef struct swig_globalvar {
61374 char *name; /* Name of global variable */
61375 PyObject *(*get_attr)(void); /* Return the current value */
61376 int (*set_attr)(PyObject *); /* Set the value */
61377 struct swig_globalvar *next;
61378 } swig_globalvar;
61379
61380 typedef struct swig_varlinkobject {
61381 PyObject_HEAD
61382 swig_globalvar *vars;
61383 } swig_varlinkobject;
61384
61385 SWIGINTERN PyObject *
61386 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
61387 return PyString_FromString("<Swig global variables>");
61388 }
61389
61390 SWIGINTERN PyObject *
61391 swig_varlink_str(swig_varlinkobject *v) {
61392 PyObject *str = PyString_FromString("(");
61393 swig_globalvar *var;
61394 for (var = v->vars; var; var=var->next) {
61395 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
61396 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
61397 }
61398 PyString_ConcatAndDel(&str,PyString_FromString(")"));
61399 return str;
61400 }
61401
61402 SWIGINTERN int
61403 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
61404 PyObject *str = swig_varlink_str(v);
61405 fprintf(fp,"Swig global variables ");
61406 fprintf(fp,"%s\n", PyString_AsString(str));
61407 Py_DECREF(str);
61408 return 0;
61409 }
61410
61411 SWIGINTERN void
61412 swig_varlink_dealloc(swig_varlinkobject *v) {
61413 swig_globalvar *var = v->vars;
61414 while (var) {
61415 swig_globalvar *n = var->next;
61416 free(var->name);
61417 free(var);
61418 var = n;
61419 }
61420 }
61421
61422 SWIGINTERN PyObject *
61423 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
61424 PyObject *res = NULL;
61425 swig_globalvar *var = v->vars;
61426 while (var) {
61427 if (strcmp(var->name,n) == 0) {
61428 res = (*var->get_attr)();
61429 break;
61430 }
61431 var = var->next;
61432 }
61433 if (res == NULL && !PyErr_Occurred()) {
61434 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
61435 }
61436 return res;
61437 }
61438
61439 SWIGINTERN int
61440 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
61441 int res = 1;
61442 swig_globalvar *var = v->vars;
61443 while (var) {
61444 if (strcmp(var->name,n) == 0) {
61445 res = (*var->set_attr)(p);
61446 break;
61447 }
61448 var = var->next;
61449 }
61450 if (res == 1 && !PyErr_Occurred()) {
61451 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
61452 }
61453 return res;
61454 }
61455
61456 SWIGINTERN PyTypeObject*
61457 swig_varlink_type(void) {
61458 static char varlink__doc__[] = "Swig var link object";
61459 static PyTypeObject varlink_type;
61460 static int type_init = 0;
61461 if (!type_init) {
61462 const PyTypeObject tmp
61463 = {
61464 PyObject_HEAD_INIT(NULL)
61465 0, /* Number of items in variable part (ob_size) */
61466 (char *)"swigvarlink", /* Type name (tp_name) */
61467 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
61468 0, /* Itemsize (tp_itemsize) */
61469 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
61470 (printfunc) swig_varlink_print, /* Print (tp_print) */
61471 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
61472 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
61473 0, /* tp_compare */
61474 (reprfunc) swig_varlink_repr, /* tp_repr */
61475 0, /* tp_as_number */
61476 0, /* tp_as_sequence */
61477 0, /* tp_as_mapping */
61478 0, /* tp_hash */
61479 0, /* tp_call */
61480 (reprfunc)swig_varlink_str, /* tp_str */
61481 0, /* tp_getattro */
61482 0, /* tp_setattro */
61483 0, /* tp_as_buffer */
61484 0, /* tp_flags */
61485 varlink__doc__, /* tp_doc */
61486 0, /* tp_traverse */
61487 0, /* tp_clear */
61488 0, /* tp_richcompare */
61489 0, /* tp_weaklistoffset */
61490 #if PY_VERSION_HEX >= 0x02020000
61491 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
61492 #endif
61493 #if PY_VERSION_HEX >= 0x02030000
61494 0, /* tp_del */
61495 #endif
61496 #ifdef COUNT_ALLOCS
61497 0,0,0,0 /* tp_alloc -> tp_next */
61498 #endif
61499 };
61500 varlink_type = tmp;
61501 varlink_type.ob_type = &PyType_Type;
61502 type_init = 1;
61503 }
61504 return &varlink_type;
61505 }
61506
61507 /* Create a variable linking object for use later */
61508 SWIGINTERN PyObject *
61509 SWIG_Python_newvarlink(void) {
61510 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
61511 if (result) {
61512 result->vars = 0;
61513 }
61514 return ((PyObject*) result);
61515 }
61516
61517 SWIGINTERN void
61518 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
61519 swig_varlinkobject *v = (swig_varlinkobject *) p;
61520 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
61521 if (gv) {
61522 size_t size = strlen(name)+1;
61523 gv->name = (char *)malloc(size);
61524 if (gv->name) {
61525 strncpy(gv->name,name,size);
61526 gv->get_attr = get_attr;
61527 gv->set_attr = set_attr;
61528 gv->next = v->vars;
61529 }
61530 }
61531 v->vars = gv;
61532 }
61533
61534 SWIGINTERN PyObject *
61535 SWIG_globals() {
61536 static PyObject *_SWIG_globals = 0;
61537 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
61538 return _SWIG_globals;
61539 }
61540
61541 /* -----------------------------------------------------------------------------
61542 * constants/methods manipulation
61543 * ----------------------------------------------------------------------------- */
61544
61545 /* Install Constants */
61546 SWIGINTERN void
61547 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
61548 PyObject *obj = 0;
61549 size_t i;
61550 for (i = 0; constants[i].type; ++i) {
61551 switch(constants[i].type) {
61552 case SWIG_PY_POINTER:
61553 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
61554 break;
61555 case SWIG_PY_BINARY:
61556 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
61557 break;
61558 default:
61559 obj = 0;
61560 break;
61561 }
61562 if (obj) {
61563 PyDict_SetItemString(d, constants[i].name, obj);
61564 Py_DECREF(obj);
61565 }
61566 }
61567 }
61568
61569 /* -----------------------------------------------------------------------------*/
61570 /* Fix SwigMethods to carry the callback ptrs when needed */
61571 /* -----------------------------------------------------------------------------*/
61572
61573 SWIGINTERN void
61574 SWIG_Python_FixMethods(PyMethodDef *methods,
61575 swig_const_info *const_table,
61576 swig_type_info **types,
61577 swig_type_info **types_initial) {
61578 size_t i;
61579 for (i = 0; methods[i].ml_name; ++i) {
61580 const char *c = methods[i].ml_doc;
61581 if (c && (c = strstr(c, "swig_ptr: "))) {
61582 int j;
61583 swig_const_info *ci = 0;
61584 const char *name = c + 10;
61585 for (j = 0; const_table[j].type; ++j) {
61586 if (strncmp(const_table[j].name, name,
61587 strlen(const_table[j].name)) == 0) {
61588 ci = &(const_table[j]);
61589 break;
61590 }
61591 }
61592 if (ci) {
61593 size_t shift = (ci->ptype) - types;
61594 swig_type_info *ty = types_initial[shift];
61595 size_t ldoc = (c - methods[i].ml_doc);
61596 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
61597 char *ndoc = (char*)malloc(ldoc + lptr + 10);
61598 if (ndoc) {
61599 char *buff = ndoc;
61600 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
61601 if (ptr) {
61602 strncpy(buff, methods[i].ml_doc, ldoc);
61603 buff += ldoc;
61604 strncpy(buff, "swig_ptr: ", 10);
61605 buff += 10;
61606 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
61607 methods[i].ml_doc = ndoc;
61608 }
61609 }
61610 }
61611 }
61612 }
61613 }
61614
61615 #ifdef __cplusplus
61616 }
61617 #endif
61618
61619 /* -----------------------------------------------------------------------------*
61620 * Partial Init method
61621 * -----------------------------------------------------------------------------*/
61622
61623 #ifdef __cplusplus
61624 extern "C"
61625 #endif
61626 SWIGEXPORT void SWIG_init(void) {
61627 PyObject *m, *d;
61628
61629 /* Fix SwigMethods to carry the callback ptrs when needed */
61630 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
61631
61632 m = Py_InitModule((char *) SWIG_name, SwigMethods);
61633 d = PyModule_GetDict(m);
61634
61635 SWIG_InitializeModule(0);
61636 SWIG_InstallConstants(d,swig_const_table);
61637
61638
61639
61640 #ifndef wxPyUSE_EXPORT
61641 // Make our API structure a CObject so other modules can import it
61642 // from this module.
61643 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
61644 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
61645 Py_XDECREF(cobj);
61646 #endif
61647
61648 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
61649 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
61650 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
61651 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
61652 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
61653 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
61654 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
61655 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
61656 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
61657 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
61658 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
61659 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
61660 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
61661 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
61662 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
61663 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
61664 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
61665 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
61666 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
61667 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
61668 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
61669 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
61670 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
61671 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
61672 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
61673 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
61674 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
61675 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
61676 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
61677 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
61678 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
61679 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
61680 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
61681 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
61682 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
61683 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
61684 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
61685 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
61686 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
61687 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
61688 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
61689 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
61690 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
61691 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
61692 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
61693 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
61694 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
61695 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
61696 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
61697 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
61698 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
61699 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
61700 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
61701 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
61702 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
61703 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
61704 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
61705 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
61706 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
61707 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
61708 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
61709 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
61710 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
61711 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
61712 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
61713 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
61714 SWIG_Python_SetConstant(d, "APPLY",SWIG_From_int(static_cast< int >(wxAPPLY)));
61715 SWIG_Python_SetConstant(d, "CLOSE",SWIG_From_int(static_cast< int >(wxCLOSE)));
61716 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
61717 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
61718 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
61719 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
61720 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
61721 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
61722 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
61723 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
61724 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
61725 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
61726 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
61727 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
61728 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
61729 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
61730 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
61731 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
61732 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
61733 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
61734 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
61735 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
61736 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
61737 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
61738 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
61739 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
61740 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
61741 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
61742 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
61743 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
61744 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
61745 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
61746 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
61747 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
61748 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
61749 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
61750 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
61751 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
61752 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
61753 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
61754 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
61755 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
61756 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
61757 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
61758 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
61759 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
61760 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
61761 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
61762 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
61763 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
61764 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
61765 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
61766 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
61767 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
61768 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
61769 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
61770 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
61771 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
61772 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
61773 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
61774 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
61775 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
61776 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
61777 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
61778 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
61779 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
61780 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
61781 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
61782 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
61783 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
61784 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
61785 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
61786 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
61787 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
61788 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
61789 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
61790 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
61791 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
61792 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
61793 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
61794 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
61795 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
61796 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
61797 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
61798 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
61799 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
61800 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
61801 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
61802 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
61803 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
61804 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
61805 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
61806 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
61807 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
61808 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
61809 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
61810 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
61811 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
61812 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
61813 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
61814 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
61815 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
61816 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
61817 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
61818 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
61819 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
61820 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
61821 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
61822 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
61823 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
61824 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
61825 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
61826 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
61827 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
61828 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
61829 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
61830 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
61831 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
61832 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
61833 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
61834 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
61835 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
61836 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
61837 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
61838 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
61839 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
61840 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
61841 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
61842 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
61843 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
61844 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
61845 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
61846 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
61847 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
61848 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
61849 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
61850 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
61851 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
61852 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
61853 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
61854 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
61855 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
61856 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
61857 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
61858 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
61859 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
61860 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
61861 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
61862 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
61863 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
61864 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
61865 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
61866 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
61867 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
61868 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
61869 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
61870 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
61871 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
61872 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
61873 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
61874 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
61875 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
61876 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
61877 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
61878 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
61879 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
61880 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
61881 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
61882 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
61883 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
61884 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
61885 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
61886 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
61887 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
61888 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
61889 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
61890 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
61891 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
61892 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
61893 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
61894 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
61895 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
61896 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
61897 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
61898 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
61899 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
61900 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
61901 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
61902 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
61903 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
61904 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
61905 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
61906 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
61907 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
61908 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
61909 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
61910 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
61911 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
61912 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
61913 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
61914 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
61915 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
61916 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
61917 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
61918 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
61919 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
61920 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
61921 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
61922 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
61923 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
61924 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
61925 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
61926 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
61927 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
61928 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
61929 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
61930 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
61931 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
61932 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
61933 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
61934 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
61935 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
61936 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
61937 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
61938 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
61939 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
61940 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
61941 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
61942 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
61943 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
61944 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
61945 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
61946 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
61947 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
61948 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
61949 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
61950 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
61951 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
61952 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
61953 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
61954 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
61955 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
61956 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
61957 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
61958 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
61959 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
61960 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
61961 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
61962 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
61963 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
61964 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
61965 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
61966 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
61967 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
61968 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
61969 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
61970 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
61971 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
61972 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
61973 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
61974 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
61975 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
61976 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
61977 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
61978 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
61979 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
61980 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
61981 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
61982 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
61983 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
61984 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
61985 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
61986 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
61987 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
61988 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
61989 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
61990 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
61991 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
61992 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
61993 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
61994 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
61995 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
61996 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
61997 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
61998 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
61999 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
62000 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
62001 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
62002 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
62003 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
62004 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
62005 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
62006 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
62007 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
62008 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
62009 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
62010 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
62011 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
62012 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
62013 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
62014 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
62015 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
62016 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
62017 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
62018 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
62019 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
62020 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
62021 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
62022 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
62023 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
62024 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
62025 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
62026 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
62027 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
62028 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
62029 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
62030 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
62031 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
62032 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
62033 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
62034 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
62035 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
62036 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
62037 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
62038 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
62039 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
62040 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
62041 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
62042 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
62043 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
62044 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
62045 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
62046 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
62047 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
62048 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
62049 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
62050 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
62051 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
62052 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
62053 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
62054 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
62055 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
62056 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
62057 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
62058 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
62059 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
62060 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
62061 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
62062 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
62063 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
62064 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
62065 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
62066 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
62067 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
62068 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
62069 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
62070 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
62071 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
62072 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
62073 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
62074 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
62075 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
62076 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
62077 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
62078 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
62079 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
62080 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
62081 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
62082 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
62083 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
62084 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
62085 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
62086 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
62087 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
62088 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
62089 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
62090 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
62091 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
62092 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
62093 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
62094 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
62095 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
62096 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
62097 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
62098 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
62099 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
62100 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
62101 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
62102 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
62103 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
62104 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
62105 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
62106 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
62107 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
62108 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
62109 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
62110 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
62111 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
62112 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
62113 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
62114 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
62115 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
62116 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
62117 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
62118 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
62119 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
62120 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
62121 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
62122 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
62123 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
62124 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
62125 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
62126 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
62127 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
62128 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
62129 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
62130 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
62131 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
62132 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
62133 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
62134 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
62135 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
62136 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
62137 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
62138 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
62139 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
62140 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
62141 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
62142 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
62143 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
62144 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
62145 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
62146 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
62147 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
62148 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
62149 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
62150 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
62151 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
62152 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
62153 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
62154 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
62155 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
62156 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
62157 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
62158 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
62159 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
62160 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
62161 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
62162 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
62163 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
62164 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
62165 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
62166 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
62167 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
62168 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
62169 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
62170 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
62171 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
62172 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
62173 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
62174 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
62175 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
62176 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
62177 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
62178 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
62179 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
62180 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
62181 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
62182 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
62183 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
62184 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
62185 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
62186 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
62187 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
62188 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
62189 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
62190 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
62191 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
62192 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
62193 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
62194 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
62195 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
62196 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
62197 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
62198 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
62199 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
62200 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
62201 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
62202 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
62203 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
62204 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
62205 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
62206 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
62207 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
62208 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
62209 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
62210 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
62211 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
62212 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
62213 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
62214 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
62215 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
62216 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
62217 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
62218 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
62219 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
62220 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
62221 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
62222 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
62223 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
62224 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
62225 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
62226 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
62227 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
62228 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
62229 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
62230 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
62231 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
62232 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
62233 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
62234 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
62235 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
62236 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
62237 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
62238 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
62239 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
62240 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
62241 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
62242 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
62243 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
62244 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
62245 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
62246 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
62247 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
62248 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
62249 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
62250 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
62251 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
62252 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
62253 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
62254 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
62255 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
62256 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
62257 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
62258 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
62259 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
62260 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
62261 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
62262 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
62263 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
62264 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
62265 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
62266 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
62267 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
62268 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
62269 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
62270 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
62271 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
62272 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
62273 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
62274 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
62275 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
62276 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
62277 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
62278 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
62279 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
62280 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
62281 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
62282 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
62283 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
62284 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
62285 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
62286 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
62287 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
62288 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
62289 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
62290 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
62291 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
62292 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
62293 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
62294 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
62295 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
62296 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
62297 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
62298 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
62299 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
62300 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
62301 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
62302 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
62303 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
62304 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
62305
62306 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
62307
62308
62309 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
62310
62311 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
62312 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
62313 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
62314 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
62315 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
62316 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
62317 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
62318 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
62319 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
62320 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
62321 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
62322 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
62323 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
62324 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
62325 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
62326 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_NONE",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_NONE)));
62327 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
62328 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
62329 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
62330 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
62331 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
62332 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
62333 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
62334 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
62335 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
62336 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
62337 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
62338 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
62339 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
62340 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
62341 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
62342 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
62343 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
62344 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
62345 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
62346 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
62347 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
62348 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
62349 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
62350 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
62351 PyDict_SetItemString(d, "wxEVT_ANY", PyInt_FromLong(wxEVT_ANY));
62352 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
62353 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
62354 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
62355 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
62356 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
62357 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
62358 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
62359 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
62360 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
62361 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
62362 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
62363 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
62364 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
62365 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
62366 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
62367 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
62368 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
62369 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
62370 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
62371 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
62372 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
62373 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
62374 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
62375 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
62376 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
62377 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
62378 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
62379 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
62380 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
62381 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
62382 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
62383 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
62384 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
62385 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
62386 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
62387 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
62388 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
62389 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
62390 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
62391 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
62392 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
62393 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
62394 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
62395 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
62396 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
62397 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
62398 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
62399 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
62400 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
62401 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
62402 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
62403 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
62404 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
62405 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
62406 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
62407 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
62408 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
62409 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
62410 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
62411 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
62412 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
62413 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
62414 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
62415 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
62416 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
62417 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
62418 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
62419 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
62420 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
62421 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
62422 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
62423 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
62424 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
62425 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
62426 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
62427 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
62428 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
62429 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
62430 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
62431 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
62432 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
62433 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
62434 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
62435 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
62436 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
62437 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
62438 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
62439 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
62440 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
62441 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
62442 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
62443 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
62444 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
62445 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
62446 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
62447 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
62448 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
62449 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
62450 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
62451 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
62452 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
62453 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
62454 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
62455 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
62456 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
62457 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
62458 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
62459 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
62460 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
62461 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
62462 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
62463 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
62464 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
62465 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
62466 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
62467 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
62468 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
62469 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
62470 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
62471 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
62472 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
62473 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
62474 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
62475 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
62476 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
62477 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
62478 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
62479 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
62480 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
62481 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
62482 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
62483 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
62484 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
62485 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
62486 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
62487 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
62488 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
62489 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
62490 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
62491 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
62492 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
62493 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
62494 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
62495 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
62496 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
62497 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
62498 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
62499 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
62500 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
62501 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
62502 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
62503 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
62504 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
62505 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
62506 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
62507 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
62508 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
62509 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
62510 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
62511 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
62512 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
62513 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
62514 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
62515 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
62516 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
62517 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
62518 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
62519 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
62520 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
62521 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
62522 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
62523 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
62524 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
62525 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
62526 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
62527
62528 // Initialize threading, some globals and such
62529 __wxPyPreStart(d);
62530
62531
62532 // Although these are defined in __version__ they need to be here too so
62533 // that an assert can be done to ensure that the wxPython and the wxWindows
62534 // versions match.
62535 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
62536 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
62537 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
62538
62539 }
62540
wxWidgets (Impactor)