]> 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
send selection events when Ctrl-clicking an item repeeatedly in a multiselection...
[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_wxPropagateOnce swig_types[96]
2563 #define SWIGTYPE_p_wxPropagationDisabler swig_types[97]
2564 #define SWIGTYPE_p_wxPyApp swig_types[98]
2565 #define SWIGTYPE_p_wxPyCommandEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyDropTarget swig_types[100]
2567 #define SWIGTYPE_p_wxPyEvent swig_types[101]
2568 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyImageHandler swig_types[103]
2570 #define SWIGTYPE_p_wxPyInputStream swig_types[104]
2571 #define SWIGTYPE_p_wxPySizer swig_types[105]
2572 #define SWIGTYPE_p_wxPyValidator swig_types[106]
2573 #define SWIGTYPE_p_wxQuantize swig_types[107]
2574 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[108]
2575 #define SWIGTYPE_p_wxRealPoint swig_types[109]
2576 #define SWIGTYPE_p_wxRect swig_types[110]
2577 #define SWIGTYPE_p_wxRect2D swig_types[111]
2578 #define SWIGTYPE_p_wxRegion swig_types[112]
2579 #define SWIGTYPE_p_wxScrollEvent swig_types[113]
2580 #define SWIGTYPE_p_wxScrollWinEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSetCursorEvent swig_types[115]
2582 #define SWIGTYPE_p_wxShowEvent swig_types[116]
2583 #define SWIGTYPE_p_wxSize swig_types[117]
2584 #define SWIGTYPE_p_wxSizeEvent swig_types[118]
2585 #define SWIGTYPE_p_wxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxSizerFlags swig_types[120]
2587 #define SWIGTYPE_p_wxSizerItem swig_types[121]
2588 #define SWIGTYPE_p_wxStaticBox swig_types[122]
2589 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[123]
2590 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[124]
2591 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[125]
2592 #define SWIGTYPE_p_wxTGAHandler swig_types[126]
2593 #define SWIGTYPE_p_wxTIFFHandler swig_types[127]
2594 #define SWIGTYPE_p_wxToolTip swig_types[128]
2595 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[129]
2596 #define SWIGTYPE_p_wxValidator swig_types[130]
2597 #define SWIGTYPE_p_wxVisualAttributes swig_types[131]
2598 #define SWIGTYPE_p_wxWindow swig_types[132]
2599 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[133]
2600 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[134]
2601 #define SWIGTYPE_p_wxXPMHandler swig_types[135]
2602 #define SWIGTYPE_p_wxZipFSHandler swig_types[136]
2603 static swig_type_info *swig_types[138];
2604 static swig_module_info swig_module = {swig_types, 137, 0, 0, 0, 0};
2605 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2606 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2607
2608 /* -------- TYPES TABLE (END) -------- */
2609
2610 #if (PY_VERSION_HEX <= 0x02000000)
2611 # if !defined(SWIG_PYTHON_CLASSIC)
2612 # error "This python version requires to use swig with the '-classic' option"
2613 # endif
2614 #endif
2615 #if (PY_VERSION_HEX <= 0x02020000)
2616 # error "This python version requires to use swig with the '-nomodern' option"
2617 #endif
2618 #if (PY_VERSION_HEX <= 0x02020000)
2619 # error "This python version requires to use swig with the '-nomodernargs' option"
2620 #endif
2621 #ifndef METH_O
2622 # error "This python version requires to use swig with the '-nofastunpack' option"
2623 #endif
2624
2625 /*-----------------------------------------------
2626 @(target):= _core_.so
2627 ------------------------------------------------*/
2628 #define SWIG_init init_core_
2629
2630 #define SWIG_name "_core_"
2631
2632 #define SWIGVERSION 0x010329
2633
2634
2635 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2636 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2637
2638
2639 #include <stdexcept>
2640
2641
2642 namespace swig {
2643 class PyObject_ptr {
2644 protected:
2645 PyObject *_obj;
2646
2647 public:
2648 PyObject_ptr() :_obj(0)
2649 {
2650 }
2651
2652 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2653 {
2654 Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2658 {
2659 if (initial_ref) Py_XINCREF(_obj);
2660 }
2661
2662 PyObject_ptr & operator=(const PyObject_ptr& item)
2663 {
2664 Py_XINCREF(item._obj);
2665 Py_XDECREF(_obj);
2666 _obj = item._obj;
2667 return *this;
2668 }
2669
2670 ~PyObject_ptr()
2671 {
2672 Py_XDECREF(_obj);
2673 }
2674
2675 operator PyObject *() const
2676 {
2677 return _obj;
2678 }
2679
2680 PyObject *operator->() const
2681 {
2682 return _obj;
2683 }
2684 };
2685 }
2686
2687
2688 namespace swig {
2689 struct PyObject_var : PyObject_ptr {
2690 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2691
2692 PyObject_var & operator = (PyObject* obj)
2693 {
2694 Py_XDECREF(_obj);
2695 _obj = obj;
2696 return *this;
2697 }
2698 };
2699 }
2700
2701
2702 #include "wx/wxPython/wxPython_int.h"
2703 #include "wx/wxPython/pyclasses.h"
2704 #include "wx/wxPython/twoitem.h"
2705
2706
2707 #ifndef wxPyUSE_EXPORT
2708 // Helper functions for dealing with SWIG objects and such. These are
2709 // located here so they know about the SWIG types and functions declared
2710 // in the wrapper code.
2711
2712 #include <wx/hashmap.h>
2713 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2714
2715
2716 // Maintains a hashmap of className to swig_type_info pointers. Given the
2717 // name of a class either looks up the type info in the cache, or scans the
2718 // SWIG tables for it.
2719 extern PyObject* wxPyPtrTypeMap;
2720 static
2721 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2722
2723 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2724
2725 if (typeInfoCache == NULL)
2726 typeInfoCache = new wxPyTypeInfoHashMap;
2727
2728 wxString name(className);
2729 swig_type_info* swigType = (*typeInfoCache)[name];
2730
2731 if (! swigType) {
2732 // it wasn't in the cache, so look it up from SWIG
2733 name.Append(wxT(" *"));
2734 swigType = SWIG_TypeQuery(name.mb_str());
2735
2736 // if it still wasn't found, try looking for a mapped name
2737 if (!swigType) {
2738 PyObject* item;
2739 name = className;
2740
2741 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2742 (char*)(const char*)name.mbc_str())) != NULL) {
2743 name = wxString(PyString_AsString(item), *wxConvCurrent);
2744 name.Append(wxT(" *"));
2745 swigType = SWIG_TypeQuery(name.mb_str());
2746 }
2747 }
2748 if (swigType) {
2749 // and add it to the map if found
2750 (*typeInfoCache)[className] = swigType;
2751 }
2752 }
2753 return swigType;
2754 }
2755
2756
2757 // Check if a class name is a type known to SWIG
2758 bool wxPyCheckSwigType(const wxChar* className) {
2759
2760 swig_type_info* swigType = wxPyFindSwigType(className);
2761 return swigType != NULL;
2762 }
2763
2764
2765 // Given a pointer to a C++ object and a class name, construct a Python proxy
2766 // object for it.
2767 PyObject* wxPyConstructObject(void* ptr,
2768 const wxChar* className,
2769 int setThisOwn) {
2770
2771 swig_type_info* swigType = wxPyFindSwigType(className);
2772 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2773
2774 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2775 }
2776
2777
2778 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2779 // Ensures that the proxy object is of the specified (or derived) type. If
2780 // not able to perform the conversion then a Python exception is set and the
2781 // error should be handled properly in the caller. Returns True on success.
2782 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2783 const wxChar* className) {
2784
2785 swig_type_info* swigType = wxPyFindSwigType(className);
2786 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2787
2788 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2789 }
2790
2791
2792
2793 // Make a SWIGified pointer object suitable for a .this attribute
2794 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2795
2796 PyObject* robj = NULL;
2797
2798 swig_type_info* swigType = wxPyFindSwigType(className);
2799 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2800
2801 robj = PySwigObject_New(ptr, swigType, 0);
2802 return robj;
2803 }
2804
2805
2806 // Python's PyInstance_Check does not return True for instances of new-style
2807 // classes. This should get close enough for both new and old classes but I
2808 // should re-evaluate the need for doing instance checks...
2809 bool wxPyInstance_Check(PyObject* obj) {
2810 return PyObject_HasAttrString(obj, "__class__") != 0;
2811 }
2812
2813
2814 // This one checks if the object is an instance of a SWIG proxy class (it has
2815 // a .this attribute, and the .this attribute is a PySwigObject.)
2816 bool wxPySwigInstance_Check(PyObject* obj) {
2817 static PyObject* this_str = NULL;
2818 if (this_str == NULL)
2819 this_str = PyString_FromString("this");
2820
2821 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2822 if (this_attr) {
2823 bool retval = (PySwigObject_Check(this_attr) != 0);
2824 Py_DECREF(this_attr);
2825 return retval;
2826 }
2827
2828 PyErr_Clear();
2829 return false;
2830 }
2831
2832
2833 // Export a C API in a struct. Other modules will be able to load this from
2834 // the wx._core_ module and will then have safe access to these functions,
2835 // even if they are located in another shared library.
2836 static wxPyCoreAPI API = {
2837
2838 wxPyCheckSwigType,
2839 wxPyConstructObject,
2840 wxPyConvertSwigPtr,
2841 wxPyMakeSwigPtr,
2842
2843 wxPyBeginAllowThreads,
2844 wxPyEndAllowThreads,
2845 wxPyBeginBlockThreads,
2846 wxPyEndBlockThreads,
2847
2848 wxPy_ConvertList,
2849
2850 wxString_in_helper,
2851 Py2wxString,
2852 wx2PyString,
2853
2854 byte_LIST_helper,
2855 int_LIST_helper,
2856 long_LIST_helper,
2857 string_LIST_helper,
2858 wxPoint_LIST_helper,
2859 wxBitmap_LIST_helper,
2860 wxString_LIST_helper,
2861 wxAcceleratorEntry_LIST_helper,
2862
2863 wxSize_helper,
2864 wxPoint_helper,
2865 wxRealPoint_helper,
2866 wxRect_helper,
2867 wxColour_helper,
2868 wxPoint2D_helper,
2869
2870 wxPySimple_typecheck,
2871 wxColour_typecheck,
2872
2873 wxPyCBH_setCallbackInfo,
2874 wxPyCBH_findCallback,
2875 wxPyCBH_callCallback,
2876 wxPyCBH_callCallbackObj,
2877 wxPyCBH_delete,
2878
2879 wxPyMake_wxObject,
2880 wxPyMake_wxSizer,
2881 wxPyPtrTypeMap_Add,
2882 wxPy2int_seq_helper,
2883 wxPy4int_seq_helper,
2884 wxArrayString2PyList_helper,
2885 wxArrayInt2PyList_helper,
2886
2887 wxPyClientData_dtor,
2888 wxPyUserData_dtor,
2889 wxPyOORClientData_dtor,
2890
2891 wxPyCBInputStream_create,
2892 wxPyCBInputStream_copy,
2893
2894 wxPyInstance_Check,
2895 wxPySwigInstance_Check,
2896
2897 wxPyCheckForApp,
2898
2899 wxArrayDouble2PyList_helper,
2900 wxPoint2D_LIST_helper,
2901 wxRect2D_helper,
2902
2903 };
2904
2905 #endif
2906
2907
2908 #if !WXWIN_COMPATIBILITY_2_4
2909 #define wxHIDE_READONLY 0
2910 #endif
2911
2912
2913 #define SWIG_From_long PyInt_FromLong
2914
2915
2916 SWIGINTERNINLINE PyObject *
2917 SWIG_From_int (int value)
2918 {
2919 return SWIG_From_long (value);
2920 }
2921
2922 static const wxString wxPyEmptyString(wxEmptyString);
2923 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2924 return self->GetClassInfo()->GetClassName();
2925 }
2926 SWIGINTERN void wxObject_Destroy(wxObject *self){
2927 delete self;
2928 }
2929
2930 #ifndef __WXMAC__
2931 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2932 #endif
2933
2934
2935 #include <limits.h>
2936 #ifndef LLONG_MIN
2937 # define LLONG_MIN LONG_LONG_MIN
2938 #endif
2939 #ifndef LLONG_MAX
2940 # define LLONG_MAX LONG_LONG_MAX
2941 #endif
2942 #ifndef ULLONG_MAX
2943 # define ULLONG_MAX ULONG_LONG_MAX
2944 #endif
2945
2946
2947 SWIGINTERN int
2948 SWIG_AsVal_long (PyObject* obj, long* val)
2949 {
2950 if (PyNumber_Check(obj)) {
2951 if (val) *val = PyInt_AsLong(obj);
2952 return SWIG_OK;
2953 }
2954 return SWIG_TypeError;
2955 }
2956
2957
2958 SWIGINTERN int
2959 SWIG_AsVal_int (PyObject * obj, int *val)
2960 {
2961 long v;
2962 int res = SWIG_AsVal_long (obj, &v);
2963 if (SWIG_IsOK(res)) {
2964 if ((v < INT_MIN || v > INT_MAX)) {
2965 return SWIG_OverflowError;
2966 } else {
2967 if (val) *val = static_cast< int >(v);
2968 }
2969 }
2970 return res;
2971 }
2972
2973 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return false;
2976 if ( ! wxSize_helper(other, &obj) ) {
2977 PyErr_Clear();
2978 return false;
2979 }
2980 return self->operator==(*obj);
2981 }
2982 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2983 wxSize temp, *obj = &temp;
2984 if ( other == Py_None ) return true;
2985 if ( ! wxSize_helper(other, &obj)) {
2986 PyErr_Clear();
2987 return true;
2988 }
2989 return self->operator!=(*obj);
2990 }
2991
2992 #include <float.h>
2993
2994
2995 SWIGINTERN int
2996 SWIG_AsVal_double (PyObject *obj, double* val)
2997 {
2998 if (PyNumber_Check(obj)) {
2999 if (val) *val = PyFloat_AsDouble(obj);
3000 return SWIG_OK;
3001 }
3002 return SWIG_TypeError;
3003 }
3004
3005
3006 SWIGINTERN int
3007 SWIG_AsVal_float (PyObject * obj, float *val)
3008 {
3009 double v;
3010 int res = SWIG_AsVal_double (obj, &v);
3011 if (SWIG_IsOK(res)) {
3012 if ((v < -FLT_MAX || v > FLT_MAX)) {
3013 return SWIG_OverflowError;
3014 } else {
3015 if (val) *val = static_cast< float >(v);
3016 }
3017 }
3018 return res;
3019 }
3020
3021 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3022 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3023 PyObject* tup = PyTuple_New(2);
3024 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3025 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3026 //wxPyEndBlockThreads(blocked);
3027 return tup;
3028 }
3029
3030 #define SWIG_From_double PyFloat_FromDouble
3031
3032 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return false;
3035 if ( ! wxRealPoint_helper(other, &obj) ) {
3036 PyErr_Clear();
3037 return false;
3038 }
3039 return self->operator==(*obj);
3040 }
3041 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3042 wxRealPoint temp, *obj = &temp;
3043 if ( other == Py_None ) return true;
3044 if ( ! wxRealPoint_helper(other, &obj)) {
3045 PyErr_Clear();
3046 return true;
3047 }
3048 return self->operator!=(*obj);
3049 }
3050 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3051 self->x = x;
3052 self->y = y;
3053 }
3054 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3055 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3056 PyObject* tup = PyTuple_New(2);
3057 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3058 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3059 //PyEndBlockThreads(blocked);
3060 return tup;
3061 }
3062 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return false;
3065 if ( ! wxPoint_helper(other, &obj) ) {
3066 PyErr_Clear();
3067 return false;
3068 }
3069 return self->operator==(*obj);
3070 }
3071 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3072 wxPoint temp, *obj = &temp;
3073 if ( other == Py_None ) return true;
3074 if ( ! wxPoint_helper(other, &obj)) {
3075 PyErr_Clear();
3076 return true;
3077 }
3078 return self->operator!=(*obj);
3079 }
3080 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3081 self->x = x;
3082 self->y = y;
3083 }
3084 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3085 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3086 PyObject* tup = PyTuple_New(2);
3087 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3088 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3089 //wxPyEndBlockThreads(blocked);
3090 return tup;
3091 }
3092 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return false;
3095 if ( ! wxRect_helper(other, &obj) ) {
3096 PyErr_Clear();
3097 return false;
3098 }
3099 return self->operator==(*obj);
3100 }
3101 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3102 wxRect temp, *obj = &temp;
3103 if ( other == Py_None ) return true;
3104 if ( ! wxRect_helper(other, &obj)) {
3105 PyErr_Clear();
3106 return true;
3107 }
3108 return self->operator!=(*obj);
3109 }
3110 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3111 self->x = x;
3112 self->y = y;
3113 self->width = width;
3114 self->height = height;
3115 }
3116 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3117 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3118 PyObject* tup = PyTuple_New(4);
3119 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3120 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3121 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3122 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3123 //wxPyEndBlockThreads(blocked);
3124 return tup;
3125 }
3126
3127 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3128 wxRegion reg1(*r1);
3129 wxRegion reg2(*r2);
3130 wxRect dest(0,0,0,0);
3131 PyObject* obj;
3132
3133 reg1.Intersect(reg2);
3134 dest = reg1.GetBox();
3135
3136 if (dest != wxRect(0,0,0,0)) {
3137 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3138 wxRect* newRect = new wxRect(dest);
3139 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3140 //wxPyEndBlockThreads(blocked);
3141 return obj;
3142 }
3143 Py_INCREF(Py_None);
3144 return Py_None;
3145 }
3146
3147 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return false;
3150 if ( ! wxPoint2D_helper(other, &obj) ) {
3151 PyErr_Clear();
3152 return false;
3153 }
3154 return self->operator==(*obj);
3155 }
3156 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3157 wxPoint2D temp, *obj = &temp;
3158 if ( other == Py_None ) return true;
3159 if ( ! wxPoint2D_helper(other, &obj)) {
3160 PyErr_Clear();
3161 return true;
3162 }
3163 return self->operator!=(*obj);
3164 }
3165 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3166 self->m_x = x;
3167 self->m_y = y;
3168 }
3169 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3170 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3171 PyObject* tup = PyTuple_New(2);
3172 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3173 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3174 //wxPyEndBlockThreads(blocked);
3175 return tup;
3176 }
3177 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3178 wxRect2D temp, *obj = &temp;
3179 if ( other == Py_None ) return false;
3180 if ( ! wxRect2D_helper(other, &obj) ) {
3181 PyErr_Clear();
3182 return false;
3183 }
3184 return self->operator==(*obj);
3185 }
3186 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3187 wxRect2D temp, *obj = &temp;
3188 if ( other == Py_None ) return true;
3189 if ( ! wxRect2D_helper(other, &obj)) {
3190 PyErr_Clear();
3191 return true;
3192 }
3193 return self->operator!=(*obj);
3194 }
3195 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3196 self->m_x = x;
3197 self->m_y = y;
3198 self->m_width = width;
3199 self->m_height = height;
3200 }
3201 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3202 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3203 PyObject* tup = PyTuple_New(4);
3204 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3205 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3206 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3207 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3208 //wxPyEndBlockThreads(blocked);
3209 return tup;
3210 }
3211
3212 #include "wx/wxPython/pyistream.h"
3213
3214 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3215 wxInputStream* wxis = wxPyCBInputStream::create(p);
3216 if (wxis)
3217 return new wxPyInputStream(wxis);
3218 else
3219 return NULL;
3220 }
3221
3222 SWIGINTERN swig_type_info*
3223 SWIG_pchar_descriptor()
3224 {
3225 static int init = 0;
3226 static swig_type_info* info = 0;
3227 if (!init) {
3228 info = SWIG_TypeQuery("_p_char");
3229 init = 1;
3230 }
3231 return info;
3232 }
3233
3234
3235 SWIGINTERNINLINE PyObject *
3236 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3237 {
3238 if (carray) {
3239 if (size > INT_MAX) {
3240 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3241 return pchar_descriptor ?
3242 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3243 } else {
3244 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3245 }
3246 } else {
3247 return SWIG_Py_Void();
3248 }
3249 }
3250
3251
3252 SWIGINTERNINLINE PyObject *
3253 SWIG_From_char (char c)
3254 {
3255 return SWIG_FromCharPtrAndSize(&c,1);
3256 }
3257
3258
3259 SWIGINTERNINLINE PyObject*
3260 SWIG_From_unsigned_SS_long (unsigned long value)
3261 {
3262 return (value > LONG_MAX) ?
3263 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3264 }
3265
3266
3267 SWIGINTERNINLINE PyObject *
3268 SWIG_From_size_t (size_t value)
3269 {
3270 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3271 }
3272
3273
3274 SWIGINTERN int
3275 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3276 {
3277 if (PyString_Check(obj)) {
3278 char *cstr; Py_ssize_t len;
3279 PyString_AsStringAndSize(obj, &cstr, &len);
3280 if (cptr) {
3281 if (alloc) {
3282 /*
3283 In python the user should not be able to modify the inner
3284 string representation. To warranty that, if you define
3285 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3286 buffer is always returned.
3287
3288 The default behavior is just to return the pointer value,
3289 so, be careful.
3290 */
3291 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3292 if (*alloc != SWIG_OLDOBJ)
3293 #else
3294 if (*alloc == SWIG_NEWOBJ)
3295 #endif
3296 {
3297 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3298 *alloc = SWIG_NEWOBJ;
3299 }
3300 else {
3301 *cptr = cstr;
3302 *alloc = SWIG_OLDOBJ;
3303 }
3304 } else {
3305 *cptr = PyString_AsString(obj);
3306 }
3307 }
3308 if (psize) *psize = len + 1;
3309 return SWIG_OK;
3310 } else {
3311 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3312 if (pchar_descriptor) {
3313 void* vptr = 0;
3314 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3315 if (cptr) *cptr = (char *) vptr;
3316 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3317 if (alloc) *alloc = SWIG_OLDOBJ;
3318 return SWIG_OK;
3319 }
3320 }
3321 }
3322 return SWIG_TypeError;
3323 }
3324
3325
3326 SWIGINTERN int
3327 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3328 {
3329 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3330 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3331 if (SWIG_IsOK(res)) {
3332 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3333 if (csize <= size) {
3334 if (val) {
3335 if (csize) memcpy(val, cptr, csize*sizeof(char));
3336 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3337 }
3338 if (alloc == SWIG_NEWOBJ) {
3339 delete[] cptr;
3340 res = SWIG_DelNewMask(res);
3341 }
3342 return res;
3343 }
3344 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3345 }
3346 return SWIG_TypeError;
3347 }
3348
3349
3350 SWIGINTERN int
3351 SWIG_AsVal_char (PyObject * obj, char *val)
3352 {
3353 int res = SWIG_AsCharArray(obj, val, 1);
3354 if (!SWIG_IsOK(res)) {
3355 long v;
3356 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3357 if (SWIG_IsOK(res)) {
3358 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3359 if (val) *val = static_cast< char >(v);
3360 } else {
3361 res = SWIG_OverflowError;
3362 }
3363 }
3364 }
3365 return res;
3366 }
3367
3368 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3369 // We use only strings for the streams, not unicode
3370 PyObject* str = PyObject_Str(obj);
3371 if (! str) {
3372 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3373 return;
3374 }
3375 self->Write(PyString_AS_STRING(str),
3376 PyString_GET_SIZE(str));
3377 Py_DECREF(str);
3378 }
3379
3380 #include "wx/wxPython/pyistream.h"
3381
3382
3383 class wxPyFileSystemHandler : public wxFileSystemHandler
3384 {
3385 public:
3386 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3387
3388 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3389 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3390 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3391 DEC_PYCALLBACK_STRING__pure(FindNext);
3392
3393 wxString GetProtocol(const wxString& location) {
3394 return wxFileSystemHandler::GetProtocol(location);
3395 }
3396
3397 wxString GetLeftLocation(const wxString& location) {
3398 return wxFileSystemHandler::GetLeftLocation(location);
3399 }
3400
3401 wxString GetAnchor(const wxString& location) {
3402 return wxFileSystemHandler::GetAnchor(location);
3403 }
3404
3405 wxString GetRightLocation(const wxString& location) {
3406 return wxFileSystemHandler::GetRightLocation(location);
3407 }
3408
3409 wxString GetMimeTypeFromExt(const wxString& location) {
3410 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3411 }
3412
3413 PYPRIVATE;
3414 };
3415
3416
3417 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3418 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3419 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3420 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3421
3422
3423 SWIGINTERN int
3424 SWIG_AsVal_bool (PyObject *obj, bool *val)
3425 {
3426 if (obj == Py_True) {
3427 if (val) *val = true;
3428 return SWIG_OK;
3429 } else if (obj == Py_False) {
3430 if (val) *val = false;
3431 return SWIG_OK;
3432 } else {
3433 long v = 0;
3434 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3435 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3436 return res;
3437 }
3438 }
3439
3440 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3441 wxFileName fname = wxFileSystem::URLToFileName(url);
3442 return fname.GetFullPath();
3443 }
3444
3445 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3446 wxImage& image,
3447 long type) {
3448 wxMemoryFSHandler::AddFile(filename, image, type);
3449 }
3450
3451 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3452 const wxBitmap& bitmap,
3453 long type) {
3454 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3455 }
3456
3457 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3458 PyObject* data) {
3459 if (! PyString_Check(data)) {
3460 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3461 "Expected string object"));
3462 return;
3463 }
3464
3465 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3466 void* ptr = (void*)PyString_AsString(data);
3467 size_t size = PyString_Size(data);
3468 wxPyEndBlockThreads(blocked);
3469
3470 wxMemoryFSHandler::AddFile(filename, ptr, size);
3471 }
3472
3473
3474 #include "wx/wxPython/pyistream.h"
3475
3476
3477 SWIGINTERN int
3478 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3479 {
3480 long v = 0;
3481 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3482 return SWIG_TypeError;
3483 }
3484 else if (val)
3485 *val = (unsigned long)v;
3486 return SWIG_OK;
3487 }
3488
3489
3490 SWIGINTERN int
3491 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3492 {
3493 unsigned long v;
3494 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3495 if (SWIG_IsOK(res)) {
3496 if ((v > UCHAR_MAX)) {
3497 return SWIG_OverflowError;
3498 } else {
3499 if (val) *val = static_cast< unsigned char >(v);
3500 }
3501 }
3502 return res;
3503 }
3504
3505
3506 SWIGINTERNINLINE PyObject *
3507 SWIG_From_unsigned_SS_char (unsigned char value)
3508 {
3509 return SWIG_From_unsigned_SS_long (value);
3510 }
3511
3512 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3513 wxImageHistogramEntry e = (*self)[key];
3514 return e.value;
3515 }
3516 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3517 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3518 wxImageHistogramEntry e = (*self)[key];
3519 return e.value;
3520 }
3521 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3522 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3523 colour.Green(),
3524 colour.Blue());
3525 wxImageHistogramEntry e = (*self)[key];
3526 return e.value;
3527 }
3528
3529 // Pull the nested class out to the top level for SWIG's sake
3530 #define wxImage_RGBValue wxImage::RGBValue
3531 #define wxImage_HSVValue wxImage::HSVValue
3532
3533 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3534 if (width > 0 && height > 0)
3535 return new wxImage(width, height, clear);
3536 else
3537 return new wxImage;
3538 }
3539 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3540 return new wxImage(bitmap.ConvertToImage());
3541 }
3542 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3543 if (DATASIZE != width*height*3) {
3544 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3545 return NULL;
3546 }
3547
3548 // Copy the source data so the wxImage can clean it up later
3549 buffer copy = (buffer)malloc(DATASIZE);
3550 if (copy == NULL) {
3551 wxPyBLOCK_THREADS(PyErr_NoMemory());
3552 return NULL;
3553 }
3554 memcpy(copy, data, DATASIZE);
3555 return new wxImage(width, height, copy, false);
3556 }
3557 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3558 if (DATASIZE != width*height*3) {
3559 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3560 return NULL;
3561 }
3562 if (ALPHASIZE != width*height) {
3563 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3564 return NULL;
3565 }
3566
3567 // Copy the source data so the wxImage can clean it up later
3568 buffer dcopy = (buffer)malloc(DATASIZE);
3569 if (dcopy == NULL) {
3570 wxPyBLOCK_THREADS(PyErr_NoMemory());
3571 return NULL;
3572 }
3573 memcpy(dcopy, data, DATASIZE);
3574
3575 buffer acopy = (buffer)malloc(ALPHASIZE);
3576 if (acopy == NULL) {
3577 wxPyBLOCK_THREADS(PyErr_NoMemory());
3578 return NULL;
3579 }
3580 memcpy(acopy, alpha, ALPHASIZE);
3581
3582 return new wxImage(width, height, dcopy, acopy, false);
3583 }
3584 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3585 wxSize size(self->GetWidth(), self->GetHeight());
3586 return size;
3587 }
3588 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3589 buffer data = self->GetData();
3590 int len = self->GetWidth() * self->GetHeight() * 3;
3591 PyObject* rv;
3592 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3593 return rv;
3594 }
3595 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3596 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3597 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3598 return;
3599 }
3600 buffer copy = (buffer)malloc(DATASIZE);
3601 if (copy == NULL) {
3602 wxPyBLOCK_THREADS(PyErr_NoMemory());
3603 return;
3604 }
3605 memcpy(copy, data, DATASIZE);
3606 self->SetData(copy, false);
3607 // wxImage takes ownership of copy...
3608 }
3609 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3610 buffer data = self->GetData();
3611 int len = self->GetWidth() * self->GetHeight() * 3;
3612 PyObject* rv;
3613 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3614 return rv;
3615 }
3616 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3617 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3618 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3619 return;
3620 }
3621 self->SetData(data, true);
3622 }
3623 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3624 buffer data = self->GetAlpha();
3625 if (! data) {
3626 RETURN_NONE();
3627 } else {
3628 int len = self->GetWidth() * self->GetHeight();
3629 PyObject* rv;
3630 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3631 return rv;
3632 }
3633 }
3634 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3635 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3636 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3637 return;
3638 }
3639 buffer acopy = (buffer)malloc(ALPHASIZE);
3640 if (acopy == NULL) {
3641 wxPyBLOCK_THREADS(PyErr_NoMemory());
3642 return;
3643 }
3644 memcpy(acopy, alpha, ALPHASIZE);
3645 self->SetAlpha(acopy, false);
3646 // wxImage takes ownership of acopy...
3647 }
3648 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3649 buffer data = self->GetAlpha();
3650 int len = self->GetWidth() * self->GetHeight();
3651 PyObject* rv;
3652 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3653 return rv;
3654 }
3655 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3656 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3657 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3658 return;
3659 }
3660 self->SetAlpha(alpha, true);
3661 }
3662 SWIGINTERN PyObject *wxImage_GetHandlers(){
3663 wxList& list = wxImage::GetHandlers();
3664 return wxPy_ConvertList(&list);
3665 }
3666 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3667 wxBitmap bitmap(*self, depth);
3668 return bitmap;
3669 }
3670 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3671 wxImage mono = self->ConvertToMono( red, green, blue );
3672 wxBitmap bitmap( mono, 1 );
3673 return bitmap;
3674 }
3675
3676 wxImage* _ImageFromBuffer(int width, int height,
3677 buffer data, int DATASIZE,
3678 buffer alpha=NULL, int ALPHASIZE=0)
3679 {
3680 if (DATASIZE != width*height*3) {
3681 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3682 return NULL;
3683 }
3684 if (alpha != NULL) {
3685 if (ALPHASIZE != width*height) {
3686 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3687 return NULL;
3688 }
3689 return new wxImage(width, height, data, alpha, true);
3690 }
3691 return new wxImage(width, height, data, true);
3692 }
3693
3694 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3695 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3696 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3697 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3699 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3700 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3701 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3702 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3703 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3704 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3705 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3706 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3707 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3708 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3709
3710 #include <wx/imagtga.h>
3711
3712
3713 #include <wx/quantize.h>
3714
3715 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3716 return wxQuantize::Quantize(src, dest,
3717 //NULL, // palette
3718 desiredNoColours,
3719 NULL, // eightBitData
3720 flags);
3721 }
3722 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3723 if (PyCallable_Check(func)) {
3724 self->Connect(id, lastId, eventType,
3725 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3726 new wxPyCallback(func));
3727 }
3728 else if (func == Py_None) {
3729 self->Disconnect(id, lastId, eventType,
3730 (wxObjectEventFunction)
3731 &wxPyCallback::EventThunker);
3732 }
3733 else {
3734 wxPyBLOCK_THREADS(
3735 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3736 }
3737 }
3738 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3739 return self->Disconnect(id, lastId, eventType,
3740 (wxObjectEventFunction)
3741 &wxPyCallback::EventThunker);
3742 }
3743 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3744 if (_self && _self != Py_None) {
3745 self->SetClientObject(new wxPyOORClientData(_self, incref));
3746 }
3747 else {
3748 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3749 if (data) {
3750 self->SetClientObject(NULL); // This will delete it too
3751 }
3752 }
3753 }
3754
3755 #if ! wxUSE_HOTKEY
3756 #define wxEVT_HOTKEY -9999
3757 #endif
3758
3759 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3760 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3761 if (data) {
3762 Py_INCREF(data->m_obj);
3763 return data->m_obj;
3764 } else {
3765 Py_INCREF(Py_None);
3766 return Py_None;
3767 }
3768 }
3769 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3770 wxPyClientData* data = new wxPyClientData(clientData);
3771 self->SetClientObject(data);
3772 }
3773 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3774 #if wxUSE_UNICODE
3775 return self->GetUnicodeKey();
3776 #else
3777 return 0;
3778 #endif
3779 }
3780 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3781 #if wxUSE_UNICODE
3782 self->m_uniChar = uniChar;
3783 #endif
3784 }
3785
3786 SWIGINTERNINLINE PyObject *
3787 SWIG_From_unsigned_SS_int (unsigned int value)
3788 {
3789 return SWIG_From_unsigned_SS_long (value);
3790 }
3791
3792
3793 SWIGINTERN int
3794 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3795 {
3796 unsigned long v;
3797 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3798 if (SWIG_IsOK(res)) {
3799 if ((v > UINT_MAX)) {
3800 return SWIG_OverflowError;
3801 } else {
3802 if (val) *val = static_cast< unsigned int >(v);
3803 }
3804 }
3805 return res;
3806 }
3807
3808 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3809 self->m_size = size;
3810 }
3811 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3812 int count = self->GetNumberOfFiles();
3813 wxString* files = self->GetFiles();
3814 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3815 PyObject* list = PyList_New(count);
3816
3817 if (!list) {
3818 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3819 wxPyEndBlockThreads(blocked);
3820 return NULL;
3821 }
3822
3823 for (int i=0; i<count; i++) {
3824 PyList_SetItem(list, i, wx2PyString(files[i]));
3825 }
3826 wxPyEndBlockThreads(blocked);
3827 return list;
3828 }
3829
3830
3831 SWIGINTERN wxPyApp *new_wxPyApp(){
3832 wxPythonApp = new wxPyApp();
3833 return wxPythonApp;
3834 }
3835 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3836 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3837 return wxPyTestDisplayAvailable();
3838 }
3839
3840 void wxApp_CleanUp() {
3841 __wxPyCleanup();
3842 }
3843
3844
3845 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3846
3847
3848
3849
3850
3851 SWIGINTERNINLINE PyObject *
3852 SWIG_FromCharPtr(const char *cptr)
3853 {
3854 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3855 }
3856
3857
3858 #if 0 // #ifdef __WXMAC__
3859
3860 // A dummy class that raises an exception if used...
3861 class wxEventLoop
3862 {
3863 public:
3864 wxEventLoop() { wxPyRaiseNotImplemented(); }
3865 int Run() { return 0; }
3866 void Exit(int rc = 0) {}
3867 bool Pending() const { return false; }
3868 bool Dispatch() { return false; }
3869 bool IsRunning() const { return false; }
3870 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3871 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3872 };
3873
3874 #else
3875
3876 #include <wx/evtloop.h>
3877
3878 #endif
3879
3880
3881
3882 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3883 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3884 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3885 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3886 wxWindowList& list = self->GetChildren();
3887 return wxPy_ConvertList(&list);
3888 }
3889 SWIGINTERN wxWindow *wxWindow_GetTopLevelParent(wxWindow *self){
3890 return wxGetTopLevelParent(self);
3891 }
3892 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3893 #if wxUSE_HOTKEY
3894 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3895 #else
3896 return false;
3897 #endif
3898 }
3899 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3900
3901
3902
3903 return false;
3904
3905 }
3906 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3907 return wxPyGetWinHandle(self);
3908 }
3909 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3910 self->AssociateHandle((WXWidget)handle);
3911 }
3912 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3913
3914 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3915 return wxWindow::FindWindowById(id, parent);
3916 }
3917
3918 wxWindow* wxFindWindowByName( const wxString& name,
3919 const wxWindow *parent = NULL ) {
3920 return wxWindow::FindWindowByName(name, parent);
3921 }
3922
3923 wxWindow* wxFindWindowByLabel( const wxString& label,
3924 const wxWindow *parent = NULL ) {
3925 return wxWindow::FindWindowByLabel(label, parent);
3926 }
3927
3928
3929 #ifdef __WXMSW__
3930 #include <wx/msw/private.h> // to get wxGetWindowId
3931 #endif
3932
3933
3934 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3935 #ifdef __WXMSW__
3936 WXHWND hWnd = (WXHWND)_hWnd;
3937 long id = wxGetWindowId(hWnd);
3938 wxWindow* win = new wxWindow;
3939 if (parent)
3940 parent->AddChild(win);
3941 win->SetEventHandler(win);
3942 win->SetHWND(hWnd);
3943 win->SetId(id);
3944 win->SubclassWin(hWnd);
3945 win->AdoptAttributesFromHWND();
3946 win->SetupColours();
3947 return win;
3948 #else
3949 wxPyRaiseNotImplemented();
3950 return NULL;
3951 #endif
3952 }
3953
3954
3955 PyObject* GetTopLevelWindows() {
3956 return wxPy_ConvertList(&wxTopLevelWindows);
3957 }
3958
3959
3960 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3961 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3962 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3963
3964 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3965
3966
3967 SWIGINTERNINLINE int
3968 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3969 {
3970 unsigned long v;
3971 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3972 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3973 return res;
3974 }
3975
3976 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3977 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3978 wxMenuItemList& list = self->GetMenuItems();
3979 return wxPy_ConvertList(&list);
3980 }
3981 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3982 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3983 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3984 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3985 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3986 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3987 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3988 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3989 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3990 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3991 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3992 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3993 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3994 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3995 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3996 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3997 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3998 static const wxString wxPyControlNameStr(wxControlNameStr);
3999 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
4000 if (clientData) {
4001 wxPyClientData* data = new wxPyClientData(clientData);
4002 return self->Append(item, data);
4003 } else
4004 return self->Append(item);
4005 }
4006 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
4007 if (clientData) {
4008 wxPyClientData* data = new wxPyClientData(clientData);
4009 return self->Insert(item, pos, data);
4010 } else
4011 return self->Insert(item, pos);
4012 }
4013 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
4014 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4015 if (data) {
4016 Py_INCREF(data->m_obj);
4017 return data->m_obj;
4018 } else {
4019 Py_INCREF(Py_None);
4020 return Py_None;
4021 }
4022 }
4023 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
4024 wxPyClientData* data = new wxPyClientData(clientData);
4025 self->SetClientObject(n, data);
4026 }
4027
4028
4029 SWIGINTERN wxSizerFlags &wxSizerFlags_Border(wxSizerFlags *self,int direction=wxALL,int borderInPixels=-1){
4030 if (borderInPixels == -1)
4031 return self->Border(direction);
4032 else
4033 return self->Border(direction, borderInPixels);
4034 }
4035 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4036 wxPyUserData* data = NULL;
4037 if ( userData ) {
4038 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4039 data = new wxPyUserData(userData);
4040 wxPyEndBlockThreads(blocked);
4041 }
4042 return new wxSizerItem(window, proportion, flag, border, data);
4043 }
4044 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4045 wxPyUserData* data = NULL;
4046 if ( userData ) {
4047 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4048 data = new wxPyUserData(userData);
4049 wxPyEndBlockThreads(blocked);
4050 }
4051 return new wxSizerItem(width, height, proportion, flag, border, data);
4052 }
4053 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4054 wxPyUserData* data = NULL;
4055 if ( userData ) {
4056 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4057 data = new wxPyUserData(userData);
4058 wxPyEndBlockThreads(blocked);
4059 }
4060 return new wxSizerItem(sizer, proportion, flag, border, data);
4061 }
4062
4063 SWIGINTERNINLINE PyObject *
4064 SWIG_From_float (float value)
4065 {
4066 return SWIG_From_double (value);
4067 }
4068
4069 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4070 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4071 if (data) {
4072 Py_INCREF(data->m_obj);
4073 return data->m_obj;
4074 } else {
4075 Py_INCREF(Py_None);
4076 return Py_None;
4077 }
4078 }
4079 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4080 wxPyUserData* data = NULL;
4081 if ( userData ) {
4082 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4083 data = new wxPyUserData(userData);
4084 wxPyEndBlockThreads(blocked);
4085 }
4086 self->SetUserData(data);
4087 }
4088
4089 // Figure out the type of the sizer item
4090
4091 struct wxPySizerItemInfo {
4092 wxPySizerItemInfo()
4093 : window(NULL), sizer(NULL), gotSize(false),
4094 size(wxDefaultSize), gotPos(false), pos(-1)
4095 {}
4096
4097 wxWindow* window;
4098 wxSizer* sizer;
4099 bool gotSize;
4100 wxSize size;
4101 bool gotPos;
4102 int pos;
4103 };
4104
4105 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4106
4107 wxPySizerItemInfo info;
4108 wxSize size;
4109 wxSize* sizePtr = &size;
4110
4111 // Find out what the type of the item is
4112 // try wxWindow
4113 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4114 PyErr_Clear();
4115 info.window = NULL;
4116
4117 // try wxSizer
4118 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4119 PyErr_Clear();
4120 info.sizer = NULL;
4121
4122 // try wxSize or (w,h)
4123 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4124 info.size = *sizePtr;
4125 info.gotSize = true;
4126 }
4127
4128 // or a single int
4129 if (checkIdx && PyInt_Check(item)) {
4130 info.pos = PyInt_AsLong(item);
4131 info.gotPos = true;
4132 }
4133 }
4134 }
4135
4136 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4137 // no expected type, figure out what kind of error message to generate
4138 if ( !checkSize && !checkIdx )
4139 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4140 else if ( checkSize && !checkIdx )
4141 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4142 else if ( !checkSize && checkIdx)
4143 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4144 else
4145 // can this one happen?
4146 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4147 }
4148
4149 return info;
4150 }
4151
4152 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4153 if (!self->GetClientObject())
4154 self->SetClientObject(new wxPyOORClientData(_self));
4155 }
4156 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4157
4158 wxPyUserData* data = NULL;
4159 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4160 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4161 if ( userData && (info.window || info.sizer || info.gotSize) )
4162 data = new wxPyUserData(userData);
4163 if ( info.sizer )
4164 PyObject_SetAttrString(item,"thisown",Py_False);
4165 wxPyEndBlockThreads(blocked);
4166
4167 // Now call the real Add method if a valid item type was found
4168 if ( info.window )
4169 return self->Add(info.window, proportion, flag, border, data);
4170 else if ( info.sizer )
4171 return self->Add(info.sizer, proportion, flag, border, data);
4172 else if (info.gotSize)
4173 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4174 proportion, flag, border, data);
4175 else
4176 return NULL;
4177 }
4178 SWIGINTERN wxSizerItem *wxSizer_AddF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4179
4180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4181 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4182 if ( info.sizer )
4183 PyObject_SetAttrString(item,"thisown",Py_False);
4184 wxPyEndBlockThreads(blocked);
4185
4186 // Now call the real Add method if a valid item type was found
4187 if ( info.window )
4188 return self->Add(info.window, flags);
4189 else if ( info.sizer )
4190 return self->Add(info.sizer, flags);
4191 else if (info.gotSize)
4192 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4193 flags.GetProportion(),
4194 flags.GetFlags(),
4195 flags.GetBorderInPixels());
4196 else
4197 return NULL;
4198 }
4199 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4200
4201 wxPyUserData* data = NULL;
4202 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4203 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4204 if ( userData && (info.window || info.sizer || info.gotSize) )
4205 data = new wxPyUserData(userData);
4206 if ( info.sizer )
4207 PyObject_SetAttrString(item,"thisown",Py_False);
4208 wxPyEndBlockThreads(blocked);
4209
4210 // Now call the real Insert method if a valid item type was found
4211 if ( info.window )
4212 return self->Insert(before, info.window, proportion, flag, border, data);
4213 else if ( info.sizer )
4214 return self->Insert(before, info.sizer, proportion, flag, border, data);
4215 else if (info.gotSize)
4216 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4217 proportion, flag, border, data);
4218 else
4219 return NULL;
4220 }
4221 SWIGINTERN wxSizerItem *wxSizer_InsertF(wxSizer *self,int before,PyObject *item,wxSizerFlags &flags){
4222
4223 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4224 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4225 if ( info.sizer )
4226 PyObject_SetAttrString(item,"thisown",Py_False);
4227 wxPyEndBlockThreads(blocked);
4228
4229 // Now call the real Insert method if a valid item type was found
4230 if ( info.window )
4231 return self->Insert(before, info.window, flags);
4232 else if ( info.sizer )
4233 return self->Insert(before, info.sizer, flags);
4234 else if (info.gotSize)
4235 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4236 flags.GetProportion(),
4237 flags.GetFlags(),
4238 flags.GetBorderInPixels());
4239 else
4240 return NULL;
4241 }
4242 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4243
4244 wxPyUserData* data = NULL;
4245 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4246 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4247 if ( userData && (info.window || info.sizer || info.gotSize) )
4248 data = new wxPyUserData(userData);
4249 if ( info.sizer )
4250 PyObject_SetAttrString(item,"thisown",Py_False);
4251 wxPyEndBlockThreads(blocked);
4252
4253 // Now call the real Prepend method if a valid item type was found
4254 if ( info.window )
4255 return self->Prepend(info.window, proportion, flag, border, data);
4256 else if ( info.sizer )
4257 return self->Prepend(info.sizer, proportion, flag, border, data);
4258 else if (info.gotSize)
4259 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4260 proportion, flag, border, data);
4261 else
4262 return NULL;
4263 }
4264 SWIGINTERN wxSizerItem *wxSizer_PrependF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4265
4266 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4267 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4268 if ( info.sizer )
4269 PyObject_SetAttrString(item,"thisown",Py_False);
4270 wxPyEndBlockThreads(blocked);
4271
4272 // Now call the real Add method if a valid item type was found
4273 if ( info.window )
4274 return self->Prepend(info.window, flags);
4275 else if ( info.sizer )
4276 return self->Prepend(info.sizer, flags);
4277 else if (info.gotSize)
4278 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4279 flags.GetProportion(),
4280 flags.GetFlags(),
4281 flags.GetBorderInPixels());
4282 else
4283 return NULL;
4284 }
4285 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4286 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4287 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4288 wxPyEndBlockThreads(blocked);
4289 if ( info.window )
4290 return false; //self->Remove(info.window);
4291 else if ( info.sizer )
4292 return self->Remove(info.sizer);
4293 else if ( info.gotPos )
4294 return self->Remove(info.pos);
4295 else
4296 return false;
4297 }
4298 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4299 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4300 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4301 wxPyEndBlockThreads(blocked);
4302 if ( info.window )
4303 return self->Detach(info.window);
4304 else if ( info.sizer )
4305 return self->Detach(info.sizer);
4306 else if ( info.gotPos )
4307 return self->Detach(info.pos);
4308 else
4309 return false;
4310 }
4311 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item,bool recursive=false){
4312 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4313 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4314 wxPyEndBlockThreads(blocked);
4315 if ( info.window )
4316 return self->GetItem(info.window, recursive);
4317 else if ( info.sizer )
4318 return self->GetItem(info.sizer, recursive);
4319 else if ( info.gotPos )
4320 return self->GetItem(info.pos);
4321 else
4322 return NULL;
4323 }
4324 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4325 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4326 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4327 wxPyEndBlockThreads(blocked);
4328 if ( info.window )
4329 self->SetItemMinSize(info.window, size);
4330 else if ( info.sizer )
4331 self->SetItemMinSize(info.sizer, size);
4332 else if ( info.gotPos )
4333 self->SetItemMinSize(info.pos, size);
4334 }
4335 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4336 wxSizerItemList& list = self->GetChildren();
4337 return wxPy_ConvertList(&list);
4338 }
4339 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4341 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4342 wxPyEndBlockThreads(blocked);
4343 if ( info.window )
4344 return self->Show(info.window, show, recursive);
4345 else if ( info.sizer )
4346 return self->Show(info.sizer, show, recursive);
4347 else if ( info.gotPos )
4348 return self->Show(info.pos, show);
4349 else
4350 return false;
4351 }
4352 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4353 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4354 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4355 wxPyEndBlockThreads(blocked);
4356 if ( info.window )
4357 return self->IsShown(info.window);
4358 else if ( info.sizer )
4359 return self->IsShown(info.sizer);
4360 else if ( info.gotPos )
4361 return self->IsShown(info.pos);
4362 else
4363 return false;
4364 }
4365
4366 // See pyclasses.h
4367 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4368 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4369 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4370
4371
4372
4373
4374 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4375 {
4376 if (source == Py_None) {
4377 **obj = wxGBPosition(-1,-1);
4378 return true;
4379 }
4380 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4381 }
4382
4383 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4384 {
4385 if (source == Py_None) {
4386 **obj = wxGBSpan(-1,-1);
4387 return true;
4388 }
4389 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4390 }
4391
4392
4393 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4394 wxGBPosition temp, *obj = &temp;
4395 if ( other == Py_None ) return false;
4396 if ( ! wxGBPosition_helper(other, &obj) ) {
4397 PyErr_Clear();
4398 return false;
4399 }
4400 return self->operator==(*obj);
4401 }
4402 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4403 wxGBPosition temp, *obj = &temp;
4404 if ( other == Py_None ) return true;
4405 if ( ! wxGBPosition_helper(other, &obj)) {
4406 PyErr_Clear();
4407 return true;
4408 }
4409 return self->operator!=(*obj);
4410 }
4411 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4412 self->SetRow(row);
4413 self->SetCol(col);
4414 }
4415 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4416 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4417 PyObject* tup = PyTuple_New(2);
4418 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4419 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4420 wxPyEndBlockThreads(blocked);
4421 return tup;
4422 }
4423 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4424 wxGBSpan temp, *obj = &temp;
4425 if ( other == Py_None ) return false;
4426 if ( ! wxGBSpan_helper(other, &obj) ) {
4427 PyErr_Clear();
4428 return false;
4429 }
4430 return self->operator==(*obj);
4431 }
4432 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4433 wxGBSpan temp, *obj = &temp;
4434 if ( other == Py_None ) return true;
4435 if ( ! wxGBSpan_helper(other, &obj)) {
4436 PyErr_Clear();
4437 return true;
4438 }
4439 return self->operator!=(*obj);
4440 }
4441 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4442 self->SetRowspan(rowspan);
4443 self->SetColspan(colspan);
4444 }
4445 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4446 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4447 PyObject* tup = PyTuple_New(2);
4448 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4449 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4450 wxPyEndBlockThreads(blocked);
4451 return tup;
4452 }
4453 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4454 wxPyUserData* data = NULL;
4455 if ( userData ) {
4456 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4457 data = new wxPyUserData(userData);
4458 wxPyEndBlockThreads(blocked);
4459 }
4460 return new wxGBSizerItem(window, pos, span, flag, border, data);
4461 }
4462 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4463 wxPyUserData* data = NULL;
4464 if ( userData ) {
4465 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4466 data = new wxPyUserData(userData);
4467 wxPyEndBlockThreads(blocked);
4468 }
4469 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4470 }
4471 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4472 wxPyUserData* data = NULL;
4473 if ( userData ) {
4474 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4475 data = new wxPyUserData(userData);
4476 wxPyEndBlockThreads(blocked);
4477 }
4478 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4479 }
4480 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4481 int row, col;
4482 self->GetEndPos(row, col);
4483 return wxGBPosition(row, col);
4484 }
4485 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4486
4487 wxPyUserData* data = NULL;
4488 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4489 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4490 if ( userData && (info.window || info.sizer || info.gotSize) )
4491 data = new wxPyUserData(userData);
4492 if ( info.sizer )
4493 PyObject_SetAttrString(item,"thisown",Py_False);
4494 wxPyEndBlockThreads(blocked);
4495
4496 // Now call the real Add method if a valid item type was found
4497 if ( info.window )
4498 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4499 else if ( info.sizer )
4500 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4501 else if (info.gotSize)
4502 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4503 pos, span, flag, border, data);
4504 return NULL;
4505 }
4506
4507
4508 #ifdef __cplusplus
4509 extern "C" {
4510 #endif
4511 SWIGINTERN int EmptyString_set(PyObject *) {
4512 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4513 return 1;
4514 }
4515
4516
4517 SWIGINTERN PyObject *EmptyString_get(void) {
4518 PyObject *pyobj = 0;
4519
4520 {
4521 #if wxUSE_UNICODE
4522 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4523 #else
4524 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4525 #endif
4526 }
4527 return pyobj;
4528 }
4529
4530
4531 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4532 PyObject *resultobj = 0;
4533 wxObject *arg1 = (wxObject *) 0 ;
4534 wxString result;
4535 void *argp1 = 0 ;
4536 int res1 = 0 ;
4537 PyObject *swig_obj[1] ;
4538
4539 if (!args) SWIG_fail;
4540 swig_obj[0] = args;
4541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4542 if (!SWIG_IsOK(res1)) {
4543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4544 }
4545 arg1 = reinterpret_cast< wxObject * >(argp1);
4546 {
4547 PyThreadState* __tstate = wxPyBeginAllowThreads();
4548 result = wxObject_GetClassName(arg1);
4549 wxPyEndAllowThreads(__tstate);
4550 if (PyErr_Occurred()) SWIG_fail;
4551 }
4552 {
4553 #if wxUSE_UNICODE
4554 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4555 #else
4556 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4557 #endif
4558 }
4559 return resultobj;
4560 fail:
4561 return NULL;
4562 }
4563
4564
4565 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4566 PyObject *resultobj = 0;
4567 wxObject *arg1 = (wxObject *) 0 ;
4568 void *argp1 = 0 ;
4569 int res1 = 0 ;
4570 PyObject *swig_obj[1] ;
4571
4572 if (!args) SWIG_fail;
4573 swig_obj[0] = args;
4574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4575 if (!SWIG_IsOK(res1)) {
4576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4577 }
4578 arg1 = reinterpret_cast< wxObject * >(argp1);
4579 {
4580 PyThreadState* __tstate = wxPyBeginAllowThreads();
4581 wxObject_Destroy(arg1);
4582 wxPyEndAllowThreads(__tstate);
4583 if (PyErr_Occurred()) SWIG_fail;
4584 }
4585 resultobj = SWIG_Py_Void();
4586 return resultobj;
4587 fail:
4588 return NULL;
4589 }
4590
4591
4592 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4593 PyObject *resultobj = 0;
4594 wxObject *arg1 = (wxObject *) 0 ;
4595 wxObject *arg2 = 0 ;
4596 bool result;
4597 void *argp1 = 0 ;
4598 int res1 = 0 ;
4599 void *argp2 = 0 ;
4600 int res2 = 0 ;
4601 PyObject * obj0 = 0 ;
4602 PyObject * obj1 = 0 ;
4603 char * kwnames[] = {
4604 (char *) "self",(char *) "p", NULL
4605 };
4606
4607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4609 if (!SWIG_IsOK(res1)) {
4610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4611 }
4612 arg1 = reinterpret_cast< wxObject * >(argp1);
4613 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4614 if (!SWIG_IsOK(res2)) {
4615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4616 }
4617 if (!argp2) {
4618 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4619 }
4620 arg2 = reinterpret_cast< wxObject * >(argp2);
4621 {
4622 PyThreadState* __tstate = wxPyBeginAllowThreads();
4623 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4624 wxPyEndAllowThreads(__tstate);
4625 if (PyErr_Occurred()) SWIG_fail;
4626 }
4627 {
4628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4629 }
4630 return resultobj;
4631 fail:
4632 return NULL;
4633 }
4634
4635
4636 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4637 PyObject *obj;
4638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4639 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4640 return SWIG_Py_Void();
4641 }
4642
4643 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4644 PyObject *resultobj = 0;
4645 wxSize *arg1 = (wxSize *) 0 ;
4646 int arg2 ;
4647 void *argp1 = 0 ;
4648 int res1 = 0 ;
4649 int val2 ;
4650 int ecode2 = 0 ;
4651 PyObject *swig_obj[2] ;
4652
4653 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4655 if (!SWIG_IsOK(res1)) {
4656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4657 }
4658 arg1 = reinterpret_cast< wxSize * >(argp1);
4659 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4660 if (!SWIG_IsOK(ecode2)) {
4661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4662 }
4663 arg2 = static_cast< int >(val2);
4664 if (arg1) (arg1)->x = arg2;
4665
4666 resultobj = SWIG_Py_Void();
4667 return resultobj;
4668 fail:
4669 return NULL;
4670 }
4671
4672
4673 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4674 PyObject *resultobj = 0;
4675 wxSize *arg1 = (wxSize *) 0 ;
4676 int result;
4677 void *argp1 = 0 ;
4678 int res1 = 0 ;
4679 PyObject *swig_obj[1] ;
4680
4681 if (!args) SWIG_fail;
4682 swig_obj[0] = args;
4683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4684 if (!SWIG_IsOK(res1)) {
4685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4686 }
4687 arg1 = reinterpret_cast< wxSize * >(argp1);
4688 result = (int) ((arg1)->x);
4689 resultobj = SWIG_From_int(static_cast< int >(result));
4690 return resultobj;
4691 fail:
4692 return NULL;
4693 }
4694
4695
4696 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4697 PyObject *resultobj = 0;
4698 wxSize *arg1 = (wxSize *) 0 ;
4699 int arg2 ;
4700 void *argp1 = 0 ;
4701 int res1 = 0 ;
4702 int val2 ;
4703 int ecode2 = 0 ;
4704 PyObject *swig_obj[2] ;
4705
4706 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4708 if (!SWIG_IsOK(res1)) {
4709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4710 }
4711 arg1 = reinterpret_cast< wxSize * >(argp1);
4712 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4713 if (!SWIG_IsOK(ecode2)) {
4714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4715 }
4716 arg2 = static_cast< int >(val2);
4717 if (arg1) (arg1)->y = arg2;
4718
4719 resultobj = SWIG_Py_Void();
4720 return resultobj;
4721 fail:
4722 return NULL;
4723 }
4724
4725
4726 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4727 PyObject *resultobj = 0;
4728 wxSize *arg1 = (wxSize *) 0 ;
4729 int result;
4730 void *argp1 = 0 ;
4731 int res1 = 0 ;
4732 PyObject *swig_obj[1] ;
4733
4734 if (!args) SWIG_fail;
4735 swig_obj[0] = args;
4736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4737 if (!SWIG_IsOK(res1)) {
4738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4739 }
4740 arg1 = reinterpret_cast< wxSize * >(argp1);
4741 result = (int) ((arg1)->y);
4742 resultobj = SWIG_From_int(static_cast< int >(result));
4743 return resultobj;
4744 fail:
4745 return NULL;
4746 }
4747
4748
4749 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4750 PyObject *resultobj = 0;
4751 int arg1 = (int) 0 ;
4752 int arg2 = (int) 0 ;
4753 wxSize *result = 0 ;
4754 int val1 ;
4755 int ecode1 = 0 ;
4756 int val2 ;
4757 int ecode2 = 0 ;
4758 PyObject * obj0 = 0 ;
4759 PyObject * obj1 = 0 ;
4760 char * kwnames[] = {
4761 (char *) "w",(char *) "h", NULL
4762 };
4763
4764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4765 if (obj0) {
4766 ecode1 = SWIG_AsVal_int(obj0, &val1);
4767 if (!SWIG_IsOK(ecode1)) {
4768 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4769 }
4770 arg1 = static_cast< int >(val1);
4771 }
4772 if (obj1) {
4773 ecode2 = SWIG_AsVal_int(obj1, &val2);
4774 if (!SWIG_IsOK(ecode2)) {
4775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4776 }
4777 arg2 = static_cast< int >(val2);
4778 }
4779 {
4780 result = (wxSize *)new wxSize(arg1,arg2);
4781 if (PyErr_Occurred()) SWIG_fail;
4782 }
4783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4784 return resultobj;
4785 fail:
4786 return NULL;
4787 }
4788
4789
4790 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4791 PyObject *resultobj = 0;
4792 wxSize *arg1 = (wxSize *) 0 ;
4793 void *argp1 = 0 ;
4794 int res1 = 0 ;
4795 PyObject *swig_obj[1] ;
4796
4797 if (!args) SWIG_fail;
4798 swig_obj[0] = args;
4799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4800 if (!SWIG_IsOK(res1)) {
4801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4802 }
4803 arg1 = reinterpret_cast< wxSize * >(argp1);
4804 {
4805 delete arg1;
4806
4807 if (PyErr_Occurred()) SWIG_fail;
4808 }
4809 resultobj = SWIG_Py_Void();
4810 return resultobj;
4811 fail:
4812 return NULL;
4813 }
4814
4815
4816 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4817 PyObject *resultobj = 0;
4818 wxSize *arg1 = (wxSize *) 0 ;
4819 PyObject *arg2 = (PyObject *) 0 ;
4820 bool result;
4821 void *argp1 = 0 ;
4822 int res1 = 0 ;
4823 PyObject * obj0 = 0 ;
4824 PyObject * obj1 = 0 ;
4825 char * kwnames[] = {
4826 (char *) "self",(char *) "other", NULL
4827 };
4828
4829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4831 if (!SWIG_IsOK(res1)) {
4832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4833 }
4834 arg1 = reinterpret_cast< wxSize * >(argp1);
4835 arg2 = obj1;
4836 {
4837 result = (bool)wxSize___eq__(arg1,arg2);
4838 if (PyErr_Occurred()) SWIG_fail;
4839 }
4840 {
4841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4842 }
4843 return resultobj;
4844 fail:
4845 return NULL;
4846 }
4847
4848
4849 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4850 PyObject *resultobj = 0;
4851 wxSize *arg1 = (wxSize *) 0 ;
4852 PyObject *arg2 = (PyObject *) 0 ;
4853 bool result;
4854 void *argp1 = 0 ;
4855 int res1 = 0 ;
4856 PyObject * obj0 = 0 ;
4857 PyObject * obj1 = 0 ;
4858 char * kwnames[] = {
4859 (char *) "self",(char *) "other", NULL
4860 };
4861
4862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4864 if (!SWIG_IsOK(res1)) {
4865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4866 }
4867 arg1 = reinterpret_cast< wxSize * >(argp1);
4868 arg2 = obj1;
4869 {
4870 result = (bool)wxSize___ne__(arg1,arg2);
4871 if (PyErr_Occurred()) SWIG_fail;
4872 }
4873 {
4874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4875 }
4876 return resultobj;
4877 fail:
4878 return NULL;
4879 }
4880
4881
4882 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4883 PyObject *resultobj = 0;
4884 wxSize *arg1 = (wxSize *) 0 ;
4885 wxSize *arg2 = 0 ;
4886 wxSize result;
4887 void *argp1 = 0 ;
4888 int res1 = 0 ;
4889 wxSize temp2 ;
4890 PyObject * obj0 = 0 ;
4891 PyObject * obj1 = 0 ;
4892 char * kwnames[] = {
4893 (char *) "self",(char *) "sz", NULL
4894 };
4895
4896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4898 if (!SWIG_IsOK(res1)) {
4899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4900 }
4901 arg1 = reinterpret_cast< wxSize * >(argp1);
4902 {
4903 arg2 = &temp2;
4904 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4905 }
4906 {
4907 result = (arg1)->operator +((wxSize const &)*arg2);
4908 if (PyErr_Occurred()) SWIG_fail;
4909 }
4910 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4911 return resultobj;
4912 fail:
4913 return NULL;
4914 }
4915
4916
4917 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4918 PyObject *resultobj = 0;
4919 wxSize *arg1 = (wxSize *) 0 ;
4920 wxSize *arg2 = 0 ;
4921 wxSize result;
4922 void *argp1 = 0 ;
4923 int res1 = 0 ;
4924 wxSize temp2 ;
4925 PyObject * obj0 = 0 ;
4926 PyObject * obj1 = 0 ;
4927 char * kwnames[] = {
4928 (char *) "self",(char *) "sz", NULL
4929 };
4930
4931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4933 if (!SWIG_IsOK(res1)) {
4934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4935 }
4936 arg1 = reinterpret_cast< wxSize * >(argp1);
4937 {
4938 arg2 = &temp2;
4939 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4940 }
4941 {
4942 result = (arg1)->operator -((wxSize const &)*arg2);
4943 if (PyErr_Occurred()) SWIG_fail;
4944 }
4945 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4946 return resultobj;
4947 fail:
4948 return NULL;
4949 }
4950
4951
4952 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4953 PyObject *resultobj = 0;
4954 wxSize *arg1 = (wxSize *) 0 ;
4955 wxSize *arg2 = 0 ;
4956 void *argp1 = 0 ;
4957 int res1 = 0 ;
4958 wxSize temp2 ;
4959 PyObject * obj0 = 0 ;
4960 PyObject * obj1 = 0 ;
4961 char * kwnames[] = {
4962 (char *) "self",(char *) "sz", NULL
4963 };
4964
4965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4967 if (!SWIG_IsOK(res1)) {
4968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4969 }
4970 arg1 = reinterpret_cast< wxSize * >(argp1);
4971 {
4972 arg2 = &temp2;
4973 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4974 }
4975 {
4976 (arg1)->IncTo((wxSize const &)*arg2);
4977 if (PyErr_Occurred()) SWIG_fail;
4978 }
4979 resultobj = SWIG_Py_Void();
4980 return resultobj;
4981 fail:
4982 return NULL;
4983 }
4984
4985
4986 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4987 PyObject *resultobj = 0;
4988 wxSize *arg1 = (wxSize *) 0 ;
4989 wxSize *arg2 = 0 ;
4990 void *argp1 = 0 ;
4991 int res1 = 0 ;
4992 wxSize temp2 ;
4993 PyObject * obj0 = 0 ;
4994 PyObject * obj1 = 0 ;
4995 char * kwnames[] = {
4996 (char *) "self",(char *) "sz", NULL
4997 };
4998
4999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
5000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5001 if (!SWIG_IsOK(res1)) {
5002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
5003 }
5004 arg1 = reinterpret_cast< wxSize * >(argp1);
5005 {
5006 arg2 = &temp2;
5007 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5008 }
5009 {
5010 (arg1)->DecTo((wxSize const &)*arg2);
5011 if (PyErr_Occurred()) SWIG_fail;
5012 }
5013 resultobj = SWIG_Py_Void();
5014 return resultobj;
5015 fail:
5016 return NULL;
5017 }
5018
5019
5020 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5021 PyObject *resultobj = 0;
5022 wxSize *arg1 = (wxSize *) 0 ;
5023 int arg2 ;
5024 int arg3 ;
5025 void *argp1 = 0 ;
5026 int res1 = 0 ;
5027 int val2 ;
5028 int ecode2 = 0 ;
5029 int val3 ;
5030 int ecode3 = 0 ;
5031 PyObject * obj0 = 0 ;
5032 PyObject * obj1 = 0 ;
5033 PyObject * obj2 = 0 ;
5034 char * kwnames[] = {
5035 (char *) "self",(char *) "dx",(char *) "dy", NULL
5036 };
5037
5038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5040 if (!SWIG_IsOK(res1)) {
5041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
5042 }
5043 arg1 = reinterpret_cast< wxSize * >(argp1);
5044 ecode2 = SWIG_AsVal_int(obj1, &val2);
5045 if (!SWIG_IsOK(ecode2)) {
5046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
5047 }
5048 arg2 = static_cast< int >(val2);
5049 ecode3 = SWIG_AsVal_int(obj2, &val3);
5050 if (!SWIG_IsOK(ecode3)) {
5051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
5052 }
5053 arg3 = static_cast< int >(val3);
5054 {
5055 (arg1)->IncBy(arg2,arg3);
5056 if (PyErr_Occurred()) SWIG_fail;
5057 }
5058 resultobj = SWIG_Py_Void();
5059 return resultobj;
5060 fail:
5061 return NULL;
5062 }
5063
5064
5065 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5066 PyObject *resultobj = 0;
5067 wxSize *arg1 = (wxSize *) 0 ;
5068 int arg2 ;
5069 int arg3 ;
5070 void *argp1 = 0 ;
5071 int res1 = 0 ;
5072 int val2 ;
5073 int ecode2 = 0 ;
5074 int val3 ;
5075 int ecode3 = 0 ;
5076 PyObject * obj0 = 0 ;
5077 PyObject * obj1 = 0 ;
5078 PyObject * obj2 = 0 ;
5079 char * kwnames[] = {
5080 (char *) "self",(char *) "dx",(char *) "dy", NULL
5081 };
5082
5083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5085 if (!SWIG_IsOK(res1)) {
5086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5087 }
5088 arg1 = reinterpret_cast< wxSize * >(argp1);
5089 ecode2 = SWIG_AsVal_int(obj1, &val2);
5090 if (!SWIG_IsOK(ecode2)) {
5091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5092 }
5093 arg2 = static_cast< int >(val2);
5094 ecode3 = SWIG_AsVal_int(obj2, &val3);
5095 if (!SWIG_IsOK(ecode3)) {
5096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5097 }
5098 arg3 = static_cast< int >(val3);
5099 {
5100 (arg1)->DecBy(arg2,arg3);
5101 if (PyErr_Occurred()) SWIG_fail;
5102 }
5103 resultobj = SWIG_Py_Void();
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj = 0;
5112 wxSize *arg1 = (wxSize *) 0 ;
5113 float arg2 ;
5114 float arg3 ;
5115 void *argp1 = 0 ;
5116 int res1 = 0 ;
5117 float val2 ;
5118 int ecode2 = 0 ;
5119 float val3 ;
5120 int ecode3 = 0 ;
5121 PyObject * obj0 = 0 ;
5122 PyObject * obj1 = 0 ;
5123 PyObject * obj2 = 0 ;
5124 char * kwnames[] = {
5125 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5126 };
5127
5128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5130 if (!SWIG_IsOK(res1)) {
5131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5132 }
5133 arg1 = reinterpret_cast< wxSize * >(argp1);
5134 ecode2 = SWIG_AsVal_float(obj1, &val2);
5135 if (!SWIG_IsOK(ecode2)) {
5136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5137 }
5138 arg2 = static_cast< float >(val2);
5139 ecode3 = SWIG_AsVal_float(obj2, &val3);
5140 if (!SWIG_IsOK(ecode3)) {
5141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5142 }
5143 arg3 = static_cast< float >(val3);
5144 {
5145 (arg1)->Scale(arg2,arg3);
5146 if (PyErr_Occurred()) SWIG_fail;
5147 }
5148 resultobj = SWIG_Py_Void();
5149 return resultobj;
5150 fail:
5151 return NULL;
5152 }
5153
5154
5155 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5156 PyObject *resultobj = 0;
5157 wxSize *arg1 = (wxSize *) 0 ;
5158 int arg2 ;
5159 int arg3 ;
5160 void *argp1 = 0 ;
5161 int res1 = 0 ;
5162 int val2 ;
5163 int ecode2 = 0 ;
5164 int val3 ;
5165 int ecode3 = 0 ;
5166 PyObject * obj0 = 0 ;
5167 PyObject * obj1 = 0 ;
5168 PyObject * obj2 = 0 ;
5169 char * kwnames[] = {
5170 (char *) "self",(char *) "w",(char *) "h", NULL
5171 };
5172
5173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5175 if (!SWIG_IsOK(res1)) {
5176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5177 }
5178 arg1 = reinterpret_cast< wxSize * >(argp1);
5179 ecode2 = SWIG_AsVal_int(obj1, &val2);
5180 if (!SWIG_IsOK(ecode2)) {
5181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5182 }
5183 arg2 = static_cast< int >(val2);
5184 ecode3 = SWIG_AsVal_int(obj2, &val3);
5185 if (!SWIG_IsOK(ecode3)) {
5186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5187 }
5188 arg3 = static_cast< int >(val3);
5189 {
5190 (arg1)->Set(arg2,arg3);
5191 if (PyErr_Occurred()) SWIG_fail;
5192 }
5193 resultobj = SWIG_Py_Void();
5194 return resultobj;
5195 fail:
5196 return NULL;
5197 }
5198
5199
5200 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5201 PyObject *resultobj = 0;
5202 wxSize *arg1 = (wxSize *) 0 ;
5203 int arg2 ;
5204 void *argp1 = 0 ;
5205 int res1 = 0 ;
5206 int val2 ;
5207 int ecode2 = 0 ;
5208 PyObject * obj0 = 0 ;
5209 PyObject * obj1 = 0 ;
5210 char * kwnames[] = {
5211 (char *) "self",(char *) "w", NULL
5212 };
5213
5214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5216 if (!SWIG_IsOK(res1)) {
5217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5218 }
5219 arg1 = reinterpret_cast< wxSize * >(argp1);
5220 ecode2 = SWIG_AsVal_int(obj1, &val2);
5221 if (!SWIG_IsOK(ecode2)) {
5222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5223 }
5224 arg2 = static_cast< int >(val2);
5225 {
5226 (arg1)->SetWidth(arg2);
5227 if (PyErr_Occurred()) SWIG_fail;
5228 }
5229 resultobj = SWIG_Py_Void();
5230 return resultobj;
5231 fail:
5232 return NULL;
5233 }
5234
5235
5236 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5237 PyObject *resultobj = 0;
5238 wxSize *arg1 = (wxSize *) 0 ;
5239 int arg2 ;
5240 void *argp1 = 0 ;
5241 int res1 = 0 ;
5242 int val2 ;
5243 int ecode2 = 0 ;
5244 PyObject * obj0 = 0 ;
5245 PyObject * obj1 = 0 ;
5246 char * kwnames[] = {
5247 (char *) "self",(char *) "h", NULL
5248 };
5249
5250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5252 if (!SWIG_IsOK(res1)) {
5253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5254 }
5255 arg1 = reinterpret_cast< wxSize * >(argp1);
5256 ecode2 = SWIG_AsVal_int(obj1, &val2);
5257 if (!SWIG_IsOK(ecode2)) {
5258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5259 }
5260 arg2 = static_cast< int >(val2);
5261 {
5262 (arg1)->SetHeight(arg2);
5263 if (PyErr_Occurred()) SWIG_fail;
5264 }
5265 resultobj = SWIG_Py_Void();
5266 return resultobj;
5267 fail:
5268 return NULL;
5269 }
5270
5271
5272 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5273 PyObject *resultobj = 0;
5274 wxSize *arg1 = (wxSize *) 0 ;
5275 int result;
5276 void *argp1 = 0 ;
5277 int res1 = 0 ;
5278 PyObject *swig_obj[1] ;
5279
5280 if (!args) SWIG_fail;
5281 swig_obj[0] = args;
5282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5283 if (!SWIG_IsOK(res1)) {
5284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5285 }
5286 arg1 = reinterpret_cast< wxSize * >(argp1);
5287 {
5288 result = (int)((wxSize const *)arg1)->GetWidth();
5289 if (PyErr_Occurred()) SWIG_fail;
5290 }
5291 resultobj = SWIG_From_int(static_cast< int >(result));
5292 return resultobj;
5293 fail:
5294 return NULL;
5295 }
5296
5297
5298 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5299 PyObject *resultobj = 0;
5300 wxSize *arg1 = (wxSize *) 0 ;
5301 int result;
5302 void *argp1 = 0 ;
5303 int res1 = 0 ;
5304 PyObject *swig_obj[1] ;
5305
5306 if (!args) SWIG_fail;
5307 swig_obj[0] = args;
5308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5309 if (!SWIG_IsOK(res1)) {
5310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5311 }
5312 arg1 = reinterpret_cast< wxSize * >(argp1);
5313 {
5314 result = (int)((wxSize const *)arg1)->GetHeight();
5315 if (PyErr_Occurred()) SWIG_fail;
5316 }
5317 resultobj = SWIG_From_int(static_cast< int >(result));
5318 return resultobj;
5319 fail:
5320 return NULL;
5321 }
5322
5323
5324 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5325 PyObject *resultobj = 0;
5326 wxSize *arg1 = (wxSize *) 0 ;
5327 bool result;
5328 void *argp1 = 0 ;
5329 int res1 = 0 ;
5330 PyObject *swig_obj[1] ;
5331
5332 if (!args) SWIG_fail;
5333 swig_obj[0] = args;
5334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5335 if (!SWIG_IsOK(res1)) {
5336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5337 }
5338 arg1 = reinterpret_cast< wxSize * >(argp1);
5339 {
5340 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5341 if (PyErr_Occurred()) SWIG_fail;
5342 }
5343 {
5344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5345 }
5346 return resultobj;
5347 fail:
5348 return NULL;
5349 }
5350
5351
5352 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5353 PyObject *resultobj = 0;
5354 wxSize *arg1 = (wxSize *) 0 ;
5355 wxSize *arg2 = 0 ;
5356 void *argp1 = 0 ;
5357 int res1 = 0 ;
5358 wxSize temp2 ;
5359 PyObject * obj0 = 0 ;
5360 PyObject * obj1 = 0 ;
5361 char * kwnames[] = {
5362 (char *) "self",(char *) "size", NULL
5363 };
5364
5365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5367 if (!SWIG_IsOK(res1)) {
5368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5369 }
5370 arg1 = reinterpret_cast< wxSize * >(argp1);
5371 {
5372 arg2 = &temp2;
5373 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5374 }
5375 {
5376 (arg1)->SetDefaults((wxSize const &)*arg2);
5377 if (PyErr_Occurred()) SWIG_fail;
5378 }
5379 resultobj = SWIG_Py_Void();
5380 return resultobj;
5381 fail:
5382 return NULL;
5383 }
5384
5385
5386 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5387 PyObject *resultobj = 0;
5388 wxSize *arg1 = (wxSize *) 0 ;
5389 PyObject *result = 0 ;
5390 void *argp1 = 0 ;
5391 int res1 = 0 ;
5392 PyObject *swig_obj[1] ;
5393
5394 if (!args) SWIG_fail;
5395 swig_obj[0] = args;
5396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5397 if (!SWIG_IsOK(res1)) {
5398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5399 }
5400 arg1 = reinterpret_cast< wxSize * >(argp1);
5401 {
5402 result = (PyObject *)wxSize_Get(arg1);
5403 if (PyErr_Occurred()) SWIG_fail;
5404 }
5405 resultobj = result;
5406 return resultobj;
5407 fail:
5408 return NULL;
5409 }
5410
5411
5412 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5413 PyObject *obj;
5414 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5415 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5416 return SWIG_Py_Void();
5417 }
5418
5419 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5420 return SWIG_Python_InitShadowInstance(args);
5421 }
5422
5423 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5424 PyObject *resultobj = 0;
5425 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5426 double arg2 ;
5427 void *argp1 = 0 ;
5428 int res1 = 0 ;
5429 double val2 ;
5430 int ecode2 = 0 ;
5431 PyObject *swig_obj[2] ;
5432
5433 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5435 if (!SWIG_IsOK(res1)) {
5436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5437 }
5438 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5439 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5440 if (!SWIG_IsOK(ecode2)) {
5441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5442 }
5443 arg2 = static_cast< double >(val2);
5444 if (arg1) (arg1)->x = arg2;
5445
5446 resultobj = SWIG_Py_Void();
5447 return resultobj;
5448 fail:
5449 return NULL;
5450 }
5451
5452
5453 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5454 PyObject *resultobj = 0;
5455 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5456 double result;
5457 void *argp1 = 0 ;
5458 int res1 = 0 ;
5459 PyObject *swig_obj[1] ;
5460
5461 if (!args) SWIG_fail;
5462 swig_obj[0] = args;
5463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5464 if (!SWIG_IsOK(res1)) {
5465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5466 }
5467 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5468 result = (double) ((arg1)->x);
5469 resultobj = SWIG_From_double(static_cast< double >(result));
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5477 PyObject *resultobj = 0;
5478 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5479 double arg2 ;
5480 void *argp1 = 0 ;
5481 int res1 = 0 ;
5482 double val2 ;
5483 int ecode2 = 0 ;
5484 PyObject *swig_obj[2] ;
5485
5486 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5488 if (!SWIG_IsOK(res1)) {
5489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5490 }
5491 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5492 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5493 if (!SWIG_IsOK(ecode2)) {
5494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5495 }
5496 arg2 = static_cast< double >(val2);
5497 if (arg1) (arg1)->y = arg2;
5498
5499 resultobj = SWIG_Py_Void();
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5507 PyObject *resultobj = 0;
5508 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5509 double result;
5510 void *argp1 = 0 ;
5511 int res1 = 0 ;
5512 PyObject *swig_obj[1] ;
5513
5514 if (!args) SWIG_fail;
5515 swig_obj[0] = args;
5516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5517 if (!SWIG_IsOK(res1)) {
5518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5519 }
5520 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5521 result = (double) ((arg1)->y);
5522 resultobj = SWIG_From_double(static_cast< double >(result));
5523 return resultobj;
5524 fail:
5525 return NULL;
5526 }
5527
5528
5529 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5530 PyObject *resultobj = 0;
5531 double arg1 = (double) 0.0 ;
5532 double arg2 = (double) 0.0 ;
5533 wxRealPoint *result = 0 ;
5534 double val1 ;
5535 int ecode1 = 0 ;
5536 double val2 ;
5537 int ecode2 = 0 ;
5538 PyObject * obj0 = 0 ;
5539 PyObject * obj1 = 0 ;
5540 char * kwnames[] = {
5541 (char *) "x",(char *) "y", NULL
5542 };
5543
5544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5545 if (obj0) {
5546 ecode1 = SWIG_AsVal_double(obj0, &val1);
5547 if (!SWIG_IsOK(ecode1)) {
5548 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5549 }
5550 arg1 = static_cast< double >(val1);
5551 }
5552 if (obj1) {
5553 ecode2 = SWIG_AsVal_double(obj1, &val2);
5554 if (!SWIG_IsOK(ecode2)) {
5555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5556 }
5557 arg2 = static_cast< double >(val2);
5558 }
5559 {
5560 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5561 if (PyErr_Occurred()) SWIG_fail;
5562 }
5563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5564 return resultobj;
5565 fail:
5566 return NULL;
5567 }
5568
5569
5570 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5571 PyObject *resultobj = 0;
5572 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5573 void *argp1 = 0 ;
5574 int res1 = 0 ;
5575 PyObject *swig_obj[1] ;
5576
5577 if (!args) SWIG_fail;
5578 swig_obj[0] = args;
5579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5580 if (!SWIG_IsOK(res1)) {
5581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5582 }
5583 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5584 {
5585 delete arg1;
5586
5587 if (PyErr_Occurred()) SWIG_fail;
5588 }
5589 resultobj = SWIG_Py_Void();
5590 return resultobj;
5591 fail:
5592 return NULL;
5593 }
5594
5595
5596 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5597 PyObject *resultobj = 0;
5598 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5599 PyObject *arg2 = (PyObject *) 0 ;
5600 bool result;
5601 void *argp1 = 0 ;
5602 int res1 = 0 ;
5603 PyObject * obj0 = 0 ;
5604 PyObject * obj1 = 0 ;
5605 char * kwnames[] = {
5606 (char *) "self",(char *) "other", NULL
5607 };
5608
5609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5611 if (!SWIG_IsOK(res1)) {
5612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5613 }
5614 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5615 arg2 = obj1;
5616 {
5617 result = (bool)wxRealPoint___eq__(arg1,arg2);
5618 if (PyErr_Occurred()) SWIG_fail;
5619 }
5620 {
5621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5622 }
5623 return resultobj;
5624 fail:
5625 return NULL;
5626 }
5627
5628
5629 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5630 PyObject *resultobj = 0;
5631 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5632 PyObject *arg2 = (PyObject *) 0 ;
5633 bool result;
5634 void *argp1 = 0 ;
5635 int res1 = 0 ;
5636 PyObject * obj0 = 0 ;
5637 PyObject * obj1 = 0 ;
5638 char * kwnames[] = {
5639 (char *) "self",(char *) "other", NULL
5640 };
5641
5642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5644 if (!SWIG_IsOK(res1)) {
5645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5646 }
5647 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5648 arg2 = obj1;
5649 {
5650 result = (bool)wxRealPoint___ne__(arg1,arg2);
5651 if (PyErr_Occurred()) SWIG_fail;
5652 }
5653 {
5654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5655 }
5656 return resultobj;
5657 fail:
5658 return NULL;
5659 }
5660
5661
5662 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5663 PyObject *resultobj = 0;
5664 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5665 wxRealPoint *arg2 = 0 ;
5666 wxRealPoint result;
5667 void *argp1 = 0 ;
5668 int res1 = 0 ;
5669 wxRealPoint temp2 ;
5670 PyObject * obj0 = 0 ;
5671 PyObject * obj1 = 0 ;
5672 char * kwnames[] = {
5673 (char *) "self",(char *) "pt", NULL
5674 };
5675
5676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5678 if (!SWIG_IsOK(res1)) {
5679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5680 }
5681 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5682 {
5683 arg2 = &temp2;
5684 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5685 }
5686 {
5687 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5688 if (PyErr_Occurred()) SWIG_fail;
5689 }
5690 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5691 return resultobj;
5692 fail:
5693 return NULL;
5694 }
5695
5696
5697 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5698 PyObject *resultobj = 0;
5699 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5700 wxRealPoint *arg2 = 0 ;
5701 wxRealPoint result;
5702 void *argp1 = 0 ;
5703 int res1 = 0 ;
5704 wxRealPoint temp2 ;
5705 PyObject * obj0 = 0 ;
5706 PyObject * obj1 = 0 ;
5707 char * kwnames[] = {
5708 (char *) "self",(char *) "pt", NULL
5709 };
5710
5711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5713 if (!SWIG_IsOK(res1)) {
5714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5715 }
5716 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5717 {
5718 arg2 = &temp2;
5719 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5720 }
5721 {
5722 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5723 if (PyErr_Occurred()) SWIG_fail;
5724 }
5725 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5726 return resultobj;
5727 fail:
5728 return NULL;
5729 }
5730
5731
5732 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5733 PyObject *resultobj = 0;
5734 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5735 double arg2 ;
5736 double arg3 ;
5737 void *argp1 = 0 ;
5738 int res1 = 0 ;
5739 double val2 ;
5740 int ecode2 = 0 ;
5741 double val3 ;
5742 int ecode3 = 0 ;
5743 PyObject * obj0 = 0 ;
5744 PyObject * obj1 = 0 ;
5745 PyObject * obj2 = 0 ;
5746 char * kwnames[] = {
5747 (char *) "self",(char *) "x",(char *) "y", NULL
5748 };
5749
5750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5752 if (!SWIG_IsOK(res1)) {
5753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5754 }
5755 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5756 ecode2 = SWIG_AsVal_double(obj1, &val2);
5757 if (!SWIG_IsOK(ecode2)) {
5758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5759 }
5760 arg2 = static_cast< double >(val2);
5761 ecode3 = SWIG_AsVal_double(obj2, &val3);
5762 if (!SWIG_IsOK(ecode3)) {
5763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5764 }
5765 arg3 = static_cast< double >(val3);
5766 {
5767 wxRealPoint_Set(arg1,arg2,arg3);
5768 if (PyErr_Occurred()) SWIG_fail;
5769 }
5770 resultobj = SWIG_Py_Void();
5771 return resultobj;
5772 fail:
5773 return NULL;
5774 }
5775
5776
5777 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5778 PyObject *resultobj = 0;
5779 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5780 PyObject *result = 0 ;
5781 void *argp1 = 0 ;
5782 int res1 = 0 ;
5783 PyObject *swig_obj[1] ;
5784
5785 if (!args) SWIG_fail;
5786 swig_obj[0] = args;
5787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5788 if (!SWIG_IsOK(res1)) {
5789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5790 }
5791 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5792 {
5793 result = (PyObject *)wxRealPoint_Get(arg1);
5794 if (PyErr_Occurred()) SWIG_fail;
5795 }
5796 resultobj = result;
5797 return resultobj;
5798 fail:
5799 return NULL;
5800 }
5801
5802
5803 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5804 PyObject *obj;
5805 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5806 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5807 return SWIG_Py_Void();
5808 }
5809
5810 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5811 return SWIG_Python_InitShadowInstance(args);
5812 }
5813
5814 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5815 PyObject *resultobj = 0;
5816 wxPoint *arg1 = (wxPoint *) 0 ;
5817 int arg2 ;
5818 void *argp1 = 0 ;
5819 int res1 = 0 ;
5820 int val2 ;
5821 int ecode2 = 0 ;
5822 PyObject *swig_obj[2] ;
5823
5824 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5826 if (!SWIG_IsOK(res1)) {
5827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5828 }
5829 arg1 = reinterpret_cast< wxPoint * >(argp1);
5830 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5831 if (!SWIG_IsOK(ecode2)) {
5832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5833 }
5834 arg2 = static_cast< int >(val2);
5835 if (arg1) (arg1)->x = arg2;
5836
5837 resultobj = SWIG_Py_Void();
5838 return resultobj;
5839 fail:
5840 return NULL;
5841 }
5842
5843
5844 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5845 PyObject *resultobj = 0;
5846 wxPoint *arg1 = (wxPoint *) 0 ;
5847 int result;
5848 void *argp1 = 0 ;
5849 int res1 = 0 ;
5850 PyObject *swig_obj[1] ;
5851
5852 if (!args) SWIG_fail;
5853 swig_obj[0] = args;
5854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5855 if (!SWIG_IsOK(res1)) {
5856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5857 }
5858 arg1 = reinterpret_cast< wxPoint * >(argp1);
5859 result = (int) ((arg1)->x);
5860 resultobj = SWIG_From_int(static_cast< int >(result));
5861 return resultobj;
5862 fail:
5863 return NULL;
5864 }
5865
5866
5867 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5868 PyObject *resultobj = 0;
5869 wxPoint *arg1 = (wxPoint *) 0 ;
5870 int arg2 ;
5871 void *argp1 = 0 ;
5872 int res1 = 0 ;
5873 int val2 ;
5874 int ecode2 = 0 ;
5875 PyObject *swig_obj[2] ;
5876
5877 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5879 if (!SWIG_IsOK(res1)) {
5880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5881 }
5882 arg1 = reinterpret_cast< wxPoint * >(argp1);
5883 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5884 if (!SWIG_IsOK(ecode2)) {
5885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5886 }
5887 arg2 = static_cast< int >(val2);
5888 if (arg1) (arg1)->y = arg2;
5889
5890 resultobj = SWIG_Py_Void();
5891 return resultobj;
5892 fail:
5893 return NULL;
5894 }
5895
5896
5897 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5898 PyObject *resultobj = 0;
5899 wxPoint *arg1 = (wxPoint *) 0 ;
5900 int result;
5901 void *argp1 = 0 ;
5902 int res1 = 0 ;
5903 PyObject *swig_obj[1] ;
5904
5905 if (!args) SWIG_fail;
5906 swig_obj[0] = args;
5907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5908 if (!SWIG_IsOK(res1)) {
5909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5910 }
5911 arg1 = reinterpret_cast< wxPoint * >(argp1);
5912 result = (int) ((arg1)->y);
5913 resultobj = SWIG_From_int(static_cast< int >(result));
5914 return resultobj;
5915 fail:
5916 return NULL;
5917 }
5918
5919
5920 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5921 PyObject *resultobj = 0;
5922 int arg1 = (int) 0 ;
5923 int arg2 = (int) 0 ;
5924 wxPoint *result = 0 ;
5925 int val1 ;
5926 int ecode1 = 0 ;
5927 int val2 ;
5928 int ecode2 = 0 ;
5929 PyObject * obj0 = 0 ;
5930 PyObject * obj1 = 0 ;
5931 char * kwnames[] = {
5932 (char *) "x",(char *) "y", NULL
5933 };
5934
5935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5936 if (obj0) {
5937 ecode1 = SWIG_AsVal_int(obj0, &val1);
5938 if (!SWIG_IsOK(ecode1)) {
5939 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5940 }
5941 arg1 = static_cast< int >(val1);
5942 }
5943 if (obj1) {
5944 ecode2 = SWIG_AsVal_int(obj1, &val2);
5945 if (!SWIG_IsOK(ecode2)) {
5946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5947 }
5948 arg2 = static_cast< int >(val2);
5949 }
5950 {
5951 result = (wxPoint *)new wxPoint(arg1,arg2);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5955 return resultobj;
5956 fail:
5957 return NULL;
5958 }
5959
5960
5961 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5962 PyObject *resultobj = 0;
5963 wxPoint *arg1 = (wxPoint *) 0 ;
5964 void *argp1 = 0 ;
5965 int res1 = 0 ;
5966 PyObject *swig_obj[1] ;
5967
5968 if (!args) SWIG_fail;
5969 swig_obj[0] = args;
5970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5971 if (!SWIG_IsOK(res1)) {
5972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5973 }
5974 arg1 = reinterpret_cast< wxPoint * >(argp1);
5975 {
5976 delete arg1;
5977
5978 if (PyErr_Occurred()) SWIG_fail;
5979 }
5980 resultobj = SWIG_Py_Void();
5981 return resultobj;
5982 fail:
5983 return NULL;
5984 }
5985
5986
5987 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5988 PyObject *resultobj = 0;
5989 wxPoint *arg1 = (wxPoint *) 0 ;
5990 PyObject *arg2 = (PyObject *) 0 ;
5991 bool result;
5992 void *argp1 = 0 ;
5993 int res1 = 0 ;
5994 PyObject * obj0 = 0 ;
5995 PyObject * obj1 = 0 ;
5996 char * kwnames[] = {
5997 (char *) "self",(char *) "other", NULL
5998 };
5999
6000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
6001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6002 if (!SWIG_IsOK(res1)) {
6003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
6004 }
6005 arg1 = reinterpret_cast< wxPoint * >(argp1);
6006 arg2 = obj1;
6007 {
6008 result = (bool)wxPoint___eq__(arg1,arg2);
6009 if (PyErr_Occurred()) SWIG_fail;
6010 }
6011 {
6012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6013 }
6014 return resultobj;
6015 fail:
6016 return NULL;
6017 }
6018
6019
6020 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6021 PyObject *resultobj = 0;
6022 wxPoint *arg1 = (wxPoint *) 0 ;
6023 PyObject *arg2 = (PyObject *) 0 ;
6024 bool result;
6025 void *argp1 = 0 ;
6026 int res1 = 0 ;
6027 PyObject * obj0 = 0 ;
6028 PyObject * obj1 = 0 ;
6029 char * kwnames[] = {
6030 (char *) "self",(char *) "other", NULL
6031 };
6032
6033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
6034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6035 if (!SWIG_IsOK(res1)) {
6036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
6037 }
6038 arg1 = reinterpret_cast< wxPoint * >(argp1);
6039 arg2 = obj1;
6040 {
6041 result = (bool)wxPoint___ne__(arg1,arg2);
6042 if (PyErr_Occurred()) SWIG_fail;
6043 }
6044 {
6045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6046 }
6047 return resultobj;
6048 fail:
6049 return NULL;
6050 }
6051
6052
6053 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6054 PyObject *resultobj = 0;
6055 wxPoint *arg1 = (wxPoint *) 0 ;
6056 wxPoint *arg2 = 0 ;
6057 wxPoint result;
6058 void *argp1 = 0 ;
6059 int res1 = 0 ;
6060 wxPoint temp2 ;
6061 PyObject * obj0 = 0 ;
6062 PyObject * obj1 = 0 ;
6063 char * kwnames[] = {
6064 (char *) "self",(char *) "pt", NULL
6065 };
6066
6067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
6068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6069 if (!SWIG_IsOK(res1)) {
6070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
6071 }
6072 arg1 = reinterpret_cast< wxPoint * >(argp1);
6073 {
6074 arg2 = &temp2;
6075 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6076 }
6077 {
6078 result = (arg1)->operator +((wxPoint const &)*arg2);
6079 if (PyErr_Occurred()) SWIG_fail;
6080 }
6081 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6082 return resultobj;
6083 fail:
6084 return NULL;
6085 }
6086
6087
6088 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6089 PyObject *resultobj = 0;
6090 wxPoint *arg1 = (wxPoint *) 0 ;
6091 wxPoint *arg2 = 0 ;
6092 wxPoint result;
6093 void *argp1 = 0 ;
6094 int res1 = 0 ;
6095 wxPoint temp2 ;
6096 PyObject * obj0 = 0 ;
6097 PyObject * obj1 = 0 ;
6098 char * kwnames[] = {
6099 (char *) "self",(char *) "pt", NULL
6100 };
6101
6102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6104 if (!SWIG_IsOK(res1)) {
6105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6106 }
6107 arg1 = reinterpret_cast< wxPoint * >(argp1);
6108 {
6109 arg2 = &temp2;
6110 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6111 }
6112 {
6113 result = (arg1)->operator -((wxPoint const &)*arg2);
6114 if (PyErr_Occurred()) SWIG_fail;
6115 }
6116 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6117 return resultobj;
6118 fail:
6119 return NULL;
6120 }
6121
6122
6123 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6124 PyObject *resultobj = 0;
6125 wxPoint *arg1 = (wxPoint *) 0 ;
6126 wxPoint *arg2 = 0 ;
6127 wxPoint *result = 0 ;
6128 void *argp1 = 0 ;
6129 int res1 = 0 ;
6130 wxPoint temp2 ;
6131 PyObject * obj0 = 0 ;
6132 PyObject * obj1 = 0 ;
6133 char * kwnames[] = {
6134 (char *) "self",(char *) "pt", NULL
6135 };
6136
6137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6139 if (!SWIG_IsOK(res1)) {
6140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6141 }
6142 arg1 = reinterpret_cast< wxPoint * >(argp1);
6143 {
6144 arg2 = &temp2;
6145 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6146 }
6147 {
6148 {
6149 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6150 result = (wxPoint *) &_result_ref;
6151 }
6152 if (PyErr_Occurred()) SWIG_fail;
6153 }
6154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6155 return resultobj;
6156 fail:
6157 return NULL;
6158 }
6159
6160
6161 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6162 PyObject *resultobj = 0;
6163 wxPoint *arg1 = (wxPoint *) 0 ;
6164 wxPoint *arg2 = 0 ;
6165 wxPoint *result = 0 ;
6166 void *argp1 = 0 ;
6167 int res1 = 0 ;
6168 wxPoint temp2 ;
6169 PyObject * obj0 = 0 ;
6170 PyObject * obj1 = 0 ;
6171 char * kwnames[] = {
6172 (char *) "self",(char *) "pt", NULL
6173 };
6174
6175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6177 if (!SWIG_IsOK(res1)) {
6178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6179 }
6180 arg1 = reinterpret_cast< wxPoint * >(argp1);
6181 {
6182 arg2 = &temp2;
6183 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6184 }
6185 {
6186 {
6187 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6188 result = (wxPoint *) &_result_ref;
6189 }
6190 if (PyErr_Occurred()) SWIG_fail;
6191 }
6192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6193 return resultobj;
6194 fail:
6195 return NULL;
6196 }
6197
6198
6199 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6200 PyObject *resultobj = 0;
6201 wxPoint *arg1 = (wxPoint *) 0 ;
6202 long arg2 ;
6203 long arg3 ;
6204 void *argp1 = 0 ;
6205 int res1 = 0 ;
6206 long val2 ;
6207 int ecode2 = 0 ;
6208 long val3 ;
6209 int ecode3 = 0 ;
6210 PyObject * obj0 = 0 ;
6211 PyObject * obj1 = 0 ;
6212 PyObject * obj2 = 0 ;
6213 char * kwnames[] = {
6214 (char *) "self",(char *) "x",(char *) "y", NULL
6215 };
6216
6217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6219 if (!SWIG_IsOK(res1)) {
6220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6221 }
6222 arg1 = reinterpret_cast< wxPoint * >(argp1);
6223 ecode2 = SWIG_AsVal_long(obj1, &val2);
6224 if (!SWIG_IsOK(ecode2)) {
6225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6226 }
6227 arg2 = static_cast< long >(val2);
6228 ecode3 = SWIG_AsVal_long(obj2, &val3);
6229 if (!SWIG_IsOK(ecode3)) {
6230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6231 }
6232 arg3 = static_cast< long >(val3);
6233 {
6234 wxPoint_Set(arg1,arg2,arg3);
6235 if (PyErr_Occurred()) SWIG_fail;
6236 }
6237 resultobj = SWIG_Py_Void();
6238 return resultobj;
6239 fail:
6240 return NULL;
6241 }
6242
6243
6244 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6245 PyObject *resultobj = 0;
6246 wxPoint *arg1 = (wxPoint *) 0 ;
6247 PyObject *result = 0 ;
6248 void *argp1 = 0 ;
6249 int res1 = 0 ;
6250 PyObject *swig_obj[1] ;
6251
6252 if (!args) SWIG_fail;
6253 swig_obj[0] = args;
6254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6255 if (!SWIG_IsOK(res1)) {
6256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6257 }
6258 arg1 = reinterpret_cast< wxPoint * >(argp1);
6259 {
6260 result = (PyObject *)wxPoint_Get(arg1);
6261 if (PyErr_Occurred()) SWIG_fail;
6262 }
6263 resultobj = result;
6264 return resultobj;
6265 fail:
6266 return NULL;
6267 }
6268
6269
6270 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6271 PyObject *obj;
6272 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6273 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6274 return SWIG_Py_Void();
6275 }
6276
6277 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6278 return SWIG_Python_InitShadowInstance(args);
6279 }
6280
6281 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6282 PyObject *resultobj = 0;
6283 int arg1 = (int) 0 ;
6284 int arg2 = (int) 0 ;
6285 int arg3 = (int) 0 ;
6286 int arg4 = (int) 0 ;
6287 wxRect *result = 0 ;
6288 int val1 ;
6289 int ecode1 = 0 ;
6290 int val2 ;
6291 int ecode2 = 0 ;
6292 int val3 ;
6293 int ecode3 = 0 ;
6294 int val4 ;
6295 int ecode4 = 0 ;
6296 PyObject * obj0 = 0 ;
6297 PyObject * obj1 = 0 ;
6298 PyObject * obj2 = 0 ;
6299 PyObject * obj3 = 0 ;
6300 char * kwnames[] = {
6301 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6302 };
6303
6304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6305 if (obj0) {
6306 ecode1 = SWIG_AsVal_int(obj0, &val1);
6307 if (!SWIG_IsOK(ecode1)) {
6308 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6309 }
6310 arg1 = static_cast< int >(val1);
6311 }
6312 if (obj1) {
6313 ecode2 = SWIG_AsVal_int(obj1, &val2);
6314 if (!SWIG_IsOK(ecode2)) {
6315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6316 }
6317 arg2 = static_cast< int >(val2);
6318 }
6319 if (obj2) {
6320 ecode3 = SWIG_AsVal_int(obj2, &val3);
6321 if (!SWIG_IsOK(ecode3)) {
6322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6323 }
6324 arg3 = static_cast< int >(val3);
6325 }
6326 if (obj3) {
6327 ecode4 = SWIG_AsVal_int(obj3, &val4);
6328 if (!SWIG_IsOK(ecode4)) {
6329 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6330 }
6331 arg4 = static_cast< int >(val4);
6332 }
6333 {
6334 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6335 if (PyErr_Occurred()) SWIG_fail;
6336 }
6337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6338 return resultobj;
6339 fail:
6340 return NULL;
6341 }
6342
6343
6344 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6345 PyObject *resultobj = 0;
6346 wxPoint *arg1 = 0 ;
6347 wxPoint *arg2 = 0 ;
6348 wxRect *result = 0 ;
6349 wxPoint temp1 ;
6350 wxPoint temp2 ;
6351 PyObject * obj0 = 0 ;
6352 PyObject * obj1 = 0 ;
6353 char * kwnames[] = {
6354 (char *) "topLeft",(char *) "bottomRight", NULL
6355 };
6356
6357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6358 {
6359 arg1 = &temp1;
6360 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6361 }
6362 {
6363 arg2 = &temp2;
6364 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6365 }
6366 {
6367 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6368 if (PyErr_Occurred()) SWIG_fail;
6369 }
6370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6371 return resultobj;
6372 fail:
6373 return NULL;
6374 }
6375
6376
6377 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6378 PyObject *resultobj = 0;
6379 wxPoint *arg1 = 0 ;
6380 wxSize *arg2 = 0 ;
6381 wxRect *result = 0 ;
6382 wxPoint temp1 ;
6383 wxSize temp2 ;
6384 PyObject * obj0 = 0 ;
6385 PyObject * obj1 = 0 ;
6386 char * kwnames[] = {
6387 (char *) "pos",(char *) "size", NULL
6388 };
6389
6390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6391 {
6392 arg1 = &temp1;
6393 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6394 }
6395 {
6396 arg2 = &temp2;
6397 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6398 }
6399 {
6400 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6401 if (PyErr_Occurred()) SWIG_fail;
6402 }
6403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6404 return resultobj;
6405 fail:
6406 return NULL;
6407 }
6408
6409
6410 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6411 PyObject *resultobj = 0;
6412 wxSize *arg1 = 0 ;
6413 wxRect *result = 0 ;
6414 wxSize temp1 ;
6415 PyObject * obj0 = 0 ;
6416 char * kwnames[] = {
6417 (char *) "size", NULL
6418 };
6419
6420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6421 {
6422 arg1 = &temp1;
6423 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6424 }
6425 {
6426 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6427 if (PyErr_Occurred()) SWIG_fail;
6428 }
6429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6430 return resultobj;
6431 fail:
6432 return NULL;
6433 }
6434
6435
6436 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6437 PyObject *resultobj = 0;
6438 wxRect *arg1 = (wxRect *) 0 ;
6439 void *argp1 = 0 ;
6440 int res1 = 0 ;
6441 PyObject *swig_obj[1] ;
6442
6443 if (!args) SWIG_fail;
6444 swig_obj[0] = args;
6445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6446 if (!SWIG_IsOK(res1)) {
6447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6448 }
6449 arg1 = reinterpret_cast< wxRect * >(argp1);
6450 {
6451 delete arg1;
6452
6453 if (PyErr_Occurred()) SWIG_fail;
6454 }
6455 resultobj = SWIG_Py_Void();
6456 return resultobj;
6457 fail:
6458 return NULL;
6459 }
6460
6461
6462 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6463 PyObject *resultobj = 0;
6464 wxRect *arg1 = (wxRect *) 0 ;
6465 int result;
6466 void *argp1 = 0 ;
6467 int res1 = 0 ;
6468 PyObject *swig_obj[1] ;
6469
6470 if (!args) SWIG_fail;
6471 swig_obj[0] = args;
6472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6473 if (!SWIG_IsOK(res1)) {
6474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6475 }
6476 arg1 = reinterpret_cast< wxRect * >(argp1);
6477 {
6478 result = (int)((wxRect const *)arg1)->GetX();
6479 if (PyErr_Occurred()) SWIG_fail;
6480 }
6481 resultobj = SWIG_From_int(static_cast< int >(result));
6482 return resultobj;
6483 fail:
6484 return NULL;
6485 }
6486
6487
6488 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6489 PyObject *resultobj = 0;
6490 wxRect *arg1 = (wxRect *) 0 ;
6491 int arg2 ;
6492 void *argp1 = 0 ;
6493 int res1 = 0 ;
6494 int val2 ;
6495 int ecode2 = 0 ;
6496 PyObject * obj0 = 0 ;
6497 PyObject * obj1 = 0 ;
6498 char * kwnames[] = {
6499 (char *) "self",(char *) "x", NULL
6500 };
6501
6502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6504 if (!SWIG_IsOK(res1)) {
6505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6506 }
6507 arg1 = reinterpret_cast< wxRect * >(argp1);
6508 ecode2 = SWIG_AsVal_int(obj1, &val2);
6509 if (!SWIG_IsOK(ecode2)) {
6510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6511 }
6512 arg2 = static_cast< int >(val2);
6513 {
6514 (arg1)->SetX(arg2);
6515 if (PyErr_Occurred()) SWIG_fail;
6516 }
6517 resultobj = SWIG_Py_Void();
6518 return resultobj;
6519 fail:
6520 return NULL;
6521 }
6522
6523
6524 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6525 PyObject *resultobj = 0;
6526 wxRect *arg1 = (wxRect *) 0 ;
6527 int result;
6528 void *argp1 = 0 ;
6529 int res1 = 0 ;
6530 PyObject *swig_obj[1] ;
6531
6532 if (!args) SWIG_fail;
6533 swig_obj[0] = args;
6534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6535 if (!SWIG_IsOK(res1)) {
6536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6537 }
6538 arg1 = reinterpret_cast< wxRect * >(argp1);
6539 {
6540 result = (int)(arg1)->GetY();
6541 if (PyErr_Occurred()) SWIG_fail;
6542 }
6543 resultobj = SWIG_From_int(static_cast< int >(result));
6544 return resultobj;
6545 fail:
6546 return NULL;
6547 }
6548
6549
6550 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6551 PyObject *resultobj = 0;
6552 wxRect *arg1 = (wxRect *) 0 ;
6553 int arg2 ;
6554 void *argp1 = 0 ;
6555 int res1 = 0 ;
6556 int val2 ;
6557 int ecode2 = 0 ;
6558 PyObject * obj0 = 0 ;
6559 PyObject * obj1 = 0 ;
6560 char * kwnames[] = {
6561 (char *) "self",(char *) "y", NULL
6562 };
6563
6564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6566 if (!SWIG_IsOK(res1)) {
6567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6568 }
6569 arg1 = reinterpret_cast< wxRect * >(argp1);
6570 ecode2 = SWIG_AsVal_int(obj1, &val2);
6571 if (!SWIG_IsOK(ecode2)) {
6572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6573 }
6574 arg2 = static_cast< int >(val2);
6575 {
6576 (arg1)->SetY(arg2);
6577 if (PyErr_Occurred()) SWIG_fail;
6578 }
6579 resultobj = SWIG_Py_Void();
6580 return resultobj;
6581 fail:
6582 return NULL;
6583 }
6584
6585
6586 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6587 PyObject *resultobj = 0;
6588 wxRect *arg1 = (wxRect *) 0 ;
6589 int result;
6590 void *argp1 = 0 ;
6591 int res1 = 0 ;
6592 PyObject *swig_obj[1] ;
6593
6594 if (!args) SWIG_fail;
6595 swig_obj[0] = args;
6596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6597 if (!SWIG_IsOK(res1)) {
6598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6599 }
6600 arg1 = reinterpret_cast< wxRect * >(argp1);
6601 {
6602 result = (int)((wxRect const *)arg1)->GetWidth();
6603 if (PyErr_Occurred()) SWIG_fail;
6604 }
6605 resultobj = SWIG_From_int(static_cast< int >(result));
6606 return resultobj;
6607 fail:
6608 return NULL;
6609 }
6610
6611
6612 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6613 PyObject *resultobj = 0;
6614 wxRect *arg1 = (wxRect *) 0 ;
6615 int arg2 ;
6616 void *argp1 = 0 ;
6617 int res1 = 0 ;
6618 int val2 ;
6619 int ecode2 = 0 ;
6620 PyObject * obj0 = 0 ;
6621 PyObject * obj1 = 0 ;
6622 char * kwnames[] = {
6623 (char *) "self",(char *) "w", NULL
6624 };
6625
6626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6628 if (!SWIG_IsOK(res1)) {
6629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6630 }
6631 arg1 = reinterpret_cast< wxRect * >(argp1);
6632 ecode2 = SWIG_AsVal_int(obj1, &val2);
6633 if (!SWIG_IsOK(ecode2)) {
6634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6635 }
6636 arg2 = static_cast< int >(val2);
6637 {
6638 (arg1)->SetWidth(arg2);
6639 if (PyErr_Occurred()) SWIG_fail;
6640 }
6641 resultobj = SWIG_Py_Void();
6642 return resultobj;
6643 fail:
6644 return NULL;
6645 }
6646
6647
6648 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6649 PyObject *resultobj = 0;
6650 wxRect *arg1 = (wxRect *) 0 ;
6651 int result;
6652 void *argp1 = 0 ;
6653 int res1 = 0 ;
6654 PyObject *swig_obj[1] ;
6655
6656 if (!args) SWIG_fail;
6657 swig_obj[0] = args;
6658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6659 if (!SWIG_IsOK(res1)) {
6660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6661 }
6662 arg1 = reinterpret_cast< wxRect * >(argp1);
6663 {
6664 result = (int)((wxRect const *)arg1)->GetHeight();
6665 if (PyErr_Occurred()) SWIG_fail;
6666 }
6667 resultobj = SWIG_From_int(static_cast< int >(result));
6668 return resultobj;
6669 fail:
6670 return NULL;
6671 }
6672
6673
6674 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6675 PyObject *resultobj = 0;
6676 wxRect *arg1 = (wxRect *) 0 ;
6677 int arg2 ;
6678 void *argp1 = 0 ;
6679 int res1 = 0 ;
6680 int val2 ;
6681 int ecode2 = 0 ;
6682 PyObject * obj0 = 0 ;
6683 PyObject * obj1 = 0 ;
6684 char * kwnames[] = {
6685 (char *) "self",(char *) "h", NULL
6686 };
6687
6688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6690 if (!SWIG_IsOK(res1)) {
6691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6692 }
6693 arg1 = reinterpret_cast< wxRect * >(argp1);
6694 ecode2 = SWIG_AsVal_int(obj1, &val2);
6695 if (!SWIG_IsOK(ecode2)) {
6696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6697 }
6698 arg2 = static_cast< int >(val2);
6699 {
6700 (arg1)->SetHeight(arg2);
6701 if (PyErr_Occurred()) SWIG_fail;
6702 }
6703 resultobj = SWIG_Py_Void();
6704 return resultobj;
6705 fail:
6706 return NULL;
6707 }
6708
6709
6710 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6711 PyObject *resultobj = 0;
6712 wxRect *arg1 = (wxRect *) 0 ;
6713 wxPoint result;
6714 void *argp1 = 0 ;
6715 int res1 = 0 ;
6716 PyObject *swig_obj[1] ;
6717
6718 if (!args) SWIG_fail;
6719 swig_obj[0] = args;
6720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6721 if (!SWIG_IsOK(res1)) {
6722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6723 }
6724 arg1 = reinterpret_cast< wxRect * >(argp1);
6725 {
6726 result = ((wxRect const *)arg1)->GetPosition();
6727 if (PyErr_Occurred()) SWIG_fail;
6728 }
6729 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6730 return resultobj;
6731 fail:
6732 return NULL;
6733 }
6734
6735
6736 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6737 PyObject *resultobj = 0;
6738 wxRect *arg1 = (wxRect *) 0 ;
6739 wxPoint *arg2 = 0 ;
6740 void *argp1 = 0 ;
6741 int res1 = 0 ;
6742 wxPoint temp2 ;
6743 PyObject * obj0 = 0 ;
6744 PyObject * obj1 = 0 ;
6745 char * kwnames[] = {
6746 (char *) "self",(char *) "p", NULL
6747 };
6748
6749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6751 if (!SWIG_IsOK(res1)) {
6752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6753 }
6754 arg1 = reinterpret_cast< wxRect * >(argp1);
6755 {
6756 arg2 = &temp2;
6757 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6758 }
6759 {
6760 (arg1)->SetPosition((wxPoint const &)*arg2);
6761 if (PyErr_Occurred()) SWIG_fail;
6762 }
6763 resultobj = SWIG_Py_Void();
6764 return resultobj;
6765 fail:
6766 return NULL;
6767 }
6768
6769
6770 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6771 PyObject *resultobj = 0;
6772 wxRect *arg1 = (wxRect *) 0 ;
6773 wxSize result;
6774 void *argp1 = 0 ;
6775 int res1 = 0 ;
6776 PyObject *swig_obj[1] ;
6777
6778 if (!args) SWIG_fail;
6779 swig_obj[0] = args;
6780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6781 if (!SWIG_IsOK(res1)) {
6782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6783 }
6784 arg1 = reinterpret_cast< wxRect * >(argp1);
6785 {
6786 result = ((wxRect const *)arg1)->GetSize();
6787 if (PyErr_Occurred()) SWIG_fail;
6788 }
6789 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6790 return resultobj;
6791 fail:
6792 return NULL;
6793 }
6794
6795
6796 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6797 PyObject *resultobj = 0;
6798 wxRect *arg1 = (wxRect *) 0 ;
6799 wxSize *arg2 = 0 ;
6800 void *argp1 = 0 ;
6801 int res1 = 0 ;
6802 wxSize temp2 ;
6803 PyObject * obj0 = 0 ;
6804 PyObject * obj1 = 0 ;
6805 char * kwnames[] = {
6806 (char *) "self",(char *) "s", NULL
6807 };
6808
6809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6811 if (!SWIG_IsOK(res1)) {
6812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6813 }
6814 arg1 = reinterpret_cast< wxRect * >(argp1);
6815 {
6816 arg2 = &temp2;
6817 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6818 }
6819 {
6820 (arg1)->SetSize((wxSize const &)*arg2);
6821 if (PyErr_Occurred()) SWIG_fail;
6822 }
6823 resultobj = SWIG_Py_Void();
6824 return resultobj;
6825 fail:
6826 return NULL;
6827 }
6828
6829
6830 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6831 PyObject *resultobj = 0;
6832 wxRect *arg1 = (wxRect *) 0 ;
6833 bool result;
6834 void *argp1 = 0 ;
6835 int res1 = 0 ;
6836 PyObject *swig_obj[1] ;
6837
6838 if (!args) SWIG_fail;
6839 swig_obj[0] = args;
6840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6841 if (!SWIG_IsOK(res1)) {
6842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6843 }
6844 arg1 = reinterpret_cast< wxRect * >(argp1);
6845 {
6846 result = (bool)((wxRect const *)arg1)->IsEmpty();
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 {
6850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6851 }
6852 return resultobj;
6853 fail:
6854 return NULL;
6855 }
6856
6857
6858 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6859 PyObject *resultobj = 0;
6860 wxRect *arg1 = (wxRect *) 0 ;
6861 wxPoint result;
6862 void *argp1 = 0 ;
6863 int res1 = 0 ;
6864 PyObject *swig_obj[1] ;
6865
6866 if (!args) SWIG_fail;
6867 swig_obj[0] = args;
6868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6869 if (!SWIG_IsOK(res1)) {
6870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6871 }
6872 arg1 = reinterpret_cast< wxRect * >(argp1);
6873 {
6874 result = ((wxRect const *)arg1)->GetTopLeft();
6875 if (PyErr_Occurred()) SWIG_fail;
6876 }
6877 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6878 return resultobj;
6879 fail:
6880 return NULL;
6881 }
6882
6883
6884 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6885 PyObject *resultobj = 0;
6886 wxRect *arg1 = (wxRect *) 0 ;
6887 wxPoint *arg2 = 0 ;
6888 void *argp1 = 0 ;
6889 int res1 = 0 ;
6890 wxPoint temp2 ;
6891 PyObject * obj0 = 0 ;
6892 PyObject * obj1 = 0 ;
6893 char * kwnames[] = {
6894 (char *) "self",(char *) "p", NULL
6895 };
6896
6897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6899 if (!SWIG_IsOK(res1)) {
6900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6901 }
6902 arg1 = reinterpret_cast< wxRect * >(argp1);
6903 {
6904 arg2 = &temp2;
6905 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6906 }
6907 {
6908 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6909 if (PyErr_Occurred()) SWIG_fail;
6910 }
6911 resultobj = SWIG_Py_Void();
6912 return resultobj;
6913 fail:
6914 return NULL;
6915 }
6916
6917
6918 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6919 PyObject *resultobj = 0;
6920 wxRect *arg1 = (wxRect *) 0 ;
6921 wxPoint result;
6922 void *argp1 = 0 ;
6923 int res1 = 0 ;
6924 PyObject *swig_obj[1] ;
6925
6926 if (!args) SWIG_fail;
6927 swig_obj[0] = args;
6928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6929 if (!SWIG_IsOK(res1)) {
6930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6931 }
6932 arg1 = reinterpret_cast< wxRect * >(argp1);
6933 {
6934 result = ((wxRect const *)arg1)->GetBottomRight();
6935 if (PyErr_Occurred()) SWIG_fail;
6936 }
6937 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6938 return resultobj;
6939 fail:
6940 return NULL;
6941 }
6942
6943
6944 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6945 PyObject *resultobj = 0;
6946 wxRect *arg1 = (wxRect *) 0 ;
6947 wxPoint *arg2 = 0 ;
6948 void *argp1 = 0 ;
6949 int res1 = 0 ;
6950 wxPoint temp2 ;
6951 PyObject * obj0 = 0 ;
6952 PyObject * obj1 = 0 ;
6953 char * kwnames[] = {
6954 (char *) "self",(char *) "p", NULL
6955 };
6956
6957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6959 if (!SWIG_IsOK(res1)) {
6960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6961 }
6962 arg1 = reinterpret_cast< wxRect * >(argp1);
6963 {
6964 arg2 = &temp2;
6965 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6966 }
6967 {
6968 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6969 if (PyErr_Occurred()) SWIG_fail;
6970 }
6971 resultobj = SWIG_Py_Void();
6972 return resultobj;
6973 fail:
6974 return NULL;
6975 }
6976
6977
6978 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6979 PyObject *resultobj = 0;
6980 wxRect *arg1 = (wxRect *) 0 ;
6981 wxPoint result;
6982 void *argp1 = 0 ;
6983 int res1 = 0 ;
6984 PyObject *swig_obj[1] ;
6985
6986 if (!args) SWIG_fail;
6987 swig_obj[0] = args;
6988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6989 if (!SWIG_IsOK(res1)) {
6990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6991 }
6992 arg1 = reinterpret_cast< wxRect * >(argp1);
6993 {
6994 result = ((wxRect const *)arg1)->GetTopRight();
6995 if (PyErr_Occurred()) SWIG_fail;
6996 }
6997 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6998 return resultobj;
6999 fail:
7000 return NULL;
7001 }
7002
7003
7004 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7005 PyObject *resultobj = 0;
7006 wxRect *arg1 = (wxRect *) 0 ;
7007 wxPoint *arg2 = 0 ;
7008 void *argp1 = 0 ;
7009 int res1 = 0 ;
7010 wxPoint temp2 ;
7011 PyObject * obj0 = 0 ;
7012 PyObject * obj1 = 0 ;
7013 char * kwnames[] = {
7014 (char *) "self",(char *) "p", NULL
7015 };
7016
7017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
7018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7019 if (!SWIG_IsOK(res1)) {
7020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
7021 }
7022 arg1 = reinterpret_cast< wxRect * >(argp1);
7023 {
7024 arg2 = &temp2;
7025 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7026 }
7027 {
7028 (arg1)->SetTopRight((wxPoint const &)*arg2);
7029 if (PyErr_Occurred()) SWIG_fail;
7030 }
7031 resultobj = SWIG_Py_Void();
7032 return resultobj;
7033 fail:
7034 return NULL;
7035 }
7036
7037
7038 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7039 PyObject *resultobj = 0;
7040 wxRect *arg1 = (wxRect *) 0 ;
7041 wxPoint result;
7042 void *argp1 = 0 ;
7043 int res1 = 0 ;
7044 PyObject *swig_obj[1] ;
7045
7046 if (!args) SWIG_fail;
7047 swig_obj[0] = args;
7048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7049 if (!SWIG_IsOK(res1)) {
7050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7051 }
7052 arg1 = reinterpret_cast< wxRect * >(argp1);
7053 {
7054 result = ((wxRect const *)arg1)->GetBottomLeft();
7055 if (PyErr_Occurred()) SWIG_fail;
7056 }
7057 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7058 return resultobj;
7059 fail:
7060 return NULL;
7061 }
7062
7063
7064 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7065 PyObject *resultobj = 0;
7066 wxRect *arg1 = (wxRect *) 0 ;
7067 wxPoint *arg2 = 0 ;
7068 void *argp1 = 0 ;
7069 int res1 = 0 ;
7070 wxPoint temp2 ;
7071 PyObject * obj0 = 0 ;
7072 PyObject * obj1 = 0 ;
7073 char * kwnames[] = {
7074 (char *) "self",(char *) "p", NULL
7075 };
7076
7077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7079 if (!SWIG_IsOK(res1)) {
7080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7081 }
7082 arg1 = reinterpret_cast< wxRect * >(argp1);
7083 {
7084 arg2 = &temp2;
7085 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7086 }
7087 {
7088 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7089 if (PyErr_Occurred()) SWIG_fail;
7090 }
7091 resultobj = SWIG_Py_Void();
7092 return resultobj;
7093 fail:
7094 return NULL;
7095 }
7096
7097
7098 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7099 PyObject *resultobj = 0;
7100 wxRect *arg1 = (wxRect *) 0 ;
7101 int result;
7102 void *argp1 = 0 ;
7103 int res1 = 0 ;
7104 PyObject *swig_obj[1] ;
7105
7106 if (!args) SWIG_fail;
7107 swig_obj[0] = args;
7108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7109 if (!SWIG_IsOK(res1)) {
7110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7111 }
7112 arg1 = reinterpret_cast< wxRect * >(argp1);
7113 {
7114 result = (int)((wxRect const *)arg1)->GetLeft();
7115 if (PyErr_Occurred()) SWIG_fail;
7116 }
7117 resultobj = SWIG_From_int(static_cast< int >(result));
7118 return resultobj;
7119 fail:
7120 return NULL;
7121 }
7122
7123
7124 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7125 PyObject *resultobj = 0;
7126 wxRect *arg1 = (wxRect *) 0 ;
7127 int result;
7128 void *argp1 = 0 ;
7129 int res1 = 0 ;
7130 PyObject *swig_obj[1] ;
7131
7132 if (!args) SWIG_fail;
7133 swig_obj[0] = args;
7134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7135 if (!SWIG_IsOK(res1)) {
7136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7137 }
7138 arg1 = reinterpret_cast< wxRect * >(argp1);
7139 {
7140 result = (int)((wxRect const *)arg1)->GetTop();
7141 if (PyErr_Occurred()) SWIG_fail;
7142 }
7143 resultobj = SWIG_From_int(static_cast< int >(result));
7144 return resultobj;
7145 fail:
7146 return NULL;
7147 }
7148
7149
7150 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7151 PyObject *resultobj = 0;
7152 wxRect *arg1 = (wxRect *) 0 ;
7153 int result;
7154 void *argp1 = 0 ;
7155 int res1 = 0 ;
7156 PyObject *swig_obj[1] ;
7157
7158 if (!args) SWIG_fail;
7159 swig_obj[0] = args;
7160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7161 if (!SWIG_IsOK(res1)) {
7162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7163 }
7164 arg1 = reinterpret_cast< wxRect * >(argp1);
7165 {
7166 result = (int)((wxRect const *)arg1)->GetBottom();
7167 if (PyErr_Occurred()) SWIG_fail;
7168 }
7169 resultobj = SWIG_From_int(static_cast< int >(result));
7170 return resultobj;
7171 fail:
7172 return NULL;
7173 }
7174
7175
7176 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7177 PyObject *resultobj = 0;
7178 wxRect *arg1 = (wxRect *) 0 ;
7179 int result;
7180 void *argp1 = 0 ;
7181 int res1 = 0 ;
7182 PyObject *swig_obj[1] ;
7183
7184 if (!args) SWIG_fail;
7185 swig_obj[0] = args;
7186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7187 if (!SWIG_IsOK(res1)) {
7188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7189 }
7190 arg1 = reinterpret_cast< wxRect * >(argp1);
7191 {
7192 result = (int)((wxRect const *)arg1)->GetRight();
7193 if (PyErr_Occurred()) SWIG_fail;
7194 }
7195 resultobj = SWIG_From_int(static_cast< int >(result));
7196 return resultobj;
7197 fail:
7198 return NULL;
7199 }
7200
7201
7202 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7203 PyObject *resultobj = 0;
7204 wxRect *arg1 = (wxRect *) 0 ;
7205 int arg2 ;
7206 void *argp1 = 0 ;
7207 int res1 = 0 ;
7208 int val2 ;
7209 int ecode2 = 0 ;
7210 PyObject * obj0 = 0 ;
7211 PyObject * obj1 = 0 ;
7212 char * kwnames[] = {
7213 (char *) "self",(char *) "left", NULL
7214 };
7215
7216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7218 if (!SWIG_IsOK(res1)) {
7219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7220 }
7221 arg1 = reinterpret_cast< wxRect * >(argp1);
7222 ecode2 = SWIG_AsVal_int(obj1, &val2);
7223 if (!SWIG_IsOK(ecode2)) {
7224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7225 }
7226 arg2 = static_cast< int >(val2);
7227 {
7228 (arg1)->SetLeft(arg2);
7229 if (PyErr_Occurred()) SWIG_fail;
7230 }
7231 resultobj = SWIG_Py_Void();
7232 return resultobj;
7233 fail:
7234 return NULL;
7235 }
7236
7237
7238 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7239 PyObject *resultobj = 0;
7240 wxRect *arg1 = (wxRect *) 0 ;
7241 int arg2 ;
7242 void *argp1 = 0 ;
7243 int res1 = 0 ;
7244 int val2 ;
7245 int ecode2 = 0 ;
7246 PyObject * obj0 = 0 ;
7247 PyObject * obj1 = 0 ;
7248 char * kwnames[] = {
7249 (char *) "self",(char *) "right", NULL
7250 };
7251
7252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7254 if (!SWIG_IsOK(res1)) {
7255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7256 }
7257 arg1 = reinterpret_cast< wxRect * >(argp1);
7258 ecode2 = SWIG_AsVal_int(obj1, &val2);
7259 if (!SWIG_IsOK(ecode2)) {
7260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7261 }
7262 arg2 = static_cast< int >(val2);
7263 {
7264 (arg1)->SetRight(arg2);
7265 if (PyErr_Occurred()) SWIG_fail;
7266 }
7267 resultobj = SWIG_Py_Void();
7268 return resultobj;
7269 fail:
7270 return NULL;
7271 }
7272
7273
7274 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7275 PyObject *resultobj = 0;
7276 wxRect *arg1 = (wxRect *) 0 ;
7277 int arg2 ;
7278 void *argp1 = 0 ;
7279 int res1 = 0 ;
7280 int val2 ;
7281 int ecode2 = 0 ;
7282 PyObject * obj0 = 0 ;
7283 PyObject * obj1 = 0 ;
7284 char * kwnames[] = {
7285 (char *) "self",(char *) "top", NULL
7286 };
7287
7288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7290 if (!SWIG_IsOK(res1)) {
7291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7292 }
7293 arg1 = reinterpret_cast< wxRect * >(argp1);
7294 ecode2 = SWIG_AsVal_int(obj1, &val2);
7295 if (!SWIG_IsOK(ecode2)) {
7296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7297 }
7298 arg2 = static_cast< int >(val2);
7299 {
7300 (arg1)->SetTop(arg2);
7301 if (PyErr_Occurred()) SWIG_fail;
7302 }
7303 resultobj = SWIG_Py_Void();
7304 return resultobj;
7305 fail:
7306 return NULL;
7307 }
7308
7309
7310 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7311 PyObject *resultobj = 0;
7312 wxRect *arg1 = (wxRect *) 0 ;
7313 int arg2 ;
7314 void *argp1 = 0 ;
7315 int res1 = 0 ;
7316 int val2 ;
7317 int ecode2 = 0 ;
7318 PyObject * obj0 = 0 ;
7319 PyObject * obj1 = 0 ;
7320 char * kwnames[] = {
7321 (char *) "self",(char *) "bottom", NULL
7322 };
7323
7324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7326 if (!SWIG_IsOK(res1)) {
7327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7328 }
7329 arg1 = reinterpret_cast< wxRect * >(argp1);
7330 ecode2 = SWIG_AsVal_int(obj1, &val2);
7331 if (!SWIG_IsOK(ecode2)) {
7332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7333 }
7334 arg2 = static_cast< int >(val2);
7335 {
7336 (arg1)->SetBottom(arg2);
7337 if (PyErr_Occurred()) SWIG_fail;
7338 }
7339 resultobj = SWIG_Py_Void();
7340 return resultobj;
7341 fail:
7342 return NULL;
7343 }
7344
7345
7346 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7347 PyObject *resultobj = 0;
7348 wxRect *arg1 = (wxRect *) 0 ;
7349 int arg2 ;
7350 int arg3 ;
7351 wxRect result;
7352 void *argp1 = 0 ;
7353 int res1 = 0 ;
7354 int val2 ;
7355 int ecode2 = 0 ;
7356 int val3 ;
7357 int ecode3 = 0 ;
7358 PyObject * obj0 = 0 ;
7359 PyObject * obj1 = 0 ;
7360 PyObject * obj2 = 0 ;
7361 char * kwnames[] = {
7362 (char *) "self",(char *) "dx",(char *) "dy", NULL
7363 };
7364
7365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7367 if (!SWIG_IsOK(res1)) {
7368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7369 }
7370 arg1 = reinterpret_cast< wxRect * >(argp1);
7371 ecode2 = SWIG_AsVal_int(obj1, &val2);
7372 if (!SWIG_IsOK(ecode2)) {
7373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7374 }
7375 arg2 = static_cast< int >(val2);
7376 ecode3 = SWIG_AsVal_int(obj2, &val3);
7377 if (!SWIG_IsOK(ecode3)) {
7378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7379 }
7380 arg3 = static_cast< int >(val3);
7381 {
7382 result = (arg1)->Inflate(arg2,arg3);
7383 if (PyErr_Occurred()) SWIG_fail;
7384 }
7385 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7386 return resultobj;
7387 fail:
7388 return NULL;
7389 }
7390
7391
7392 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7393 PyObject *resultobj = 0;
7394 wxRect *arg1 = (wxRect *) 0 ;
7395 int arg2 ;
7396 int arg3 ;
7397 wxRect *result = 0 ;
7398 void *argp1 = 0 ;
7399 int res1 = 0 ;
7400 int val2 ;
7401 int ecode2 = 0 ;
7402 int val3 ;
7403 int ecode3 = 0 ;
7404 PyObject * obj0 = 0 ;
7405 PyObject * obj1 = 0 ;
7406 PyObject * obj2 = 0 ;
7407 char * kwnames[] = {
7408 (char *) "self",(char *) "dx",(char *) "dy", NULL
7409 };
7410
7411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7413 if (!SWIG_IsOK(res1)) {
7414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7415 }
7416 arg1 = reinterpret_cast< wxRect * >(argp1);
7417 ecode2 = SWIG_AsVal_int(obj1, &val2);
7418 if (!SWIG_IsOK(ecode2)) {
7419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7420 }
7421 arg2 = static_cast< int >(val2);
7422 ecode3 = SWIG_AsVal_int(obj2, &val3);
7423 if (!SWIG_IsOK(ecode3)) {
7424 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7425 }
7426 arg3 = static_cast< int >(val3);
7427 {
7428 {
7429 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7430 result = (wxRect *) &_result_ref;
7431 }
7432 if (PyErr_Occurred()) SWIG_fail;
7433 }
7434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7435 return resultobj;
7436 fail:
7437 return NULL;
7438 }
7439
7440
7441 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7442 PyObject *resultobj = 0;
7443 wxRect *arg1 = (wxRect *) 0 ;
7444 int arg2 ;
7445 int arg3 ;
7446 void *argp1 = 0 ;
7447 int res1 = 0 ;
7448 int val2 ;
7449 int ecode2 = 0 ;
7450 int val3 ;
7451 int ecode3 = 0 ;
7452 PyObject * obj0 = 0 ;
7453 PyObject * obj1 = 0 ;
7454 PyObject * obj2 = 0 ;
7455 char * kwnames[] = {
7456 (char *) "self",(char *) "dx",(char *) "dy", NULL
7457 };
7458
7459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7461 if (!SWIG_IsOK(res1)) {
7462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7463 }
7464 arg1 = reinterpret_cast< wxRect * >(argp1);
7465 ecode2 = SWIG_AsVal_int(obj1, &val2);
7466 if (!SWIG_IsOK(ecode2)) {
7467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7468 }
7469 arg2 = static_cast< int >(val2);
7470 ecode3 = SWIG_AsVal_int(obj2, &val3);
7471 if (!SWIG_IsOK(ecode3)) {
7472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7473 }
7474 arg3 = static_cast< int >(val3);
7475 {
7476 (arg1)->Offset(arg2,arg3);
7477 if (PyErr_Occurred()) SWIG_fail;
7478 }
7479 resultobj = SWIG_Py_Void();
7480 return resultobj;
7481 fail:
7482 return NULL;
7483 }
7484
7485
7486 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7487 PyObject *resultobj = 0;
7488 wxRect *arg1 = (wxRect *) 0 ;
7489 wxPoint *arg2 = 0 ;
7490 void *argp1 = 0 ;
7491 int res1 = 0 ;
7492 wxPoint temp2 ;
7493 PyObject * obj0 = 0 ;
7494 PyObject * obj1 = 0 ;
7495 char * kwnames[] = {
7496 (char *) "self",(char *) "pt", NULL
7497 };
7498
7499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7501 if (!SWIG_IsOK(res1)) {
7502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7503 }
7504 arg1 = reinterpret_cast< wxRect * >(argp1);
7505 {
7506 arg2 = &temp2;
7507 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7508 }
7509 {
7510 (arg1)->Offset((wxPoint const &)*arg2);
7511 if (PyErr_Occurred()) SWIG_fail;
7512 }
7513 resultobj = SWIG_Py_Void();
7514 return resultobj;
7515 fail:
7516 return NULL;
7517 }
7518
7519
7520 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7521 PyObject *resultobj = 0;
7522 wxRect *arg1 = (wxRect *) 0 ;
7523 wxRect *arg2 = 0 ;
7524 wxRect result;
7525 void *argp1 = 0 ;
7526 int res1 = 0 ;
7527 wxRect temp2 ;
7528 PyObject * obj0 = 0 ;
7529 PyObject * obj1 = 0 ;
7530 char * kwnames[] = {
7531 (char *) "self",(char *) "rect", NULL
7532 };
7533
7534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7536 if (!SWIG_IsOK(res1)) {
7537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7538 }
7539 arg1 = reinterpret_cast< wxRect * >(argp1);
7540 {
7541 arg2 = &temp2;
7542 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7543 }
7544 {
7545 result = (arg1)->Intersect((wxRect const &)*arg2);
7546 if (PyErr_Occurred()) SWIG_fail;
7547 }
7548 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7549 return resultobj;
7550 fail:
7551 return NULL;
7552 }
7553
7554
7555 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7556 PyObject *resultobj = 0;
7557 wxRect *arg1 = (wxRect *) 0 ;
7558 wxRect *arg2 = 0 ;
7559 wxRect result;
7560 void *argp1 = 0 ;
7561 int res1 = 0 ;
7562 wxRect temp2 ;
7563 PyObject * obj0 = 0 ;
7564 PyObject * obj1 = 0 ;
7565 char * kwnames[] = {
7566 (char *) "self",(char *) "rect", NULL
7567 };
7568
7569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7571 if (!SWIG_IsOK(res1)) {
7572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7573 }
7574 arg1 = reinterpret_cast< wxRect * >(argp1);
7575 {
7576 arg2 = &temp2;
7577 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7578 }
7579 {
7580 result = (arg1)->Union((wxRect const &)*arg2);
7581 if (PyErr_Occurred()) SWIG_fail;
7582 }
7583 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7584 return resultobj;
7585 fail:
7586 return NULL;
7587 }
7588
7589
7590 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7591 PyObject *resultobj = 0;
7592 wxRect *arg1 = (wxRect *) 0 ;
7593 wxRect *arg2 = 0 ;
7594 wxRect result;
7595 void *argp1 = 0 ;
7596 int res1 = 0 ;
7597 wxRect temp2 ;
7598 PyObject * obj0 = 0 ;
7599 PyObject * obj1 = 0 ;
7600 char * kwnames[] = {
7601 (char *) "self",(char *) "rect", NULL
7602 };
7603
7604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7606 if (!SWIG_IsOK(res1)) {
7607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7608 }
7609 arg1 = reinterpret_cast< wxRect * >(argp1);
7610 {
7611 arg2 = &temp2;
7612 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7613 }
7614 {
7615 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7616 if (PyErr_Occurred()) SWIG_fail;
7617 }
7618 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7619 return resultobj;
7620 fail:
7621 return NULL;
7622 }
7623
7624
7625 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7626 PyObject *resultobj = 0;
7627 wxRect *arg1 = (wxRect *) 0 ;
7628 wxRect *arg2 = 0 ;
7629 wxRect *result = 0 ;
7630 void *argp1 = 0 ;
7631 int res1 = 0 ;
7632 wxRect temp2 ;
7633 PyObject * obj0 = 0 ;
7634 PyObject * obj1 = 0 ;
7635 char * kwnames[] = {
7636 (char *) "self",(char *) "rect", NULL
7637 };
7638
7639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7641 if (!SWIG_IsOK(res1)) {
7642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7643 }
7644 arg1 = reinterpret_cast< wxRect * >(argp1);
7645 {
7646 arg2 = &temp2;
7647 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7648 }
7649 {
7650 {
7651 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7652 result = (wxRect *) &_result_ref;
7653 }
7654 if (PyErr_Occurred()) SWIG_fail;
7655 }
7656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7657 return resultobj;
7658 fail:
7659 return NULL;
7660 }
7661
7662
7663 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7664 PyObject *resultobj = 0;
7665 wxRect *arg1 = (wxRect *) 0 ;
7666 PyObject *arg2 = (PyObject *) 0 ;
7667 bool result;
7668 void *argp1 = 0 ;
7669 int res1 = 0 ;
7670 PyObject * obj0 = 0 ;
7671 PyObject * obj1 = 0 ;
7672 char * kwnames[] = {
7673 (char *) "self",(char *) "other", NULL
7674 };
7675
7676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7678 if (!SWIG_IsOK(res1)) {
7679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7680 }
7681 arg1 = reinterpret_cast< wxRect * >(argp1);
7682 arg2 = obj1;
7683 {
7684 result = (bool)wxRect___eq__(arg1,arg2);
7685 if (PyErr_Occurred()) SWIG_fail;
7686 }
7687 {
7688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7689 }
7690 return resultobj;
7691 fail:
7692 return NULL;
7693 }
7694
7695
7696 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7697 PyObject *resultobj = 0;
7698 wxRect *arg1 = (wxRect *) 0 ;
7699 PyObject *arg2 = (PyObject *) 0 ;
7700 bool result;
7701 void *argp1 = 0 ;
7702 int res1 = 0 ;
7703 PyObject * obj0 = 0 ;
7704 PyObject * obj1 = 0 ;
7705 char * kwnames[] = {
7706 (char *) "self",(char *) "other", NULL
7707 };
7708
7709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7711 if (!SWIG_IsOK(res1)) {
7712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7713 }
7714 arg1 = reinterpret_cast< wxRect * >(argp1);
7715 arg2 = obj1;
7716 {
7717 result = (bool)wxRect___ne__(arg1,arg2);
7718 if (PyErr_Occurred()) SWIG_fail;
7719 }
7720 {
7721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7722 }
7723 return resultobj;
7724 fail:
7725 return NULL;
7726 }
7727
7728
7729 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7730 PyObject *resultobj = 0;
7731 wxRect *arg1 = (wxRect *) 0 ;
7732 int arg2 ;
7733 int arg3 ;
7734 bool result;
7735 void *argp1 = 0 ;
7736 int res1 = 0 ;
7737 int val2 ;
7738 int ecode2 = 0 ;
7739 int val3 ;
7740 int ecode3 = 0 ;
7741 PyObject * obj0 = 0 ;
7742 PyObject * obj1 = 0 ;
7743 PyObject * obj2 = 0 ;
7744 char * kwnames[] = {
7745 (char *) "self",(char *) "x",(char *) "y", NULL
7746 };
7747
7748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7750 if (!SWIG_IsOK(res1)) {
7751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7752 }
7753 arg1 = reinterpret_cast< wxRect * >(argp1);
7754 ecode2 = SWIG_AsVal_int(obj1, &val2);
7755 if (!SWIG_IsOK(ecode2)) {
7756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7757 }
7758 arg2 = static_cast< int >(val2);
7759 ecode3 = SWIG_AsVal_int(obj2, &val3);
7760 if (!SWIG_IsOK(ecode3)) {
7761 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7762 }
7763 arg3 = static_cast< int >(val3);
7764 {
7765 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7766 if (PyErr_Occurred()) SWIG_fail;
7767 }
7768 {
7769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7770 }
7771 return resultobj;
7772 fail:
7773 return NULL;
7774 }
7775
7776
7777 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7778 PyObject *resultobj = 0;
7779 wxRect *arg1 = (wxRect *) 0 ;
7780 wxPoint *arg2 = 0 ;
7781 bool result;
7782 void *argp1 = 0 ;
7783 int res1 = 0 ;
7784 wxPoint temp2 ;
7785 PyObject * obj0 = 0 ;
7786 PyObject * obj1 = 0 ;
7787 char * kwnames[] = {
7788 (char *) "self",(char *) "pt", NULL
7789 };
7790
7791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7793 if (!SWIG_IsOK(res1)) {
7794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7795 }
7796 arg1 = reinterpret_cast< wxRect * >(argp1);
7797 {
7798 arg2 = &temp2;
7799 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7800 }
7801 {
7802 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7803 if (PyErr_Occurred()) SWIG_fail;
7804 }
7805 {
7806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7807 }
7808 return resultobj;
7809 fail:
7810 return NULL;
7811 }
7812
7813
7814 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7815 PyObject *resultobj = 0;
7816 wxRect *arg1 = (wxRect *) 0 ;
7817 wxRect *arg2 = 0 ;
7818 bool result;
7819 void *argp1 = 0 ;
7820 int res1 = 0 ;
7821 wxRect temp2 ;
7822 PyObject * obj0 = 0 ;
7823 PyObject * obj1 = 0 ;
7824 char * kwnames[] = {
7825 (char *) "self",(char *) "rect", NULL
7826 };
7827
7828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7830 if (!SWIG_IsOK(res1)) {
7831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7832 }
7833 arg1 = reinterpret_cast< wxRect * >(argp1);
7834 {
7835 arg2 = &temp2;
7836 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7837 }
7838 {
7839 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7840 if (PyErr_Occurred()) SWIG_fail;
7841 }
7842 {
7843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7844 }
7845 return resultobj;
7846 fail:
7847 return NULL;
7848 }
7849
7850
7851 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7852 PyObject *resultobj = 0;
7853 wxRect *arg1 = (wxRect *) 0 ;
7854 wxRect *arg2 = 0 ;
7855 bool result;
7856 void *argp1 = 0 ;
7857 int res1 = 0 ;
7858 wxRect temp2 ;
7859 PyObject * obj0 = 0 ;
7860 PyObject * obj1 = 0 ;
7861 char * kwnames[] = {
7862 (char *) "self",(char *) "rect", NULL
7863 };
7864
7865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7867 if (!SWIG_IsOK(res1)) {
7868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7869 }
7870 arg1 = reinterpret_cast< wxRect * >(argp1);
7871 {
7872 arg2 = &temp2;
7873 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7874 }
7875 {
7876 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7877 if (PyErr_Occurred()) SWIG_fail;
7878 }
7879 {
7880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7881 }
7882 return resultobj;
7883 fail:
7884 return NULL;
7885 }
7886
7887
7888 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7889 PyObject *resultobj = 0;
7890 wxRect *arg1 = (wxRect *) 0 ;
7891 wxRect *arg2 = 0 ;
7892 int arg3 = (int) wxBOTH ;
7893 wxRect result;
7894 void *argp1 = 0 ;
7895 int res1 = 0 ;
7896 wxRect temp2 ;
7897 int val3 ;
7898 int ecode3 = 0 ;
7899 PyObject * obj0 = 0 ;
7900 PyObject * obj1 = 0 ;
7901 PyObject * obj2 = 0 ;
7902 char * kwnames[] = {
7903 (char *) "self",(char *) "r",(char *) "dir", NULL
7904 };
7905
7906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7908 if (!SWIG_IsOK(res1)) {
7909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7910 }
7911 arg1 = reinterpret_cast< wxRect * >(argp1);
7912 {
7913 arg2 = &temp2;
7914 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7915 }
7916 if (obj2) {
7917 ecode3 = SWIG_AsVal_int(obj2, &val3);
7918 if (!SWIG_IsOK(ecode3)) {
7919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7920 }
7921 arg3 = static_cast< int >(val3);
7922 }
7923 {
7924 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7925 if (PyErr_Occurred()) SWIG_fail;
7926 }
7927 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7928 return resultobj;
7929 fail:
7930 return NULL;
7931 }
7932
7933
7934 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7935 PyObject *resultobj = 0;
7936 wxRect *arg1 = (wxRect *) 0 ;
7937 int arg2 ;
7938 void *argp1 = 0 ;
7939 int res1 = 0 ;
7940 int val2 ;
7941 int ecode2 = 0 ;
7942 PyObject *swig_obj[2] ;
7943
7944 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7946 if (!SWIG_IsOK(res1)) {
7947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7948 }
7949 arg1 = reinterpret_cast< wxRect * >(argp1);
7950 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7951 if (!SWIG_IsOK(ecode2)) {
7952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7953 }
7954 arg2 = static_cast< int >(val2);
7955 if (arg1) (arg1)->x = arg2;
7956
7957 resultobj = SWIG_Py_Void();
7958 return resultobj;
7959 fail:
7960 return NULL;
7961 }
7962
7963
7964 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7965 PyObject *resultobj = 0;
7966 wxRect *arg1 = (wxRect *) 0 ;
7967 int result;
7968 void *argp1 = 0 ;
7969 int res1 = 0 ;
7970 PyObject *swig_obj[1] ;
7971
7972 if (!args) SWIG_fail;
7973 swig_obj[0] = args;
7974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7975 if (!SWIG_IsOK(res1)) {
7976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7977 }
7978 arg1 = reinterpret_cast< wxRect * >(argp1);
7979 result = (int) ((arg1)->x);
7980 resultobj = SWIG_From_int(static_cast< int >(result));
7981 return resultobj;
7982 fail:
7983 return NULL;
7984 }
7985
7986
7987 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7988 PyObject *resultobj = 0;
7989 wxRect *arg1 = (wxRect *) 0 ;
7990 int arg2 ;
7991 void *argp1 = 0 ;
7992 int res1 = 0 ;
7993 int val2 ;
7994 int ecode2 = 0 ;
7995 PyObject *swig_obj[2] ;
7996
7997 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7999 if (!SWIG_IsOK(res1)) {
8000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
8001 }
8002 arg1 = reinterpret_cast< wxRect * >(argp1);
8003 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8004 if (!SWIG_IsOK(ecode2)) {
8005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
8006 }
8007 arg2 = static_cast< int >(val2);
8008 if (arg1) (arg1)->y = arg2;
8009
8010 resultobj = SWIG_Py_Void();
8011 return resultobj;
8012 fail:
8013 return NULL;
8014 }
8015
8016
8017 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8018 PyObject *resultobj = 0;
8019 wxRect *arg1 = (wxRect *) 0 ;
8020 int result;
8021 void *argp1 = 0 ;
8022 int res1 = 0 ;
8023 PyObject *swig_obj[1] ;
8024
8025 if (!args) SWIG_fail;
8026 swig_obj[0] = args;
8027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8028 if (!SWIG_IsOK(res1)) {
8029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8030 }
8031 arg1 = reinterpret_cast< wxRect * >(argp1);
8032 result = (int) ((arg1)->y);
8033 resultobj = SWIG_From_int(static_cast< int >(result));
8034 return resultobj;
8035 fail:
8036 return NULL;
8037 }
8038
8039
8040 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8041 PyObject *resultobj = 0;
8042 wxRect *arg1 = (wxRect *) 0 ;
8043 int arg2 ;
8044 void *argp1 = 0 ;
8045 int res1 = 0 ;
8046 int val2 ;
8047 int ecode2 = 0 ;
8048 PyObject *swig_obj[2] ;
8049
8050 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8052 if (!SWIG_IsOK(res1)) {
8053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8054 }
8055 arg1 = reinterpret_cast< wxRect * >(argp1);
8056 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8057 if (!SWIG_IsOK(ecode2)) {
8058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8059 }
8060 arg2 = static_cast< int >(val2);
8061 if (arg1) (arg1)->width = arg2;
8062
8063 resultobj = SWIG_Py_Void();
8064 return resultobj;
8065 fail:
8066 return NULL;
8067 }
8068
8069
8070 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8071 PyObject *resultobj = 0;
8072 wxRect *arg1 = (wxRect *) 0 ;
8073 int result;
8074 void *argp1 = 0 ;
8075 int res1 = 0 ;
8076 PyObject *swig_obj[1] ;
8077
8078 if (!args) SWIG_fail;
8079 swig_obj[0] = args;
8080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8081 if (!SWIG_IsOK(res1)) {
8082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8083 }
8084 arg1 = reinterpret_cast< wxRect * >(argp1);
8085 result = (int) ((arg1)->width);
8086 resultobj = SWIG_From_int(static_cast< int >(result));
8087 return resultobj;
8088 fail:
8089 return NULL;
8090 }
8091
8092
8093 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8094 PyObject *resultobj = 0;
8095 wxRect *arg1 = (wxRect *) 0 ;
8096 int arg2 ;
8097 void *argp1 = 0 ;
8098 int res1 = 0 ;
8099 int val2 ;
8100 int ecode2 = 0 ;
8101 PyObject *swig_obj[2] ;
8102
8103 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8105 if (!SWIG_IsOK(res1)) {
8106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8107 }
8108 arg1 = reinterpret_cast< wxRect * >(argp1);
8109 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8110 if (!SWIG_IsOK(ecode2)) {
8111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8112 }
8113 arg2 = static_cast< int >(val2);
8114 if (arg1) (arg1)->height = arg2;
8115
8116 resultobj = SWIG_Py_Void();
8117 return resultobj;
8118 fail:
8119 return NULL;
8120 }
8121
8122
8123 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8124 PyObject *resultobj = 0;
8125 wxRect *arg1 = (wxRect *) 0 ;
8126 int result;
8127 void *argp1 = 0 ;
8128 int res1 = 0 ;
8129 PyObject *swig_obj[1] ;
8130
8131 if (!args) SWIG_fail;
8132 swig_obj[0] = args;
8133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8134 if (!SWIG_IsOK(res1)) {
8135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8136 }
8137 arg1 = reinterpret_cast< wxRect * >(argp1);
8138 result = (int) ((arg1)->height);
8139 resultobj = SWIG_From_int(static_cast< int >(result));
8140 return resultobj;
8141 fail:
8142 return NULL;
8143 }
8144
8145
8146 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8147 PyObject *resultobj = 0;
8148 wxRect *arg1 = (wxRect *) 0 ;
8149 int arg2 = (int) 0 ;
8150 int arg3 = (int) 0 ;
8151 int arg4 = (int) 0 ;
8152 int arg5 = (int) 0 ;
8153 void *argp1 = 0 ;
8154 int res1 = 0 ;
8155 int val2 ;
8156 int ecode2 = 0 ;
8157 int val3 ;
8158 int ecode3 = 0 ;
8159 int val4 ;
8160 int ecode4 = 0 ;
8161 int val5 ;
8162 int ecode5 = 0 ;
8163 PyObject * obj0 = 0 ;
8164 PyObject * obj1 = 0 ;
8165 PyObject * obj2 = 0 ;
8166 PyObject * obj3 = 0 ;
8167 PyObject * obj4 = 0 ;
8168 char * kwnames[] = {
8169 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8170 };
8171
8172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8174 if (!SWIG_IsOK(res1)) {
8175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8176 }
8177 arg1 = reinterpret_cast< wxRect * >(argp1);
8178 if (obj1) {
8179 ecode2 = SWIG_AsVal_int(obj1, &val2);
8180 if (!SWIG_IsOK(ecode2)) {
8181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8182 }
8183 arg2 = static_cast< int >(val2);
8184 }
8185 if (obj2) {
8186 ecode3 = SWIG_AsVal_int(obj2, &val3);
8187 if (!SWIG_IsOK(ecode3)) {
8188 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8189 }
8190 arg3 = static_cast< int >(val3);
8191 }
8192 if (obj3) {
8193 ecode4 = SWIG_AsVal_int(obj3, &val4);
8194 if (!SWIG_IsOK(ecode4)) {
8195 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8196 }
8197 arg4 = static_cast< int >(val4);
8198 }
8199 if (obj4) {
8200 ecode5 = SWIG_AsVal_int(obj4, &val5);
8201 if (!SWIG_IsOK(ecode5)) {
8202 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8203 }
8204 arg5 = static_cast< int >(val5);
8205 }
8206 {
8207 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8208 if (PyErr_Occurred()) SWIG_fail;
8209 }
8210 resultobj = SWIG_Py_Void();
8211 return resultobj;
8212 fail:
8213 return NULL;
8214 }
8215
8216
8217 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8218 PyObject *resultobj = 0;
8219 wxRect *arg1 = (wxRect *) 0 ;
8220 PyObject *result = 0 ;
8221 void *argp1 = 0 ;
8222 int res1 = 0 ;
8223 PyObject *swig_obj[1] ;
8224
8225 if (!args) SWIG_fail;
8226 swig_obj[0] = args;
8227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8228 if (!SWIG_IsOK(res1)) {
8229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8230 }
8231 arg1 = reinterpret_cast< wxRect * >(argp1);
8232 {
8233 result = (PyObject *)wxRect_Get(arg1);
8234 if (PyErr_Occurred()) SWIG_fail;
8235 }
8236 resultobj = result;
8237 return resultobj;
8238 fail:
8239 return NULL;
8240 }
8241
8242
8243 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8244 PyObject *obj;
8245 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8246 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8247 return SWIG_Py_Void();
8248 }
8249
8250 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8251 return SWIG_Python_InitShadowInstance(args);
8252 }
8253
8254 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8255 PyObject *resultobj = 0;
8256 wxRect *arg1 = (wxRect *) 0 ;
8257 wxRect *arg2 = (wxRect *) 0 ;
8258 PyObject *result = 0 ;
8259 void *argp1 = 0 ;
8260 int res1 = 0 ;
8261 void *argp2 = 0 ;
8262 int res2 = 0 ;
8263 PyObject * obj0 = 0 ;
8264 PyObject * obj1 = 0 ;
8265 char * kwnames[] = {
8266 (char *) "r1",(char *) "r2", NULL
8267 };
8268
8269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8271 if (!SWIG_IsOK(res1)) {
8272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8273 }
8274 arg1 = reinterpret_cast< wxRect * >(argp1);
8275 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8276 if (!SWIG_IsOK(res2)) {
8277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8278 }
8279 arg2 = reinterpret_cast< wxRect * >(argp2);
8280 {
8281 if (!wxPyCheckForApp()) SWIG_fail;
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 result = (PyObject *)wxIntersectRect(arg1,arg2);
8284 wxPyEndAllowThreads(__tstate);
8285 if (PyErr_Occurred()) SWIG_fail;
8286 }
8287 resultobj = result;
8288 return resultobj;
8289 fail:
8290 return NULL;
8291 }
8292
8293
8294 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8295 PyObject *resultobj = 0;
8296 double arg1 = (double) 0.0 ;
8297 double arg2 = (double) 0.0 ;
8298 wxPoint2D *result = 0 ;
8299 double val1 ;
8300 int ecode1 = 0 ;
8301 double val2 ;
8302 int ecode2 = 0 ;
8303 PyObject * obj0 = 0 ;
8304 PyObject * obj1 = 0 ;
8305 char * kwnames[] = {
8306 (char *) "x",(char *) "y", NULL
8307 };
8308
8309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8310 if (obj0) {
8311 ecode1 = SWIG_AsVal_double(obj0, &val1);
8312 if (!SWIG_IsOK(ecode1)) {
8313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8314 }
8315 arg1 = static_cast< double >(val1);
8316 }
8317 if (obj1) {
8318 ecode2 = SWIG_AsVal_double(obj1, &val2);
8319 if (!SWIG_IsOK(ecode2)) {
8320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8321 }
8322 arg2 = static_cast< double >(val2);
8323 }
8324 {
8325 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8326 if (PyErr_Occurred()) SWIG_fail;
8327 }
8328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8329 return resultobj;
8330 fail:
8331 return NULL;
8332 }
8333
8334
8335 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8336 PyObject *resultobj = 0;
8337 wxPoint2D *arg1 = 0 ;
8338 wxPoint2D *result = 0 ;
8339 wxPoint2D temp1 ;
8340 PyObject * obj0 = 0 ;
8341 char * kwnames[] = {
8342 (char *) "pt", NULL
8343 };
8344
8345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8346 {
8347 arg1 = &temp1;
8348 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8349 }
8350 {
8351 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8352 if (PyErr_Occurred()) SWIG_fail;
8353 }
8354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8355 return resultobj;
8356 fail:
8357 return NULL;
8358 }
8359
8360
8361 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8362 PyObject *resultobj = 0;
8363 wxPoint *arg1 = 0 ;
8364 wxPoint2D *result = 0 ;
8365 wxPoint temp1 ;
8366 PyObject * obj0 = 0 ;
8367 char * kwnames[] = {
8368 (char *) "pt", NULL
8369 };
8370
8371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8372 {
8373 arg1 = &temp1;
8374 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8375 }
8376 {
8377 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8378 if (PyErr_Occurred()) SWIG_fail;
8379 }
8380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8381 return resultobj;
8382 fail:
8383 return NULL;
8384 }
8385
8386
8387 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8388 PyObject *resultobj = 0;
8389 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8390 void *argp1 = 0 ;
8391 int res1 = 0 ;
8392 PyObject *swig_obj[1] ;
8393
8394 if (!args) SWIG_fail;
8395 swig_obj[0] = args;
8396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8397 if (!SWIG_IsOK(res1)) {
8398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8399 }
8400 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8401 {
8402 delete arg1;
8403
8404 if (PyErr_Occurred()) SWIG_fail;
8405 }
8406 resultobj = SWIG_Py_Void();
8407 return resultobj;
8408 fail:
8409 return NULL;
8410 }
8411
8412
8413 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8414 PyObject *resultobj = 0;
8415 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8416 int *arg2 = (int *) 0 ;
8417 int *arg3 = (int *) 0 ;
8418 void *argp1 = 0 ;
8419 int res1 = 0 ;
8420 int temp2 ;
8421 int res2 = SWIG_TMPOBJ ;
8422 int temp3 ;
8423 int res3 = SWIG_TMPOBJ ;
8424 PyObject *swig_obj[1] ;
8425
8426 arg2 = &temp2;
8427 arg3 = &temp3;
8428 if (!args) SWIG_fail;
8429 swig_obj[0] = args;
8430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8431 if (!SWIG_IsOK(res1)) {
8432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8433 }
8434 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8435 {
8436 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8437 if (PyErr_Occurred()) SWIG_fail;
8438 }
8439 resultobj = SWIG_Py_Void();
8440 if (SWIG_IsTmpObj(res2)) {
8441 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8442 } else {
8443 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8444 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8445 }
8446 if (SWIG_IsTmpObj(res3)) {
8447 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8448 } else {
8449 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8450 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8451 }
8452 return resultobj;
8453 fail:
8454 return NULL;
8455 }
8456
8457
8458 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8459 PyObject *resultobj = 0;
8460 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8461 int *arg2 = (int *) 0 ;
8462 int *arg3 = (int *) 0 ;
8463 void *argp1 = 0 ;
8464 int res1 = 0 ;
8465 int temp2 ;
8466 int res2 = SWIG_TMPOBJ ;
8467 int temp3 ;
8468 int res3 = SWIG_TMPOBJ ;
8469 PyObject *swig_obj[1] ;
8470
8471 arg2 = &temp2;
8472 arg3 = &temp3;
8473 if (!args) SWIG_fail;
8474 swig_obj[0] = args;
8475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8476 if (!SWIG_IsOK(res1)) {
8477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8478 }
8479 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8480 {
8481 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8482 if (PyErr_Occurred()) SWIG_fail;
8483 }
8484 resultobj = SWIG_Py_Void();
8485 if (SWIG_IsTmpObj(res2)) {
8486 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8487 } else {
8488 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8489 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8490 }
8491 if (SWIG_IsTmpObj(res3)) {
8492 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8493 } else {
8494 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8495 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8496 }
8497 return resultobj;
8498 fail:
8499 return NULL;
8500 }
8501
8502
8503 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8504 PyObject *resultobj = 0;
8505 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8506 double result;
8507 void *argp1 = 0 ;
8508 int res1 = 0 ;
8509 PyObject *swig_obj[1] ;
8510
8511 if (!args) SWIG_fail;
8512 swig_obj[0] = args;
8513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8514 if (!SWIG_IsOK(res1)) {
8515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8516 }
8517 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8518 {
8519 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8520 if (PyErr_Occurred()) SWIG_fail;
8521 }
8522 resultobj = SWIG_From_double(static_cast< double >(result));
8523 return resultobj;
8524 fail:
8525 return NULL;
8526 }
8527
8528
8529 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8530 PyObject *resultobj = 0;
8531 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8532 double result;
8533 void *argp1 = 0 ;
8534 int res1 = 0 ;
8535 PyObject *swig_obj[1] ;
8536
8537 if (!args) SWIG_fail;
8538 swig_obj[0] = args;
8539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8540 if (!SWIG_IsOK(res1)) {
8541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8542 }
8543 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8544 {
8545 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8546 if (PyErr_Occurred()) SWIG_fail;
8547 }
8548 resultobj = SWIG_From_double(static_cast< double >(result));
8549 return resultobj;
8550 fail:
8551 return NULL;
8552 }
8553
8554
8555 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8556 PyObject *resultobj = 0;
8557 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8558 double arg2 ;
8559 void *argp1 = 0 ;
8560 int res1 = 0 ;
8561 double val2 ;
8562 int ecode2 = 0 ;
8563 PyObject * obj0 = 0 ;
8564 PyObject * obj1 = 0 ;
8565 char * kwnames[] = {
8566 (char *) "self",(char *) "length", NULL
8567 };
8568
8569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8571 if (!SWIG_IsOK(res1)) {
8572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8573 }
8574 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8575 ecode2 = SWIG_AsVal_double(obj1, &val2);
8576 if (!SWIG_IsOK(ecode2)) {
8577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8578 }
8579 arg2 = static_cast< double >(val2);
8580 {
8581 (arg1)->SetVectorLength(arg2);
8582 if (PyErr_Occurred()) SWIG_fail;
8583 }
8584 resultobj = SWIG_Py_Void();
8585 return resultobj;
8586 fail:
8587 return NULL;
8588 }
8589
8590
8591 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8592 PyObject *resultobj = 0;
8593 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8594 double arg2 ;
8595 void *argp1 = 0 ;
8596 int res1 = 0 ;
8597 double val2 ;
8598 int ecode2 = 0 ;
8599 PyObject * obj0 = 0 ;
8600 PyObject * obj1 = 0 ;
8601 char * kwnames[] = {
8602 (char *) "self",(char *) "degrees", NULL
8603 };
8604
8605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8607 if (!SWIG_IsOK(res1)) {
8608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8609 }
8610 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8611 ecode2 = SWIG_AsVal_double(obj1, &val2);
8612 if (!SWIG_IsOK(ecode2)) {
8613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8614 }
8615 arg2 = static_cast< double >(val2);
8616 {
8617 (arg1)->SetVectorAngle(arg2);
8618 if (PyErr_Occurred()) SWIG_fail;
8619 }
8620 resultobj = SWIG_Py_Void();
8621 return resultobj;
8622 fail:
8623 return NULL;
8624 }
8625
8626
8627 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8628 PyObject *resultobj = 0;
8629 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8630 wxPoint2D *arg2 = 0 ;
8631 double result;
8632 void *argp1 = 0 ;
8633 int res1 = 0 ;
8634 wxPoint2D temp2 ;
8635 PyObject * obj0 = 0 ;
8636 PyObject * obj1 = 0 ;
8637 char * kwnames[] = {
8638 (char *) "self",(char *) "pt", NULL
8639 };
8640
8641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8643 if (!SWIG_IsOK(res1)) {
8644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8645 }
8646 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8647 {
8648 arg2 = &temp2;
8649 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8650 }
8651 {
8652 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8653 if (PyErr_Occurred()) SWIG_fail;
8654 }
8655 resultobj = SWIG_From_double(static_cast< double >(result));
8656 return resultobj;
8657 fail:
8658 return NULL;
8659 }
8660
8661
8662 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8663 PyObject *resultobj = 0;
8664 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8665 wxPoint2D *arg2 = 0 ;
8666 double result;
8667 void *argp1 = 0 ;
8668 int res1 = 0 ;
8669 wxPoint2D temp2 ;
8670 PyObject * obj0 = 0 ;
8671 PyObject * obj1 = 0 ;
8672 char * kwnames[] = {
8673 (char *) "self",(char *) "pt", NULL
8674 };
8675
8676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8678 if (!SWIG_IsOK(res1)) {
8679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8680 }
8681 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8682 {
8683 arg2 = &temp2;
8684 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8685 }
8686 {
8687 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8688 if (PyErr_Occurred()) SWIG_fail;
8689 }
8690 resultobj = SWIG_From_double(static_cast< double >(result));
8691 return resultobj;
8692 fail:
8693 return NULL;
8694 }
8695
8696
8697 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8698 PyObject *resultobj = 0;
8699 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8700 wxPoint2D *arg2 = 0 ;
8701 double result;
8702 void *argp1 = 0 ;
8703 int res1 = 0 ;
8704 wxPoint2D temp2 ;
8705 PyObject * obj0 = 0 ;
8706 PyObject * obj1 = 0 ;
8707 char * kwnames[] = {
8708 (char *) "self",(char *) "vec", NULL
8709 };
8710
8711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8713 if (!SWIG_IsOK(res1)) {
8714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8715 }
8716 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8717 {
8718 arg2 = &temp2;
8719 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8720 }
8721 {
8722 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8723 if (PyErr_Occurred()) SWIG_fail;
8724 }
8725 resultobj = SWIG_From_double(static_cast< double >(result));
8726 return resultobj;
8727 fail:
8728 return NULL;
8729 }
8730
8731
8732 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8733 PyObject *resultobj = 0;
8734 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8735 wxPoint2D *arg2 = 0 ;
8736 double result;
8737 void *argp1 = 0 ;
8738 int res1 = 0 ;
8739 wxPoint2D temp2 ;
8740 PyObject * obj0 = 0 ;
8741 PyObject * obj1 = 0 ;
8742 char * kwnames[] = {
8743 (char *) "self",(char *) "vec", NULL
8744 };
8745
8746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8748 if (!SWIG_IsOK(res1)) {
8749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8750 }
8751 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8752 {
8753 arg2 = &temp2;
8754 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8755 }
8756 {
8757 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8758 if (PyErr_Occurred()) SWIG_fail;
8759 }
8760 resultobj = SWIG_From_double(static_cast< double >(result));
8761 return resultobj;
8762 fail:
8763 return NULL;
8764 }
8765
8766
8767 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8768 PyObject *resultobj = 0;
8769 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8770 wxPoint2D result;
8771 void *argp1 = 0 ;
8772 int res1 = 0 ;
8773 PyObject *swig_obj[1] ;
8774
8775 if (!args) SWIG_fail;
8776 swig_obj[0] = args;
8777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8778 if (!SWIG_IsOK(res1)) {
8779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8780 }
8781 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8782 {
8783 result = (arg1)->operator -();
8784 if (PyErr_Occurred()) SWIG_fail;
8785 }
8786 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8787 return resultobj;
8788 fail:
8789 return NULL;
8790 }
8791
8792
8793 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8794 PyObject *resultobj = 0;
8795 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8796 wxPoint2D *arg2 = 0 ;
8797 wxPoint2D *result = 0 ;
8798 void *argp1 = 0 ;
8799 int res1 = 0 ;
8800 wxPoint2D temp2 ;
8801 PyObject * obj0 = 0 ;
8802 PyObject * obj1 = 0 ;
8803 char * kwnames[] = {
8804 (char *) "self",(char *) "pt", NULL
8805 };
8806
8807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8809 if (!SWIG_IsOK(res1)) {
8810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8811 }
8812 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8813 {
8814 arg2 = &temp2;
8815 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8816 }
8817 {
8818 {
8819 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8820 result = (wxPoint2D *) &_result_ref;
8821 }
8822 if (PyErr_Occurred()) SWIG_fail;
8823 }
8824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8825 return resultobj;
8826 fail:
8827 return NULL;
8828 }
8829
8830
8831 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8832 PyObject *resultobj = 0;
8833 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8834 wxPoint2D *arg2 = 0 ;
8835 wxPoint2D *result = 0 ;
8836 void *argp1 = 0 ;
8837 int res1 = 0 ;
8838 wxPoint2D temp2 ;
8839 PyObject * obj0 = 0 ;
8840 PyObject * obj1 = 0 ;
8841 char * kwnames[] = {
8842 (char *) "self",(char *) "pt", NULL
8843 };
8844
8845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8847 if (!SWIG_IsOK(res1)) {
8848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8849 }
8850 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8851 {
8852 arg2 = &temp2;
8853 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8854 }
8855 {
8856 {
8857 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8858 result = (wxPoint2D *) &_result_ref;
8859 }
8860 if (PyErr_Occurred()) SWIG_fail;
8861 }
8862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8863 return resultobj;
8864 fail:
8865 return NULL;
8866 }
8867
8868
8869 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8870 PyObject *resultobj = 0;
8871 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8872 wxPoint2D *arg2 = 0 ;
8873 wxPoint2D *result = 0 ;
8874 void *argp1 = 0 ;
8875 int res1 = 0 ;
8876 wxPoint2D temp2 ;
8877 PyObject * obj0 = 0 ;
8878 PyObject * obj1 = 0 ;
8879 char * kwnames[] = {
8880 (char *) "self",(char *) "pt", NULL
8881 };
8882
8883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8885 if (!SWIG_IsOK(res1)) {
8886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8887 }
8888 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8889 {
8890 arg2 = &temp2;
8891 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8892 }
8893 {
8894 {
8895 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8896 result = (wxPoint2D *) &_result_ref;
8897 }
8898 if (PyErr_Occurred()) SWIG_fail;
8899 }
8900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8901 return resultobj;
8902 fail:
8903 return NULL;
8904 }
8905
8906
8907 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8908 PyObject *resultobj = 0;
8909 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8910 wxPoint2D *arg2 = 0 ;
8911 wxPoint2D *result = 0 ;
8912 void *argp1 = 0 ;
8913 int res1 = 0 ;
8914 wxPoint2D temp2 ;
8915 PyObject * obj0 = 0 ;
8916 PyObject * obj1 = 0 ;
8917 char * kwnames[] = {
8918 (char *) "self",(char *) "pt", NULL
8919 };
8920
8921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8923 if (!SWIG_IsOK(res1)) {
8924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8925 }
8926 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8927 {
8928 arg2 = &temp2;
8929 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8930 }
8931 {
8932 {
8933 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8934 result = (wxPoint2D *) &_result_ref;
8935 }
8936 if (PyErr_Occurred()) SWIG_fail;
8937 }
8938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8939 return resultobj;
8940 fail:
8941 return NULL;
8942 }
8943
8944
8945 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8946 PyObject *resultobj = 0;
8947 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8948 PyObject *arg2 = (PyObject *) 0 ;
8949 bool result;
8950 void *argp1 = 0 ;
8951 int res1 = 0 ;
8952 PyObject * obj0 = 0 ;
8953 PyObject * obj1 = 0 ;
8954 char * kwnames[] = {
8955 (char *) "self",(char *) "other", NULL
8956 };
8957
8958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8960 if (!SWIG_IsOK(res1)) {
8961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8962 }
8963 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8964 arg2 = obj1;
8965 {
8966 result = (bool)wxPoint2D___eq__(arg1,arg2);
8967 if (PyErr_Occurred()) SWIG_fail;
8968 }
8969 {
8970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8971 }
8972 return resultobj;
8973 fail:
8974 return NULL;
8975 }
8976
8977
8978 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8979 PyObject *resultobj = 0;
8980 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8981 PyObject *arg2 = (PyObject *) 0 ;
8982 bool result;
8983 void *argp1 = 0 ;
8984 int res1 = 0 ;
8985 PyObject * obj0 = 0 ;
8986 PyObject * obj1 = 0 ;
8987 char * kwnames[] = {
8988 (char *) "self",(char *) "other", NULL
8989 };
8990
8991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8993 if (!SWIG_IsOK(res1)) {
8994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8995 }
8996 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8997 arg2 = obj1;
8998 {
8999 result = (bool)wxPoint2D___ne__(arg1,arg2);
9000 if (PyErr_Occurred()) SWIG_fail;
9001 }
9002 {
9003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9004 }
9005 return resultobj;
9006 fail:
9007 return NULL;
9008 }
9009
9010
9011 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9012 PyObject *resultobj = 0;
9013 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9014 double arg2 ;
9015 void *argp1 = 0 ;
9016 int res1 = 0 ;
9017 double val2 ;
9018 int ecode2 = 0 ;
9019 PyObject *swig_obj[2] ;
9020
9021 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9023 if (!SWIG_IsOK(res1)) {
9024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9025 }
9026 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9027 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9028 if (!SWIG_IsOK(ecode2)) {
9029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9030 }
9031 arg2 = static_cast< double >(val2);
9032 if (arg1) (arg1)->m_x = arg2;
9033
9034 resultobj = SWIG_Py_Void();
9035 return resultobj;
9036 fail:
9037 return NULL;
9038 }
9039
9040
9041 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9042 PyObject *resultobj = 0;
9043 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9044 double result;
9045 void *argp1 = 0 ;
9046 int res1 = 0 ;
9047 PyObject *swig_obj[1] ;
9048
9049 if (!args) SWIG_fail;
9050 swig_obj[0] = args;
9051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9052 if (!SWIG_IsOK(res1)) {
9053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9054 }
9055 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9056 result = (double) ((arg1)->m_x);
9057 resultobj = SWIG_From_double(static_cast< double >(result));
9058 return resultobj;
9059 fail:
9060 return NULL;
9061 }
9062
9063
9064 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9065 PyObject *resultobj = 0;
9066 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9067 double arg2 ;
9068 void *argp1 = 0 ;
9069 int res1 = 0 ;
9070 double val2 ;
9071 int ecode2 = 0 ;
9072 PyObject *swig_obj[2] ;
9073
9074 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9076 if (!SWIG_IsOK(res1)) {
9077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9078 }
9079 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9080 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9081 if (!SWIG_IsOK(ecode2)) {
9082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9083 }
9084 arg2 = static_cast< double >(val2);
9085 if (arg1) (arg1)->m_y = arg2;
9086
9087 resultobj = SWIG_Py_Void();
9088 return resultobj;
9089 fail:
9090 return NULL;
9091 }
9092
9093
9094 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9095 PyObject *resultobj = 0;
9096 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9097 double result;
9098 void *argp1 = 0 ;
9099 int res1 = 0 ;
9100 PyObject *swig_obj[1] ;
9101
9102 if (!args) SWIG_fail;
9103 swig_obj[0] = args;
9104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9105 if (!SWIG_IsOK(res1)) {
9106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9107 }
9108 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9109 result = (double) ((arg1)->m_y);
9110 resultobj = SWIG_From_double(static_cast< double >(result));
9111 return resultobj;
9112 fail:
9113 return NULL;
9114 }
9115
9116
9117 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9118 PyObject *resultobj = 0;
9119 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9120 double arg2 = (double) 0 ;
9121 double arg3 = (double) 0 ;
9122 void *argp1 = 0 ;
9123 int res1 = 0 ;
9124 double val2 ;
9125 int ecode2 = 0 ;
9126 double val3 ;
9127 int ecode3 = 0 ;
9128 PyObject * obj0 = 0 ;
9129 PyObject * obj1 = 0 ;
9130 PyObject * obj2 = 0 ;
9131 char * kwnames[] = {
9132 (char *) "self",(char *) "x",(char *) "y", NULL
9133 };
9134
9135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9137 if (!SWIG_IsOK(res1)) {
9138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9139 }
9140 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9141 if (obj1) {
9142 ecode2 = SWIG_AsVal_double(obj1, &val2);
9143 if (!SWIG_IsOK(ecode2)) {
9144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9145 }
9146 arg2 = static_cast< double >(val2);
9147 }
9148 if (obj2) {
9149 ecode3 = SWIG_AsVal_double(obj2, &val3);
9150 if (!SWIG_IsOK(ecode3)) {
9151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9152 }
9153 arg3 = static_cast< double >(val3);
9154 }
9155 {
9156 wxPoint2D_Set(arg1,arg2,arg3);
9157 if (PyErr_Occurred()) SWIG_fail;
9158 }
9159 resultobj = SWIG_Py_Void();
9160 return resultobj;
9161 fail:
9162 return NULL;
9163 }
9164
9165
9166 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9167 PyObject *resultobj = 0;
9168 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9169 PyObject *result = 0 ;
9170 void *argp1 = 0 ;
9171 int res1 = 0 ;
9172 PyObject *swig_obj[1] ;
9173
9174 if (!args) SWIG_fail;
9175 swig_obj[0] = args;
9176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9177 if (!SWIG_IsOK(res1)) {
9178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9179 }
9180 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9181 {
9182 result = (PyObject *)wxPoint2D_Get(arg1);
9183 if (PyErr_Occurred()) SWIG_fail;
9184 }
9185 resultobj = result;
9186 return resultobj;
9187 fail:
9188 return NULL;
9189 }
9190
9191
9192 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9193 PyObject *obj;
9194 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9195 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9196 return SWIG_Py_Void();
9197 }
9198
9199 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9200 return SWIG_Python_InitShadowInstance(args);
9201 }
9202
9203 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9204 PyObject *resultobj = 0;
9205 wxDouble arg1 = (wxDouble) 0.0 ;
9206 wxDouble arg2 = (wxDouble) 0.0 ;
9207 wxDouble arg3 = (wxDouble) 0.0 ;
9208 wxDouble arg4 = (wxDouble) 0.0 ;
9209 wxRect2D *result = 0 ;
9210 void *argp1 ;
9211 int res1 = 0 ;
9212 void *argp2 ;
9213 int res2 = 0 ;
9214 void *argp3 ;
9215 int res3 = 0 ;
9216 void *argp4 ;
9217 int res4 = 0 ;
9218 PyObject * obj0 = 0 ;
9219 PyObject * obj1 = 0 ;
9220 PyObject * obj2 = 0 ;
9221 PyObject * obj3 = 0 ;
9222 char * kwnames[] = {
9223 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9224 };
9225
9226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9227 if (obj0) {
9228 {
9229 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9230 if (!SWIG_IsOK(res1)) {
9231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9232 }
9233 if (!argp1) {
9234 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9235 } else {
9236 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9237 arg1 = *temp;
9238 if (SWIG_IsNewObj(res1)) delete temp;
9239 }
9240 }
9241 }
9242 if (obj1) {
9243 {
9244 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9245 if (!SWIG_IsOK(res2)) {
9246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9247 }
9248 if (!argp2) {
9249 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9250 } else {
9251 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9252 arg2 = *temp;
9253 if (SWIG_IsNewObj(res2)) delete temp;
9254 }
9255 }
9256 }
9257 if (obj2) {
9258 {
9259 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9260 if (!SWIG_IsOK(res3)) {
9261 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9262 }
9263 if (!argp3) {
9264 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9265 } else {
9266 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9267 arg3 = *temp;
9268 if (SWIG_IsNewObj(res3)) delete temp;
9269 }
9270 }
9271 }
9272 if (obj3) {
9273 {
9274 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9275 if (!SWIG_IsOK(res4)) {
9276 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9277 }
9278 if (!argp4) {
9279 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9280 } else {
9281 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9282 arg4 = *temp;
9283 if (SWIG_IsNewObj(res4)) delete temp;
9284 }
9285 }
9286 }
9287 {
9288 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9289 if (PyErr_Occurred()) SWIG_fail;
9290 }
9291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9292 return resultobj;
9293 fail:
9294 return NULL;
9295 }
9296
9297
9298 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9299 PyObject *resultobj = 0;
9300 wxRect2D *arg1 = (wxRect2D *) 0 ;
9301 void *argp1 = 0 ;
9302 int res1 = 0 ;
9303 PyObject *swig_obj[1] ;
9304
9305 if (!args) SWIG_fail;
9306 swig_obj[0] = args;
9307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9308 if (!SWIG_IsOK(res1)) {
9309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9310 }
9311 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9312 {
9313 delete arg1;
9314
9315 if (PyErr_Occurred()) SWIG_fail;
9316 }
9317 resultobj = SWIG_Py_Void();
9318 return resultobj;
9319 fail:
9320 return NULL;
9321 }
9322
9323
9324 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9325 PyObject *resultobj = 0;
9326 wxRect2D *arg1 = (wxRect2D *) 0 ;
9327 wxPoint2D result;
9328 void *argp1 = 0 ;
9329 int res1 = 0 ;
9330 PyObject *swig_obj[1] ;
9331
9332 if (!args) SWIG_fail;
9333 swig_obj[0] = args;
9334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9335 if (!SWIG_IsOK(res1)) {
9336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9337 }
9338 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9339 {
9340 result = (arg1)->GetPosition();
9341 if (PyErr_Occurred()) SWIG_fail;
9342 }
9343 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9344 return resultobj;
9345 fail:
9346 return NULL;
9347 }
9348
9349
9350 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9351 PyObject *resultobj = 0;
9352 wxRect2D *arg1 = (wxRect2D *) 0 ;
9353 wxSize result;
9354 void *argp1 = 0 ;
9355 int res1 = 0 ;
9356 PyObject *swig_obj[1] ;
9357
9358 if (!args) SWIG_fail;
9359 swig_obj[0] = args;
9360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9361 if (!SWIG_IsOK(res1)) {
9362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9363 }
9364 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9365 {
9366 result = (arg1)->GetSize();
9367 if (PyErr_Occurred()) SWIG_fail;
9368 }
9369 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9370 return resultobj;
9371 fail:
9372 return NULL;
9373 }
9374
9375
9376 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9377 PyObject *resultobj = 0;
9378 wxRect2D *arg1 = (wxRect2D *) 0 ;
9379 wxDouble result;
9380 void *argp1 = 0 ;
9381 int res1 = 0 ;
9382 PyObject *swig_obj[1] ;
9383
9384 if (!args) SWIG_fail;
9385 swig_obj[0] = args;
9386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9387 if (!SWIG_IsOK(res1)) {
9388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9389 }
9390 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9391 {
9392 result = ((wxRect2D const *)arg1)->GetLeft();
9393 if (PyErr_Occurred()) SWIG_fail;
9394 }
9395 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9396 return resultobj;
9397 fail:
9398 return NULL;
9399 }
9400
9401
9402 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9403 PyObject *resultobj = 0;
9404 wxRect2D *arg1 = (wxRect2D *) 0 ;
9405 wxDouble arg2 ;
9406 void *argp1 = 0 ;
9407 int res1 = 0 ;
9408 void *argp2 ;
9409 int res2 = 0 ;
9410 PyObject * obj0 = 0 ;
9411 PyObject * obj1 = 0 ;
9412 char * kwnames[] = {
9413 (char *) "self",(char *) "n", NULL
9414 };
9415
9416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9418 if (!SWIG_IsOK(res1)) {
9419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9420 }
9421 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9422 {
9423 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9424 if (!SWIG_IsOK(res2)) {
9425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9426 }
9427 if (!argp2) {
9428 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9429 } else {
9430 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9431 arg2 = *temp;
9432 if (SWIG_IsNewObj(res2)) delete temp;
9433 }
9434 }
9435 {
9436 (arg1)->SetLeft(arg2);
9437 if (PyErr_Occurred()) SWIG_fail;
9438 }
9439 resultobj = SWIG_Py_Void();
9440 return resultobj;
9441 fail:
9442 return NULL;
9443 }
9444
9445
9446 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9447 PyObject *resultobj = 0;
9448 wxRect2D *arg1 = (wxRect2D *) 0 ;
9449 wxDouble arg2 ;
9450 void *argp1 = 0 ;
9451 int res1 = 0 ;
9452 void *argp2 ;
9453 int res2 = 0 ;
9454 PyObject * obj0 = 0 ;
9455 PyObject * obj1 = 0 ;
9456 char * kwnames[] = {
9457 (char *) "self",(char *) "n", NULL
9458 };
9459
9460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9462 if (!SWIG_IsOK(res1)) {
9463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9464 }
9465 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9466 {
9467 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9468 if (!SWIG_IsOK(res2)) {
9469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9470 }
9471 if (!argp2) {
9472 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9473 } else {
9474 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9475 arg2 = *temp;
9476 if (SWIG_IsNewObj(res2)) delete temp;
9477 }
9478 }
9479 {
9480 (arg1)->MoveLeftTo(arg2);
9481 if (PyErr_Occurred()) SWIG_fail;
9482 }
9483 resultobj = SWIG_Py_Void();
9484 return resultobj;
9485 fail:
9486 return NULL;
9487 }
9488
9489
9490 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9491 PyObject *resultobj = 0;
9492 wxRect2D *arg1 = (wxRect2D *) 0 ;
9493 wxDouble result;
9494 void *argp1 = 0 ;
9495 int res1 = 0 ;
9496 PyObject *swig_obj[1] ;
9497
9498 if (!args) SWIG_fail;
9499 swig_obj[0] = args;
9500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9501 if (!SWIG_IsOK(res1)) {
9502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9503 }
9504 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9505 {
9506 result = ((wxRect2D const *)arg1)->GetTop();
9507 if (PyErr_Occurred()) SWIG_fail;
9508 }
9509 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9510 return resultobj;
9511 fail:
9512 return NULL;
9513 }
9514
9515
9516 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9517 PyObject *resultobj = 0;
9518 wxRect2D *arg1 = (wxRect2D *) 0 ;
9519 wxDouble arg2 ;
9520 void *argp1 = 0 ;
9521 int res1 = 0 ;
9522 void *argp2 ;
9523 int res2 = 0 ;
9524 PyObject * obj0 = 0 ;
9525 PyObject * obj1 = 0 ;
9526 char * kwnames[] = {
9527 (char *) "self",(char *) "n", NULL
9528 };
9529
9530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9532 if (!SWIG_IsOK(res1)) {
9533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9534 }
9535 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9536 {
9537 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9538 if (!SWIG_IsOK(res2)) {
9539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9540 }
9541 if (!argp2) {
9542 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9543 } else {
9544 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9545 arg2 = *temp;
9546 if (SWIG_IsNewObj(res2)) delete temp;
9547 }
9548 }
9549 {
9550 (arg1)->SetTop(arg2);
9551 if (PyErr_Occurred()) SWIG_fail;
9552 }
9553 resultobj = SWIG_Py_Void();
9554 return resultobj;
9555 fail:
9556 return NULL;
9557 }
9558
9559
9560 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9561 PyObject *resultobj = 0;
9562 wxRect2D *arg1 = (wxRect2D *) 0 ;
9563 wxDouble arg2 ;
9564 void *argp1 = 0 ;
9565 int res1 = 0 ;
9566 void *argp2 ;
9567 int res2 = 0 ;
9568 PyObject * obj0 = 0 ;
9569 PyObject * obj1 = 0 ;
9570 char * kwnames[] = {
9571 (char *) "self",(char *) "n", NULL
9572 };
9573
9574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9576 if (!SWIG_IsOK(res1)) {
9577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9578 }
9579 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9580 {
9581 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9582 if (!SWIG_IsOK(res2)) {
9583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9584 }
9585 if (!argp2) {
9586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9587 } else {
9588 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9589 arg2 = *temp;
9590 if (SWIG_IsNewObj(res2)) delete temp;
9591 }
9592 }
9593 {
9594 (arg1)->MoveTopTo(arg2);
9595 if (PyErr_Occurred()) SWIG_fail;
9596 }
9597 resultobj = SWIG_Py_Void();
9598 return resultobj;
9599 fail:
9600 return NULL;
9601 }
9602
9603
9604 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9605 PyObject *resultobj = 0;
9606 wxRect2D *arg1 = (wxRect2D *) 0 ;
9607 wxDouble result;
9608 void *argp1 = 0 ;
9609 int res1 = 0 ;
9610 PyObject *swig_obj[1] ;
9611
9612 if (!args) SWIG_fail;
9613 swig_obj[0] = args;
9614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9615 if (!SWIG_IsOK(res1)) {
9616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9617 }
9618 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9619 {
9620 result = ((wxRect2D const *)arg1)->GetBottom();
9621 if (PyErr_Occurred()) SWIG_fail;
9622 }
9623 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9624 return resultobj;
9625 fail:
9626 return NULL;
9627 }
9628
9629
9630 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9631 PyObject *resultobj = 0;
9632 wxRect2D *arg1 = (wxRect2D *) 0 ;
9633 wxDouble arg2 ;
9634 void *argp1 = 0 ;
9635 int res1 = 0 ;
9636 void *argp2 ;
9637 int res2 = 0 ;
9638 PyObject * obj0 = 0 ;
9639 PyObject * obj1 = 0 ;
9640 char * kwnames[] = {
9641 (char *) "self",(char *) "n", NULL
9642 };
9643
9644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9646 if (!SWIG_IsOK(res1)) {
9647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9648 }
9649 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9650 {
9651 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9652 if (!SWIG_IsOK(res2)) {
9653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9654 }
9655 if (!argp2) {
9656 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9657 } else {
9658 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9659 arg2 = *temp;
9660 if (SWIG_IsNewObj(res2)) delete temp;
9661 }
9662 }
9663 {
9664 (arg1)->SetBottom(arg2);
9665 if (PyErr_Occurred()) SWIG_fail;
9666 }
9667 resultobj = SWIG_Py_Void();
9668 return resultobj;
9669 fail:
9670 return NULL;
9671 }
9672
9673
9674 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9675 PyObject *resultobj = 0;
9676 wxRect2D *arg1 = (wxRect2D *) 0 ;
9677 wxDouble arg2 ;
9678 void *argp1 = 0 ;
9679 int res1 = 0 ;
9680 void *argp2 ;
9681 int res2 = 0 ;
9682 PyObject * obj0 = 0 ;
9683 PyObject * obj1 = 0 ;
9684 char * kwnames[] = {
9685 (char *) "self",(char *) "n", NULL
9686 };
9687
9688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9690 if (!SWIG_IsOK(res1)) {
9691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9692 }
9693 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9694 {
9695 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9696 if (!SWIG_IsOK(res2)) {
9697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9698 }
9699 if (!argp2) {
9700 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9701 } else {
9702 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9703 arg2 = *temp;
9704 if (SWIG_IsNewObj(res2)) delete temp;
9705 }
9706 }
9707 {
9708 (arg1)->MoveBottomTo(arg2);
9709 if (PyErr_Occurred()) SWIG_fail;
9710 }
9711 resultobj = SWIG_Py_Void();
9712 return resultobj;
9713 fail:
9714 return NULL;
9715 }
9716
9717
9718 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9719 PyObject *resultobj = 0;
9720 wxRect2D *arg1 = (wxRect2D *) 0 ;
9721 wxDouble result;
9722 void *argp1 = 0 ;
9723 int res1 = 0 ;
9724 PyObject *swig_obj[1] ;
9725
9726 if (!args) SWIG_fail;
9727 swig_obj[0] = args;
9728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9729 if (!SWIG_IsOK(res1)) {
9730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9731 }
9732 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9733 {
9734 result = ((wxRect2D const *)arg1)->GetRight();
9735 if (PyErr_Occurred()) SWIG_fail;
9736 }
9737 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9738 return resultobj;
9739 fail:
9740 return NULL;
9741 }
9742
9743
9744 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9745 PyObject *resultobj = 0;
9746 wxRect2D *arg1 = (wxRect2D *) 0 ;
9747 wxDouble arg2 ;
9748 void *argp1 = 0 ;
9749 int res1 = 0 ;
9750 void *argp2 ;
9751 int res2 = 0 ;
9752 PyObject * obj0 = 0 ;
9753 PyObject * obj1 = 0 ;
9754 char * kwnames[] = {
9755 (char *) "self",(char *) "n", NULL
9756 };
9757
9758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9760 if (!SWIG_IsOK(res1)) {
9761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9762 }
9763 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9764 {
9765 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9766 if (!SWIG_IsOK(res2)) {
9767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9768 }
9769 if (!argp2) {
9770 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9771 } else {
9772 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9773 arg2 = *temp;
9774 if (SWIG_IsNewObj(res2)) delete temp;
9775 }
9776 }
9777 {
9778 (arg1)->SetRight(arg2);
9779 if (PyErr_Occurred()) SWIG_fail;
9780 }
9781 resultobj = SWIG_Py_Void();
9782 return resultobj;
9783 fail:
9784 return NULL;
9785 }
9786
9787
9788 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9789 PyObject *resultobj = 0;
9790 wxRect2D *arg1 = (wxRect2D *) 0 ;
9791 wxDouble arg2 ;
9792 void *argp1 = 0 ;
9793 int res1 = 0 ;
9794 void *argp2 ;
9795 int res2 = 0 ;
9796 PyObject * obj0 = 0 ;
9797 PyObject * obj1 = 0 ;
9798 char * kwnames[] = {
9799 (char *) "self",(char *) "n", NULL
9800 };
9801
9802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9804 if (!SWIG_IsOK(res1)) {
9805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9806 }
9807 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9808 {
9809 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9810 if (!SWIG_IsOK(res2)) {
9811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9812 }
9813 if (!argp2) {
9814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9815 } else {
9816 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9817 arg2 = *temp;
9818 if (SWIG_IsNewObj(res2)) delete temp;
9819 }
9820 }
9821 {
9822 (arg1)->MoveRightTo(arg2);
9823 if (PyErr_Occurred()) SWIG_fail;
9824 }
9825 resultobj = SWIG_Py_Void();
9826 return resultobj;
9827 fail:
9828 return NULL;
9829 }
9830
9831
9832 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9833 PyObject *resultobj = 0;
9834 wxRect2D *arg1 = (wxRect2D *) 0 ;
9835 wxPoint2D result;
9836 void *argp1 = 0 ;
9837 int res1 = 0 ;
9838 PyObject *swig_obj[1] ;
9839
9840 if (!args) SWIG_fail;
9841 swig_obj[0] = args;
9842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9843 if (!SWIG_IsOK(res1)) {
9844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9845 }
9846 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9847 {
9848 result = ((wxRect2D const *)arg1)->GetLeftTop();
9849 if (PyErr_Occurred()) SWIG_fail;
9850 }
9851 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9852 return resultobj;
9853 fail:
9854 return NULL;
9855 }
9856
9857
9858 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9859 PyObject *resultobj = 0;
9860 wxRect2D *arg1 = (wxRect2D *) 0 ;
9861 wxPoint2D *arg2 = 0 ;
9862 void *argp1 = 0 ;
9863 int res1 = 0 ;
9864 wxPoint2D temp2 ;
9865 PyObject * obj0 = 0 ;
9866 PyObject * obj1 = 0 ;
9867 char * kwnames[] = {
9868 (char *) "self",(char *) "pt", NULL
9869 };
9870
9871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9873 if (!SWIG_IsOK(res1)) {
9874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9875 }
9876 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9877 {
9878 arg2 = &temp2;
9879 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9880 }
9881 {
9882 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9883 if (PyErr_Occurred()) SWIG_fail;
9884 }
9885 resultobj = SWIG_Py_Void();
9886 return resultobj;
9887 fail:
9888 return NULL;
9889 }
9890
9891
9892 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9893 PyObject *resultobj = 0;
9894 wxRect2D *arg1 = (wxRect2D *) 0 ;
9895 wxPoint2D *arg2 = 0 ;
9896 void *argp1 = 0 ;
9897 int res1 = 0 ;
9898 wxPoint2D temp2 ;
9899 PyObject * obj0 = 0 ;
9900 PyObject * obj1 = 0 ;
9901 char * kwnames[] = {
9902 (char *) "self",(char *) "pt", NULL
9903 };
9904
9905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9907 if (!SWIG_IsOK(res1)) {
9908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9909 }
9910 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9911 {
9912 arg2 = &temp2;
9913 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9914 }
9915 {
9916 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9917 if (PyErr_Occurred()) SWIG_fail;
9918 }
9919 resultobj = SWIG_Py_Void();
9920 return resultobj;
9921 fail:
9922 return NULL;
9923 }
9924
9925
9926 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9927 PyObject *resultobj = 0;
9928 wxRect2D *arg1 = (wxRect2D *) 0 ;
9929 wxPoint2D result;
9930 void *argp1 = 0 ;
9931 int res1 = 0 ;
9932 PyObject *swig_obj[1] ;
9933
9934 if (!args) SWIG_fail;
9935 swig_obj[0] = args;
9936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9937 if (!SWIG_IsOK(res1)) {
9938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9939 }
9940 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9941 {
9942 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9943 if (PyErr_Occurred()) SWIG_fail;
9944 }
9945 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9946 return resultobj;
9947 fail:
9948 return NULL;
9949 }
9950
9951
9952 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9953 PyObject *resultobj = 0;
9954 wxRect2D *arg1 = (wxRect2D *) 0 ;
9955 wxPoint2D *arg2 = 0 ;
9956 void *argp1 = 0 ;
9957 int res1 = 0 ;
9958 wxPoint2D temp2 ;
9959 PyObject * obj0 = 0 ;
9960 PyObject * obj1 = 0 ;
9961 char * kwnames[] = {
9962 (char *) "self",(char *) "pt", NULL
9963 };
9964
9965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9967 if (!SWIG_IsOK(res1)) {
9968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9969 }
9970 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9971 {
9972 arg2 = &temp2;
9973 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9974 }
9975 {
9976 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9977 if (PyErr_Occurred()) SWIG_fail;
9978 }
9979 resultobj = SWIG_Py_Void();
9980 return resultobj;
9981 fail:
9982 return NULL;
9983 }
9984
9985
9986 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9987 PyObject *resultobj = 0;
9988 wxRect2D *arg1 = (wxRect2D *) 0 ;
9989 wxPoint2D *arg2 = 0 ;
9990 void *argp1 = 0 ;
9991 int res1 = 0 ;
9992 wxPoint2D temp2 ;
9993 PyObject * obj0 = 0 ;
9994 PyObject * obj1 = 0 ;
9995 char * kwnames[] = {
9996 (char *) "self",(char *) "pt", NULL
9997 };
9998
9999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10001 if (!SWIG_IsOK(res1)) {
10002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10003 }
10004 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10005 {
10006 arg2 = &temp2;
10007 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10008 }
10009 {
10010 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
10011 if (PyErr_Occurred()) SWIG_fail;
10012 }
10013 resultobj = SWIG_Py_Void();
10014 return resultobj;
10015 fail:
10016 return NULL;
10017 }
10018
10019
10020 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10021 PyObject *resultobj = 0;
10022 wxRect2D *arg1 = (wxRect2D *) 0 ;
10023 wxPoint2D result;
10024 void *argp1 = 0 ;
10025 int res1 = 0 ;
10026 PyObject *swig_obj[1] ;
10027
10028 if (!args) SWIG_fail;
10029 swig_obj[0] = args;
10030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10031 if (!SWIG_IsOK(res1)) {
10032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10033 }
10034 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10035 {
10036 result = ((wxRect2D const *)arg1)->GetRightTop();
10037 if (PyErr_Occurred()) SWIG_fail;
10038 }
10039 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10040 return resultobj;
10041 fail:
10042 return NULL;
10043 }
10044
10045
10046 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10047 PyObject *resultobj = 0;
10048 wxRect2D *arg1 = (wxRect2D *) 0 ;
10049 wxPoint2D *arg2 = 0 ;
10050 void *argp1 = 0 ;
10051 int res1 = 0 ;
10052 wxPoint2D temp2 ;
10053 PyObject * obj0 = 0 ;
10054 PyObject * obj1 = 0 ;
10055 char * kwnames[] = {
10056 (char *) "self",(char *) "pt", NULL
10057 };
10058
10059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
10060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10061 if (!SWIG_IsOK(res1)) {
10062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
10063 }
10064 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10065 {
10066 arg2 = &temp2;
10067 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10068 }
10069 {
10070 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
10071 if (PyErr_Occurred()) SWIG_fail;
10072 }
10073 resultobj = SWIG_Py_Void();
10074 return resultobj;
10075 fail:
10076 return NULL;
10077 }
10078
10079
10080 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10081 PyObject *resultobj = 0;
10082 wxRect2D *arg1 = (wxRect2D *) 0 ;
10083 wxPoint2D *arg2 = 0 ;
10084 void *argp1 = 0 ;
10085 int res1 = 0 ;
10086 wxPoint2D temp2 ;
10087 PyObject * obj0 = 0 ;
10088 PyObject * obj1 = 0 ;
10089 char * kwnames[] = {
10090 (char *) "self",(char *) "pt", NULL
10091 };
10092
10093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10095 if (!SWIG_IsOK(res1)) {
10096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10097 }
10098 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10099 {
10100 arg2 = &temp2;
10101 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10102 }
10103 {
10104 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10105 if (PyErr_Occurred()) SWIG_fail;
10106 }
10107 resultobj = SWIG_Py_Void();
10108 return resultobj;
10109 fail:
10110 return NULL;
10111 }
10112
10113
10114 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10115 PyObject *resultobj = 0;
10116 wxRect2D *arg1 = (wxRect2D *) 0 ;
10117 wxPoint2D result;
10118 void *argp1 = 0 ;
10119 int res1 = 0 ;
10120 PyObject *swig_obj[1] ;
10121
10122 if (!args) SWIG_fail;
10123 swig_obj[0] = args;
10124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10125 if (!SWIG_IsOK(res1)) {
10126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10127 }
10128 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10129 {
10130 result = ((wxRect2D const *)arg1)->GetRightBottom();
10131 if (PyErr_Occurred()) SWIG_fail;
10132 }
10133 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10134 return resultobj;
10135 fail:
10136 return NULL;
10137 }
10138
10139
10140 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10141 PyObject *resultobj = 0;
10142 wxRect2D *arg1 = (wxRect2D *) 0 ;
10143 wxPoint2D *arg2 = 0 ;
10144 void *argp1 = 0 ;
10145 int res1 = 0 ;
10146 wxPoint2D temp2 ;
10147 PyObject * obj0 = 0 ;
10148 PyObject * obj1 = 0 ;
10149 char * kwnames[] = {
10150 (char *) "self",(char *) "pt", NULL
10151 };
10152
10153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10155 if (!SWIG_IsOK(res1)) {
10156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10157 }
10158 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10159 {
10160 arg2 = &temp2;
10161 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10162 }
10163 {
10164 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10165 if (PyErr_Occurred()) SWIG_fail;
10166 }
10167 resultobj = SWIG_Py_Void();
10168 return resultobj;
10169 fail:
10170 return NULL;
10171 }
10172
10173
10174 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10175 PyObject *resultobj = 0;
10176 wxRect2D *arg1 = (wxRect2D *) 0 ;
10177 wxPoint2D *arg2 = 0 ;
10178 void *argp1 = 0 ;
10179 int res1 = 0 ;
10180 wxPoint2D temp2 ;
10181 PyObject * obj0 = 0 ;
10182 PyObject * obj1 = 0 ;
10183 char * kwnames[] = {
10184 (char *) "self",(char *) "pt", NULL
10185 };
10186
10187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10189 if (!SWIG_IsOK(res1)) {
10190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10191 }
10192 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10193 {
10194 arg2 = &temp2;
10195 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10196 }
10197 {
10198 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10199 if (PyErr_Occurred()) SWIG_fail;
10200 }
10201 resultobj = SWIG_Py_Void();
10202 return resultobj;
10203 fail:
10204 return NULL;
10205 }
10206
10207
10208 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10209 PyObject *resultobj = 0;
10210 wxRect2D *arg1 = (wxRect2D *) 0 ;
10211 wxPoint2D result;
10212 void *argp1 = 0 ;
10213 int res1 = 0 ;
10214 PyObject *swig_obj[1] ;
10215
10216 if (!args) SWIG_fail;
10217 swig_obj[0] = args;
10218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10219 if (!SWIG_IsOK(res1)) {
10220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10221 }
10222 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10223 {
10224 result = ((wxRect2D const *)arg1)->GetCentre();
10225 if (PyErr_Occurred()) SWIG_fail;
10226 }
10227 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10228 return resultobj;
10229 fail:
10230 return NULL;
10231 }
10232
10233
10234 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10235 PyObject *resultobj = 0;
10236 wxRect2D *arg1 = (wxRect2D *) 0 ;
10237 wxPoint2D *arg2 = 0 ;
10238 void *argp1 = 0 ;
10239 int res1 = 0 ;
10240 wxPoint2D temp2 ;
10241 PyObject * obj0 = 0 ;
10242 PyObject * obj1 = 0 ;
10243 char * kwnames[] = {
10244 (char *) "self",(char *) "pt", NULL
10245 };
10246
10247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10249 if (!SWIG_IsOK(res1)) {
10250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10251 }
10252 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10253 {
10254 arg2 = &temp2;
10255 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10256 }
10257 {
10258 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10259 if (PyErr_Occurred()) SWIG_fail;
10260 }
10261 resultobj = SWIG_Py_Void();
10262 return resultobj;
10263 fail:
10264 return NULL;
10265 }
10266
10267
10268 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10269 PyObject *resultobj = 0;
10270 wxRect2D *arg1 = (wxRect2D *) 0 ;
10271 wxPoint2D *arg2 = 0 ;
10272 void *argp1 = 0 ;
10273 int res1 = 0 ;
10274 wxPoint2D temp2 ;
10275 PyObject * obj0 = 0 ;
10276 PyObject * obj1 = 0 ;
10277 char * kwnames[] = {
10278 (char *) "self",(char *) "pt", NULL
10279 };
10280
10281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10283 if (!SWIG_IsOK(res1)) {
10284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10285 }
10286 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10287 {
10288 arg2 = &temp2;
10289 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10290 }
10291 {
10292 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10293 if (PyErr_Occurred()) SWIG_fail;
10294 }
10295 resultobj = SWIG_Py_Void();
10296 return resultobj;
10297 fail:
10298 return NULL;
10299 }
10300
10301
10302 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10303 PyObject *resultobj = 0;
10304 wxRect2D *arg1 = (wxRect2D *) 0 ;
10305 wxPoint2D *arg2 = 0 ;
10306 wxOutCode result;
10307 void *argp1 = 0 ;
10308 int res1 = 0 ;
10309 wxPoint2D temp2 ;
10310 PyObject * obj0 = 0 ;
10311 PyObject * obj1 = 0 ;
10312 char * kwnames[] = {
10313 (char *) "self",(char *) "pt", NULL
10314 };
10315
10316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10318 if (!SWIG_IsOK(res1)) {
10319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10320 }
10321 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10322 {
10323 arg2 = &temp2;
10324 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10325 }
10326 {
10327 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10328 if (PyErr_Occurred()) SWIG_fail;
10329 }
10330 resultobj = SWIG_From_int(static_cast< int >(result));
10331 return resultobj;
10332 fail:
10333 return NULL;
10334 }
10335
10336
10337 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10338 PyObject *resultobj = 0;
10339 wxRect2D *arg1 = (wxRect2D *) 0 ;
10340 wxPoint2D *arg2 = 0 ;
10341 bool result;
10342 void *argp1 = 0 ;
10343 int res1 = 0 ;
10344 wxPoint2D temp2 ;
10345 PyObject * obj0 = 0 ;
10346 PyObject * obj1 = 0 ;
10347 char * kwnames[] = {
10348 (char *) "self",(char *) "pt", NULL
10349 };
10350
10351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10353 if (!SWIG_IsOK(res1)) {
10354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10355 }
10356 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10357 {
10358 arg2 = &temp2;
10359 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10360 }
10361 {
10362 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10363 if (PyErr_Occurred()) SWIG_fail;
10364 }
10365 {
10366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10367 }
10368 return resultobj;
10369 fail:
10370 return NULL;
10371 }
10372
10373
10374 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10375 PyObject *resultobj = 0;
10376 wxRect2D *arg1 = (wxRect2D *) 0 ;
10377 wxRect2D *arg2 = 0 ;
10378 bool result;
10379 void *argp1 = 0 ;
10380 int res1 = 0 ;
10381 wxRect2D temp2 ;
10382 PyObject * obj0 = 0 ;
10383 PyObject * obj1 = 0 ;
10384 char * kwnames[] = {
10385 (char *) "self",(char *) "rect", NULL
10386 };
10387
10388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10390 if (!SWIG_IsOK(res1)) {
10391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10392 }
10393 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10394 {
10395 arg2 = &temp2;
10396 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10397 }
10398 {
10399 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10400 if (PyErr_Occurred()) SWIG_fail;
10401 }
10402 {
10403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10404 }
10405 return resultobj;
10406 fail:
10407 return NULL;
10408 }
10409
10410
10411 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10412 PyObject *resultobj = 0;
10413 wxRect2D *arg1 = (wxRect2D *) 0 ;
10414 bool result;
10415 void *argp1 = 0 ;
10416 int res1 = 0 ;
10417 PyObject *swig_obj[1] ;
10418
10419 if (!args) SWIG_fail;
10420 swig_obj[0] = args;
10421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10422 if (!SWIG_IsOK(res1)) {
10423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10424 }
10425 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10426 {
10427 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10428 if (PyErr_Occurred()) SWIG_fail;
10429 }
10430 {
10431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10432 }
10433 return resultobj;
10434 fail:
10435 return NULL;
10436 }
10437
10438
10439 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10440 PyObject *resultobj = 0;
10441 wxRect2D *arg1 = (wxRect2D *) 0 ;
10442 wxRect2D *arg2 = 0 ;
10443 bool result;
10444 void *argp1 = 0 ;
10445 int res1 = 0 ;
10446 wxRect2D temp2 ;
10447 PyObject * obj0 = 0 ;
10448 PyObject * obj1 = 0 ;
10449 char * kwnames[] = {
10450 (char *) "self",(char *) "rect", NULL
10451 };
10452
10453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10455 if (!SWIG_IsOK(res1)) {
10456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10457 }
10458 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10459 {
10460 arg2 = &temp2;
10461 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10462 }
10463 {
10464 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10465 if (PyErr_Occurred()) SWIG_fail;
10466 }
10467 {
10468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10469 }
10470 return resultobj;
10471 fail:
10472 return NULL;
10473 }
10474
10475
10476 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10477 PyObject *resultobj = 0;
10478 wxRect2D *arg1 = (wxRect2D *) 0 ;
10479 wxDouble arg2 ;
10480 wxDouble arg3 ;
10481 void *argp1 = 0 ;
10482 int res1 = 0 ;
10483 void *argp2 ;
10484 int res2 = 0 ;
10485 void *argp3 ;
10486 int res3 = 0 ;
10487
10488 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10490 if (!SWIG_IsOK(res1)) {
10491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10492 }
10493 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10494 {
10495 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10496 if (!SWIG_IsOK(res2)) {
10497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10498 }
10499 if (!argp2) {
10500 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10501 } else {
10502 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10503 arg2 = *temp;
10504 if (SWIG_IsNewObj(res2)) delete temp;
10505 }
10506 }
10507 {
10508 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10509 if (!SWIG_IsOK(res3)) {
10510 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10511 }
10512 if (!argp3) {
10513 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10514 } else {
10515 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10516 arg3 = *temp;
10517 if (SWIG_IsNewObj(res3)) delete temp;
10518 }
10519 }
10520 {
10521 (arg1)->Inset(arg2,arg3);
10522 if (PyErr_Occurred()) SWIG_fail;
10523 }
10524 resultobj = SWIG_Py_Void();
10525 return resultobj;
10526 fail:
10527 return NULL;
10528 }
10529
10530
10531 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10532 PyObject *resultobj = 0;
10533 wxRect2D *arg1 = (wxRect2D *) 0 ;
10534 wxDouble arg2 ;
10535 wxDouble arg3 ;
10536 wxDouble arg4 ;
10537 wxDouble arg5 ;
10538 void *argp1 = 0 ;
10539 int res1 = 0 ;
10540 void *argp2 ;
10541 int res2 = 0 ;
10542 void *argp3 ;
10543 int res3 = 0 ;
10544 void *argp4 ;
10545 int res4 = 0 ;
10546 void *argp5 ;
10547 int res5 = 0 ;
10548
10549 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10551 if (!SWIG_IsOK(res1)) {
10552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10553 }
10554 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10555 {
10556 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10557 if (!SWIG_IsOK(res2)) {
10558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10559 }
10560 if (!argp2) {
10561 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10562 } else {
10563 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10564 arg2 = *temp;
10565 if (SWIG_IsNewObj(res2)) delete temp;
10566 }
10567 }
10568 {
10569 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10570 if (!SWIG_IsOK(res3)) {
10571 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10572 }
10573 if (!argp3) {
10574 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10575 } else {
10576 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10577 arg3 = *temp;
10578 if (SWIG_IsNewObj(res3)) delete temp;
10579 }
10580 }
10581 {
10582 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10583 if (!SWIG_IsOK(res4)) {
10584 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10585 }
10586 if (!argp4) {
10587 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10588 } else {
10589 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10590 arg4 = *temp;
10591 if (SWIG_IsNewObj(res4)) delete temp;
10592 }
10593 }
10594 {
10595 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10596 if (!SWIG_IsOK(res5)) {
10597 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10598 }
10599 if (!argp5) {
10600 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10601 } else {
10602 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10603 arg5 = *temp;
10604 if (SWIG_IsNewObj(res5)) delete temp;
10605 }
10606 }
10607 {
10608 (arg1)->Inset(arg2,arg3,arg4,arg5);
10609 if (PyErr_Occurred()) SWIG_fail;
10610 }
10611 resultobj = SWIG_Py_Void();
10612 return resultobj;
10613 fail:
10614 return NULL;
10615 }
10616
10617
10618 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10619 int argc;
10620 PyObject *argv[6];
10621
10622 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10623 --argc;
10624 if (argc == 3) {
10625 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10626 }
10627 if (argc == 5) {
10628 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10629 }
10630
10631 fail:
10632 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10633 return NULL;
10634 }
10635
10636
10637 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10638 PyObject *resultobj = 0;
10639 wxRect2D *arg1 = (wxRect2D *) 0 ;
10640 wxPoint2D *arg2 = 0 ;
10641 void *argp1 = 0 ;
10642 int res1 = 0 ;
10643 wxPoint2D temp2 ;
10644 PyObject * obj0 = 0 ;
10645 PyObject * obj1 = 0 ;
10646 char * kwnames[] = {
10647 (char *) "self",(char *) "pt", NULL
10648 };
10649
10650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10652 if (!SWIG_IsOK(res1)) {
10653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10654 }
10655 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10656 {
10657 arg2 = &temp2;
10658 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10659 }
10660 {
10661 (arg1)->Offset((wxPoint2D const &)*arg2);
10662 if (PyErr_Occurred()) SWIG_fail;
10663 }
10664 resultobj = SWIG_Py_Void();
10665 return resultobj;
10666 fail:
10667 return NULL;
10668 }
10669
10670
10671 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10672 PyObject *resultobj = 0;
10673 wxRect2D *arg1 = (wxRect2D *) 0 ;
10674 wxRect2D *arg2 = 0 ;
10675 void *argp1 = 0 ;
10676 int res1 = 0 ;
10677 wxRect2D temp2 ;
10678 PyObject * obj0 = 0 ;
10679 PyObject * obj1 = 0 ;
10680 char * kwnames[] = {
10681 (char *) "self",(char *) "rect", NULL
10682 };
10683
10684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10686 if (!SWIG_IsOK(res1)) {
10687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10688 }
10689 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10690 {
10691 arg2 = &temp2;
10692 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10693 }
10694 {
10695 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10696 if (PyErr_Occurred()) SWIG_fail;
10697 }
10698 resultobj = SWIG_Py_Void();
10699 return resultobj;
10700 fail:
10701 return NULL;
10702 }
10703
10704
10705 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10706 PyObject *resultobj = 0;
10707 wxRect2D *arg1 = (wxRect2D *) 0 ;
10708 int arg2 ;
10709 int arg3 ;
10710 wxPoint2D result;
10711 void *argp1 = 0 ;
10712 int res1 = 0 ;
10713 int val2 ;
10714 int ecode2 = 0 ;
10715 int val3 ;
10716 int ecode3 = 0 ;
10717 PyObject * obj0 = 0 ;
10718 PyObject * obj1 = 0 ;
10719 PyObject * obj2 = 0 ;
10720 char * kwnames[] = {
10721 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10722 };
10723
10724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10726 if (!SWIG_IsOK(res1)) {
10727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10728 }
10729 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10730 ecode2 = SWIG_AsVal_int(obj1, &val2);
10731 if (!SWIG_IsOK(ecode2)) {
10732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10733 }
10734 arg2 = static_cast< int >(val2);
10735 ecode3 = SWIG_AsVal_int(obj2, &val3);
10736 if (!SWIG_IsOK(ecode3)) {
10737 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10738 }
10739 arg3 = static_cast< int >(val3);
10740 {
10741 result = (arg1)->Interpolate(arg2,arg3);
10742 if (PyErr_Occurred()) SWIG_fail;
10743 }
10744 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10745 return resultobj;
10746 fail:
10747 return NULL;
10748 }
10749
10750
10751 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10752 PyObject *resultobj = 0;
10753 wxRect2D *arg1 = (wxRect2D *) 0 ;
10754 wxRect2D *arg2 = 0 ;
10755 void *argp1 = 0 ;
10756 int res1 = 0 ;
10757 wxRect2D temp2 ;
10758 PyObject * obj0 = 0 ;
10759 PyObject * obj1 = 0 ;
10760 char * kwnames[] = {
10761 (char *) "self",(char *) "otherRect", NULL
10762 };
10763
10764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10766 if (!SWIG_IsOK(res1)) {
10767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10768 }
10769 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10770 {
10771 arg2 = &temp2;
10772 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10773 }
10774 {
10775 (arg1)->Intersect((wxRect2D const &)*arg2);
10776 if (PyErr_Occurred()) SWIG_fail;
10777 }
10778 resultobj = SWIG_Py_Void();
10779 return resultobj;
10780 fail:
10781 return NULL;
10782 }
10783
10784
10785 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10786 PyObject *resultobj = 0;
10787 wxRect2D *arg1 = (wxRect2D *) 0 ;
10788 wxRect2D *arg2 = 0 ;
10789 wxRect2D result;
10790 void *argp1 = 0 ;
10791 int res1 = 0 ;
10792 wxRect2D temp2 ;
10793 PyObject * obj0 = 0 ;
10794 PyObject * obj1 = 0 ;
10795 char * kwnames[] = {
10796 (char *) "self",(char *) "otherRect", NULL
10797 };
10798
10799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10801 if (!SWIG_IsOK(res1)) {
10802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10803 }
10804 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10805 {
10806 arg2 = &temp2;
10807 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10808 }
10809 {
10810 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10811 if (PyErr_Occurred()) SWIG_fail;
10812 }
10813 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10814 return resultobj;
10815 fail:
10816 return NULL;
10817 }
10818
10819
10820 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10821 PyObject *resultobj = 0;
10822 wxRect2D *arg1 = (wxRect2D *) 0 ;
10823 wxRect2D *arg2 = 0 ;
10824 bool result;
10825 void *argp1 = 0 ;
10826 int res1 = 0 ;
10827 wxRect2D temp2 ;
10828 PyObject * obj0 = 0 ;
10829 PyObject * obj1 = 0 ;
10830 char * kwnames[] = {
10831 (char *) "self",(char *) "rect", NULL
10832 };
10833
10834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10836 if (!SWIG_IsOK(res1)) {
10837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10838 }
10839 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10840 {
10841 arg2 = &temp2;
10842 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10843 }
10844 {
10845 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10846 if (PyErr_Occurred()) SWIG_fail;
10847 }
10848 {
10849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10850 }
10851 return resultobj;
10852 fail:
10853 return NULL;
10854 }
10855
10856
10857 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10858 PyObject *resultobj = 0;
10859 wxRect2D *arg1 = (wxRect2D *) 0 ;
10860 wxRect2D *arg2 = 0 ;
10861 void *argp1 = 0 ;
10862 int res1 = 0 ;
10863 wxRect2D temp2 ;
10864 PyObject * obj0 = 0 ;
10865 PyObject * obj1 = 0 ;
10866 char * kwnames[] = {
10867 (char *) "self",(char *) "otherRect", NULL
10868 };
10869
10870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10872 if (!SWIG_IsOK(res1)) {
10873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10874 }
10875 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10876 {
10877 arg2 = &temp2;
10878 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10879 }
10880 {
10881 (arg1)->Union((wxRect2D const &)*arg2);
10882 if (PyErr_Occurred()) SWIG_fail;
10883 }
10884 resultobj = SWIG_Py_Void();
10885 return resultobj;
10886 fail:
10887 return NULL;
10888 }
10889
10890
10891 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10892 PyObject *resultobj = 0;
10893 wxRect2D *arg1 = (wxRect2D *) 0 ;
10894 wxRect2D *arg2 = 0 ;
10895 wxRect2D result;
10896 void *argp1 = 0 ;
10897 int res1 = 0 ;
10898 wxRect2D temp2 ;
10899 PyObject * obj0 = 0 ;
10900 PyObject * obj1 = 0 ;
10901 char * kwnames[] = {
10902 (char *) "self",(char *) "otherRect", NULL
10903 };
10904
10905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10907 if (!SWIG_IsOK(res1)) {
10908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10909 }
10910 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10911 {
10912 arg2 = &temp2;
10913 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10914 }
10915 {
10916 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10917 if (PyErr_Occurred()) SWIG_fail;
10918 }
10919 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10920 return resultobj;
10921 fail:
10922 return NULL;
10923 }
10924
10925
10926 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10927 PyObject *resultobj = 0;
10928 wxRect2D *arg1 = (wxRect2D *) 0 ;
10929 wxDouble arg2 ;
10930 void *argp1 = 0 ;
10931 int res1 = 0 ;
10932 void *argp2 ;
10933 int res2 = 0 ;
10934
10935 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10937 if (!SWIG_IsOK(res1)) {
10938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10939 }
10940 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10941 {
10942 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10943 if (!SWIG_IsOK(res2)) {
10944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10945 }
10946 if (!argp2) {
10947 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10948 } else {
10949 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10950 arg2 = *temp;
10951 if (SWIG_IsNewObj(res2)) delete temp;
10952 }
10953 }
10954 {
10955 (arg1)->Scale(arg2);
10956 if (PyErr_Occurred()) SWIG_fail;
10957 }
10958 resultobj = SWIG_Py_Void();
10959 return resultobj;
10960 fail:
10961 return NULL;
10962 }
10963
10964
10965 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10966 PyObject *resultobj = 0;
10967 wxRect2D *arg1 = (wxRect2D *) 0 ;
10968 int arg2 ;
10969 int arg3 ;
10970 void *argp1 = 0 ;
10971 int res1 = 0 ;
10972 int val2 ;
10973 int ecode2 = 0 ;
10974 int val3 ;
10975 int ecode3 = 0 ;
10976
10977 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10979 if (!SWIG_IsOK(res1)) {
10980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10981 }
10982 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10983 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10984 if (!SWIG_IsOK(ecode2)) {
10985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10986 }
10987 arg2 = static_cast< int >(val2);
10988 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10989 if (!SWIG_IsOK(ecode3)) {
10990 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10991 }
10992 arg3 = static_cast< int >(val3);
10993 {
10994 (arg1)->Scale(arg2,arg3);
10995 if (PyErr_Occurred()) SWIG_fail;
10996 }
10997 resultobj = SWIG_Py_Void();
10998 return resultobj;
10999 fail:
11000 return NULL;
11001 }
11002
11003
11004 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
11005 int argc;
11006 PyObject *argv[4];
11007
11008 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
11009 --argc;
11010 if (argc == 2) {
11011 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
11012 }
11013 if (argc == 3) {
11014 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
11015 }
11016
11017 fail:
11018 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
11019 return NULL;
11020 }
11021
11022
11023 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11024 PyObject *resultobj = 0;
11025 wxRect2D *arg1 = (wxRect2D *) 0 ;
11026 PyObject *arg2 = (PyObject *) 0 ;
11027 bool result;
11028 void *argp1 = 0 ;
11029 int res1 = 0 ;
11030 PyObject * obj0 = 0 ;
11031 PyObject * obj1 = 0 ;
11032 char * kwnames[] = {
11033 (char *) "self",(char *) "other", NULL
11034 };
11035
11036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
11037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11038 if (!SWIG_IsOK(res1)) {
11039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11040 }
11041 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11042 arg2 = obj1;
11043 {
11044 result = (bool)wxRect2D___eq__(arg1,arg2);
11045 if (PyErr_Occurred()) SWIG_fail;
11046 }
11047 {
11048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11049 }
11050 return resultobj;
11051 fail:
11052 return NULL;
11053 }
11054
11055
11056 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11057 PyObject *resultobj = 0;
11058 wxRect2D *arg1 = (wxRect2D *) 0 ;
11059 PyObject *arg2 = (PyObject *) 0 ;
11060 bool result;
11061 void *argp1 = 0 ;
11062 int res1 = 0 ;
11063 PyObject * obj0 = 0 ;
11064 PyObject * obj1 = 0 ;
11065 char * kwnames[] = {
11066 (char *) "self",(char *) "other", NULL
11067 };
11068
11069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
11070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11071 if (!SWIG_IsOK(res1)) {
11072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11073 }
11074 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11075 arg2 = obj1;
11076 {
11077 result = (bool)wxRect2D___ne__(arg1,arg2);
11078 if (PyErr_Occurred()) SWIG_fail;
11079 }
11080 {
11081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11082 }
11083 return resultobj;
11084 fail:
11085 return NULL;
11086 }
11087
11088
11089 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11090 PyObject *resultobj = 0;
11091 wxRect2D *arg1 = (wxRect2D *) 0 ;
11092 wxDouble arg2 ;
11093 void *argp1 = 0 ;
11094 int res1 = 0 ;
11095 void *argp2 ;
11096 int res2 = 0 ;
11097 PyObject *swig_obj[2] ;
11098
11099 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11101 if (!SWIG_IsOK(res1)) {
11102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11103 }
11104 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11105 {
11106 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11107 if (!SWIG_IsOK(res2)) {
11108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11109 }
11110 if (!argp2) {
11111 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11112 } else {
11113 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11114 arg2 = *temp;
11115 if (SWIG_IsNewObj(res2)) delete temp;
11116 }
11117 }
11118 if (arg1) (arg1)->m_x = arg2;
11119
11120 resultobj = SWIG_Py_Void();
11121 return resultobj;
11122 fail:
11123 return NULL;
11124 }
11125
11126
11127 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11128 PyObject *resultobj = 0;
11129 wxRect2D *arg1 = (wxRect2D *) 0 ;
11130 wxDouble result;
11131 void *argp1 = 0 ;
11132 int res1 = 0 ;
11133 PyObject *swig_obj[1] ;
11134
11135 if (!args) SWIG_fail;
11136 swig_obj[0] = args;
11137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11138 if (!SWIG_IsOK(res1)) {
11139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11140 }
11141 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11142 result = ((arg1)->m_x);
11143 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11144 return resultobj;
11145 fail:
11146 return NULL;
11147 }
11148
11149
11150 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11151 PyObject *resultobj = 0;
11152 wxRect2D *arg1 = (wxRect2D *) 0 ;
11153 wxDouble arg2 ;
11154 void *argp1 = 0 ;
11155 int res1 = 0 ;
11156 void *argp2 ;
11157 int res2 = 0 ;
11158 PyObject *swig_obj[2] ;
11159
11160 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11162 if (!SWIG_IsOK(res1)) {
11163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11164 }
11165 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11166 {
11167 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11168 if (!SWIG_IsOK(res2)) {
11169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11170 }
11171 if (!argp2) {
11172 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11173 } else {
11174 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11175 arg2 = *temp;
11176 if (SWIG_IsNewObj(res2)) delete temp;
11177 }
11178 }
11179 if (arg1) (arg1)->m_y = arg2;
11180
11181 resultobj = SWIG_Py_Void();
11182 return resultobj;
11183 fail:
11184 return NULL;
11185 }
11186
11187
11188 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11189 PyObject *resultobj = 0;
11190 wxRect2D *arg1 = (wxRect2D *) 0 ;
11191 wxDouble result;
11192 void *argp1 = 0 ;
11193 int res1 = 0 ;
11194 PyObject *swig_obj[1] ;
11195
11196 if (!args) SWIG_fail;
11197 swig_obj[0] = args;
11198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11199 if (!SWIG_IsOK(res1)) {
11200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11201 }
11202 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11203 result = ((arg1)->m_y);
11204 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11205 return resultobj;
11206 fail:
11207 return NULL;
11208 }
11209
11210
11211 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11212 PyObject *resultobj = 0;
11213 wxRect2D *arg1 = (wxRect2D *) 0 ;
11214 wxDouble arg2 ;
11215 void *argp1 = 0 ;
11216 int res1 = 0 ;
11217 void *argp2 ;
11218 int res2 = 0 ;
11219 PyObject *swig_obj[2] ;
11220
11221 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11223 if (!SWIG_IsOK(res1)) {
11224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11225 }
11226 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11227 {
11228 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11229 if (!SWIG_IsOK(res2)) {
11230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11231 }
11232 if (!argp2) {
11233 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11234 } else {
11235 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11236 arg2 = *temp;
11237 if (SWIG_IsNewObj(res2)) delete temp;
11238 }
11239 }
11240 if (arg1) (arg1)->m_width = arg2;
11241
11242 resultobj = SWIG_Py_Void();
11243 return resultobj;
11244 fail:
11245 return NULL;
11246 }
11247
11248
11249 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11250 PyObject *resultobj = 0;
11251 wxRect2D *arg1 = (wxRect2D *) 0 ;
11252 wxDouble result;
11253 void *argp1 = 0 ;
11254 int res1 = 0 ;
11255 PyObject *swig_obj[1] ;
11256
11257 if (!args) SWIG_fail;
11258 swig_obj[0] = args;
11259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11260 if (!SWIG_IsOK(res1)) {
11261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11262 }
11263 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11264 result = ((arg1)->m_width);
11265 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11266 return resultobj;
11267 fail:
11268 return NULL;
11269 }
11270
11271
11272 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11273 PyObject *resultobj = 0;
11274 wxRect2D *arg1 = (wxRect2D *) 0 ;
11275 wxDouble arg2 ;
11276 void *argp1 = 0 ;
11277 int res1 = 0 ;
11278 void *argp2 ;
11279 int res2 = 0 ;
11280 PyObject *swig_obj[2] ;
11281
11282 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11284 if (!SWIG_IsOK(res1)) {
11285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11286 }
11287 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11288 {
11289 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11290 if (!SWIG_IsOK(res2)) {
11291 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11292 }
11293 if (!argp2) {
11294 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11295 } else {
11296 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11297 arg2 = *temp;
11298 if (SWIG_IsNewObj(res2)) delete temp;
11299 }
11300 }
11301 if (arg1) (arg1)->m_height = arg2;
11302
11303 resultobj = SWIG_Py_Void();
11304 return resultobj;
11305 fail:
11306 return NULL;
11307 }
11308
11309
11310 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11311 PyObject *resultobj = 0;
11312 wxRect2D *arg1 = (wxRect2D *) 0 ;
11313 wxDouble result;
11314 void *argp1 = 0 ;
11315 int res1 = 0 ;
11316 PyObject *swig_obj[1] ;
11317
11318 if (!args) SWIG_fail;
11319 swig_obj[0] = args;
11320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11321 if (!SWIG_IsOK(res1)) {
11322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11323 }
11324 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11325 result = ((arg1)->m_height);
11326 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11327 return resultobj;
11328 fail:
11329 return NULL;
11330 }
11331
11332
11333 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11334 PyObject *resultobj = 0;
11335 wxRect2D *arg1 = (wxRect2D *) 0 ;
11336 wxDouble arg2 = (wxDouble) 0 ;
11337 wxDouble arg3 = (wxDouble) 0 ;
11338 wxDouble arg4 = (wxDouble) 0 ;
11339 wxDouble arg5 = (wxDouble) 0 ;
11340 void *argp1 = 0 ;
11341 int res1 = 0 ;
11342 void *argp2 ;
11343 int res2 = 0 ;
11344 void *argp3 ;
11345 int res3 = 0 ;
11346 void *argp4 ;
11347 int res4 = 0 ;
11348 void *argp5 ;
11349 int res5 = 0 ;
11350 PyObject * obj0 = 0 ;
11351 PyObject * obj1 = 0 ;
11352 PyObject * obj2 = 0 ;
11353 PyObject * obj3 = 0 ;
11354 PyObject * obj4 = 0 ;
11355 char * kwnames[] = {
11356 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11357 };
11358
11359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11361 if (!SWIG_IsOK(res1)) {
11362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11363 }
11364 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11365 if (obj1) {
11366 {
11367 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11368 if (!SWIG_IsOK(res2)) {
11369 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11370 }
11371 if (!argp2) {
11372 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11373 } else {
11374 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11375 arg2 = *temp;
11376 if (SWIG_IsNewObj(res2)) delete temp;
11377 }
11378 }
11379 }
11380 if (obj2) {
11381 {
11382 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11383 if (!SWIG_IsOK(res3)) {
11384 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11385 }
11386 if (!argp3) {
11387 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11388 } else {
11389 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11390 arg3 = *temp;
11391 if (SWIG_IsNewObj(res3)) delete temp;
11392 }
11393 }
11394 }
11395 if (obj3) {
11396 {
11397 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11398 if (!SWIG_IsOK(res4)) {
11399 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11400 }
11401 if (!argp4) {
11402 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11403 } else {
11404 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11405 arg4 = *temp;
11406 if (SWIG_IsNewObj(res4)) delete temp;
11407 }
11408 }
11409 }
11410 if (obj4) {
11411 {
11412 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11413 if (!SWIG_IsOK(res5)) {
11414 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11415 }
11416 if (!argp5) {
11417 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11418 } else {
11419 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11420 arg5 = *temp;
11421 if (SWIG_IsNewObj(res5)) delete temp;
11422 }
11423 }
11424 }
11425 {
11426 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11427 if (PyErr_Occurred()) SWIG_fail;
11428 }
11429 resultobj = SWIG_Py_Void();
11430 return resultobj;
11431 fail:
11432 return NULL;
11433 }
11434
11435
11436 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11437 PyObject *resultobj = 0;
11438 wxRect2D *arg1 = (wxRect2D *) 0 ;
11439 PyObject *result = 0 ;
11440 void *argp1 = 0 ;
11441 int res1 = 0 ;
11442 PyObject *swig_obj[1] ;
11443
11444 if (!args) SWIG_fail;
11445 swig_obj[0] = args;
11446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11447 if (!SWIG_IsOK(res1)) {
11448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11449 }
11450 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11451 {
11452 result = (PyObject *)wxRect2D_Get(arg1);
11453 if (PyErr_Occurred()) SWIG_fail;
11454 }
11455 resultobj = result;
11456 return resultobj;
11457 fail:
11458 return NULL;
11459 }
11460
11461
11462 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11463 PyObject *obj;
11464 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11465 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11466 return SWIG_Py_Void();
11467 }
11468
11469 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11470 return SWIG_Python_InitShadowInstance(args);
11471 }
11472
11473 SWIGINTERN int DefaultPosition_set(PyObject *) {
11474 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11475 return 1;
11476 }
11477
11478
11479 SWIGINTERN PyObject *DefaultPosition_get(void) {
11480 PyObject *pyobj = 0;
11481
11482 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11483 return pyobj;
11484 }
11485
11486
11487 SWIGINTERN int DefaultSize_set(PyObject *) {
11488 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11489 return 1;
11490 }
11491
11492
11493 SWIGINTERN PyObject *DefaultSize_get(void) {
11494 PyObject *pyobj = 0;
11495
11496 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11497 return pyobj;
11498 }
11499
11500
11501 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11502 PyObject *resultobj = 0;
11503 PyObject *arg1 = (PyObject *) 0 ;
11504 wxPyInputStream *result = 0 ;
11505 PyObject * obj0 = 0 ;
11506 char * kwnames[] = {
11507 (char *) "p", NULL
11508 };
11509
11510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11511 arg1 = obj0;
11512 {
11513 PyThreadState* __tstate = wxPyBeginAllowThreads();
11514 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11515 wxPyEndAllowThreads(__tstate);
11516 if (PyErr_Occurred()) SWIG_fail;
11517 }
11518 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11519 return resultobj;
11520 fail:
11521 return NULL;
11522 }
11523
11524
11525 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11526 PyObject *resultobj = 0;
11527 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11528 void *argp1 = 0 ;
11529 int res1 = 0 ;
11530 PyObject *swig_obj[1] ;
11531
11532 if (!args) SWIG_fail;
11533 swig_obj[0] = args;
11534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11535 if (!SWIG_IsOK(res1)) {
11536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11537 }
11538 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11539 {
11540 PyThreadState* __tstate = wxPyBeginAllowThreads();
11541 delete arg1;
11542
11543 wxPyEndAllowThreads(__tstate);
11544 if (PyErr_Occurred()) SWIG_fail;
11545 }
11546 resultobj = SWIG_Py_Void();
11547 return resultobj;
11548 fail:
11549 return NULL;
11550 }
11551
11552
11553 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11554 PyObject *resultobj = 0;
11555 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11556 void *argp1 = 0 ;
11557 int res1 = 0 ;
11558 PyObject *swig_obj[1] ;
11559
11560 if (!args) SWIG_fail;
11561 swig_obj[0] = args;
11562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11563 if (!SWIG_IsOK(res1)) {
11564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11565 }
11566 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11567 {
11568 PyThreadState* __tstate = wxPyBeginAllowThreads();
11569 (arg1)->close();
11570 wxPyEndAllowThreads(__tstate);
11571 if (PyErr_Occurred()) SWIG_fail;
11572 }
11573 resultobj = SWIG_Py_Void();
11574 return resultobj;
11575 fail:
11576 return NULL;
11577 }
11578
11579
11580 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11581 PyObject *resultobj = 0;
11582 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11583 void *argp1 = 0 ;
11584 int res1 = 0 ;
11585 PyObject *swig_obj[1] ;
11586
11587 if (!args) SWIG_fail;
11588 swig_obj[0] = args;
11589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11590 if (!SWIG_IsOK(res1)) {
11591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11592 }
11593 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11594 {
11595 PyThreadState* __tstate = wxPyBeginAllowThreads();
11596 (arg1)->flush();
11597 wxPyEndAllowThreads(__tstate);
11598 if (PyErr_Occurred()) SWIG_fail;
11599 }
11600 resultobj = SWIG_Py_Void();
11601 return resultobj;
11602 fail:
11603 return NULL;
11604 }
11605
11606
11607 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11608 PyObject *resultobj = 0;
11609 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11610 bool result;
11611 void *argp1 = 0 ;
11612 int res1 = 0 ;
11613 PyObject *swig_obj[1] ;
11614
11615 if (!args) SWIG_fail;
11616 swig_obj[0] = args;
11617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11618 if (!SWIG_IsOK(res1)) {
11619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11620 }
11621 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11622 {
11623 PyThreadState* __tstate = wxPyBeginAllowThreads();
11624 result = (bool)(arg1)->eof();
11625 wxPyEndAllowThreads(__tstate);
11626 if (PyErr_Occurred()) SWIG_fail;
11627 }
11628 {
11629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11630 }
11631 return resultobj;
11632 fail:
11633 return NULL;
11634 }
11635
11636
11637 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11638 PyObject *resultobj = 0;
11639 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11640 int arg2 = (int) -1 ;
11641 PyObject *result = 0 ;
11642 void *argp1 = 0 ;
11643 int res1 = 0 ;
11644 int val2 ;
11645 int ecode2 = 0 ;
11646 PyObject * obj0 = 0 ;
11647 PyObject * obj1 = 0 ;
11648 char * kwnames[] = {
11649 (char *) "self",(char *) "size", NULL
11650 };
11651
11652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11654 if (!SWIG_IsOK(res1)) {
11655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11656 }
11657 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11658 if (obj1) {
11659 ecode2 = SWIG_AsVal_int(obj1, &val2);
11660 if (!SWIG_IsOK(ecode2)) {
11661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11662 }
11663 arg2 = static_cast< int >(val2);
11664 }
11665 {
11666 PyThreadState* __tstate = wxPyBeginAllowThreads();
11667 result = (PyObject *)(arg1)->read(arg2);
11668 wxPyEndAllowThreads(__tstate);
11669 if (PyErr_Occurred()) SWIG_fail;
11670 }
11671 resultobj = result;
11672 return resultobj;
11673 fail:
11674 return NULL;
11675 }
11676
11677
11678 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11679 PyObject *resultobj = 0;
11680 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11681 int arg2 = (int) -1 ;
11682 PyObject *result = 0 ;
11683 void *argp1 = 0 ;
11684 int res1 = 0 ;
11685 int val2 ;
11686 int ecode2 = 0 ;
11687 PyObject * obj0 = 0 ;
11688 PyObject * obj1 = 0 ;
11689 char * kwnames[] = {
11690 (char *) "self",(char *) "size", NULL
11691 };
11692
11693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11695 if (!SWIG_IsOK(res1)) {
11696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11697 }
11698 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11699 if (obj1) {
11700 ecode2 = SWIG_AsVal_int(obj1, &val2);
11701 if (!SWIG_IsOK(ecode2)) {
11702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11703 }
11704 arg2 = static_cast< int >(val2);
11705 }
11706 {
11707 PyThreadState* __tstate = wxPyBeginAllowThreads();
11708 result = (PyObject *)(arg1)->readline(arg2);
11709 wxPyEndAllowThreads(__tstate);
11710 if (PyErr_Occurred()) SWIG_fail;
11711 }
11712 resultobj = result;
11713 return resultobj;
11714 fail:
11715 return NULL;
11716 }
11717
11718
11719 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11720 PyObject *resultobj = 0;
11721 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11722 int arg2 = (int) -1 ;
11723 PyObject *result = 0 ;
11724 void *argp1 = 0 ;
11725 int res1 = 0 ;
11726 int val2 ;
11727 int ecode2 = 0 ;
11728 PyObject * obj0 = 0 ;
11729 PyObject * obj1 = 0 ;
11730 char * kwnames[] = {
11731 (char *) "self",(char *) "sizehint", NULL
11732 };
11733
11734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11736 if (!SWIG_IsOK(res1)) {
11737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11738 }
11739 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11740 if (obj1) {
11741 ecode2 = SWIG_AsVal_int(obj1, &val2);
11742 if (!SWIG_IsOK(ecode2)) {
11743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11744 }
11745 arg2 = static_cast< int >(val2);
11746 }
11747 {
11748 PyThreadState* __tstate = wxPyBeginAllowThreads();
11749 result = (PyObject *)(arg1)->readlines(arg2);
11750 wxPyEndAllowThreads(__tstate);
11751 if (PyErr_Occurred()) SWIG_fail;
11752 }
11753 resultobj = result;
11754 return resultobj;
11755 fail:
11756 return NULL;
11757 }
11758
11759
11760 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11761 PyObject *resultobj = 0;
11762 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11763 int arg2 ;
11764 int arg3 = (int) 0 ;
11765 void *argp1 = 0 ;
11766 int res1 = 0 ;
11767 int val2 ;
11768 int ecode2 = 0 ;
11769 int val3 ;
11770 int ecode3 = 0 ;
11771 PyObject * obj0 = 0 ;
11772 PyObject * obj1 = 0 ;
11773 PyObject * obj2 = 0 ;
11774 char * kwnames[] = {
11775 (char *) "self",(char *) "offset",(char *) "whence", NULL
11776 };
11777
11778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11780 if (!SWIG_IsOK(res1)) {
11781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11782 }
11783 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11784 ecode2 = SWIG_AsVal_int(obj1, &val2);
11785 if (!SWIG_IsOK(ecode2)) {
11786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11787 }
11788 arg2 = static_cast< int >(val2);
11789 if (obj2) {
11790 ecode3 = SWIG_AsVal_int(obj2, &val3);
11791 if (!SWIG_IsOK(ecode3)) {
11792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11793 }
11794 arg3 = static_cast< int >(val3);
11795 }
11796 {
11797 PyThreadState* __tstate = wxPyBeginAllowThreads();
11798 (arg1)->seek(arg2,arg3);
11799 wxPyEndAllowThreads(__tstate);
11800 if (PyErr_Occurred()) SWIG_fail;
11801 }
11802 resultobj = SWIG_Py_Void();
11803 return resultobj;
11804 fail:
11805 return NULL;
11806 }
11807
11808
11809 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11810 PyObject *resultobj = 0;
11811 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11812 int result;
11813 void *argp1 = 0 ;
11814 int res1 = 0 ;
11815 PyObject *swig_obj[1] ;
11816
11817 if (!args) SWIG_fail;
11818 swig_obj[0] = args;
11819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11820 if (!SWIG_IsOK(res1)) {
11821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11822 }
11823 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11824 {
11825 PyThreadState* __tstate = wxPyBeginAllowThreads();
11826 result = (int)(arg1)->tell();
11827 wxPyEndAllowThreads(__tstate);
11828 if (PyErr_Occurred()) SWIG_fail;
11829 }
11830 resultobj = SWIG_From_int(static_cast< int >(result));
11831 return resultobj;
11832 fail:
11833 return NULL;
11834 }
11835
11836
11837 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11838 PyObject *resultobj = 0;
11839 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11840 char result;
11841 void *argp1 = 0 ;
11842 int res1 = 0 ;
11843 PyObject *swig_obj[1] ;
11844
11845 if (!args) SWIG_fail;
11846 swig_obj[0] = args;
11847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11848 if (!SWIG_IsOK(res1)) {
11849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11850 }
11851 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11852 {
11853 PyThreadState* __tstate = wxPyBeginAllowThreads();
11854 result = (char)(arg1)->Peek();
11855 wxPyEndAllowThreads(__tstate);
11856 if (PyErr_Occurred()) SWIG_fail;
11857 }
11858 resultobj = SWIG_From_char(static_cast< char >(result));
11859 return resultobj;
11860 fail:
11861 return NULL;
11862 }
11863
11864
11865 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11866 PyObject *resultobj = 0;
11867 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11868 char result;
11869 void *argp1 = 0 ;
11870 int res1 = 0 ;
11871 PyObject *swig_obj[1] ;
11872
11873 if (!args) SWIG_fail;
11874 swig_obj[0] = args;
11875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11876 if (!SWIG_IsOK(res1)) {
11877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11878 }
11879 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11880 {
11881 PyThreadState* __tstate = wxPyBeginAllowThreads();
11882 result = (char)(arg1)->GetC();
11883 wxPyEndAllowThreads(__tstate);
11884 if (PyErr_Occurred()) SWIG_fail;
11885 }
11886 resultobj = SWIG_From_char(static_cast< char >(result));
11887 return resultobj;
11888 fail:
11889 return NULL;
11890 }
11891
11892
11893 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11894 PyObject *resultobj = 0;
11895 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11896 size_t result;
11897 void *argp1 = 0 ;
11898 int res1 = 0 ;
11899 PyObject *swig_obj[1] ;
11900
11901 if (!args) SWIG_fail;
11902 swig_obj[0] = args;
11903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11904 if (!SWIG_IsOK(res1)) {
11905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11906 }
11907 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11908 {
11909 PyThreadState* __tstate = wxPyBeginAllowThreads();
11910 result = (size_t)(arg1)->LastRead();
11911 wxPyEndAllowThreads(__tstate);
11912 if (PyErr_Occurred()) SWIG_fail;
11913 }
11914 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11915 return resultobj;
11916 fail:
11917 return NULL;
11918 }
11919
11920
11921 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11922 PyObject *resultobj = 0;
11923 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11924 bool result;
11925 void *argp1 = 0 ;
11926 int res1 = 0 ;
11927 PyObject *swig_obj[1] ;
11928
11929 if (!args) SWIG_fail;
11930 swig_obj[0] = args;
11931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11932 if (!SWIG_IsOK(res1)) {
11933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11934 }
11935 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11936 {
11937 PyThreadState* __tstate = wxPyBeginAllowThreads();
11938 result = (bool)(arg1)->CanRead();
11939 wxPyEndAllowThreads(__tstate);
11940 if (PyErr_Occurred()) SWIG_fail;
11941 }
11942 {
11943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11944 }
11945 return resultobj;
11946 fail:
11947 return NULL;
11948 }
11949
11950
11951 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11952 PyObject *resultobj = 0;
11953 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11954 bool result;
11955 void *argp1 = 0 ;
11956 int res1 = 0 ;
11957 PyObject *swig_obj[1] ;
11958
11959 if (!args) SWIG_fail;
11960 swig_obj[0] = args;
11961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11962 if (!SWIG_IsOK(res1)) {
11963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11964 }
11965 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11966 {
11967 PyThreadState* __tstate = wxPyBeginAllowThreads();
11968 result = (bool)(arg1)->Eof();
11969 wxPyEndAllowThreads(__tstate);
11970 if (PyErr_Occurred()) SWIG_fail;
11971 }
11972 {
11973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11974 }
11975 return resultobj;
11976 fail:
11977 return NULL;
11978 }
11979
11980
11981 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11982 PyObject *resultobj = 0;
11983 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11984 char arg2 ;
11985 bool result;
11986 void *argp1 = 0 ;
11987 int res1 = 0 ;
11988 char val2 ;
11989 int ecode2 = 0 ;
11990 PyObject * obj0 = 0 ;
11991 PyObject * obj1 = 0 ;
11992 char * kwnames[] = {
11993 (char *) "self",(char *) "c", NULL
11994 };
11995
11996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11998 if (!SWIG_IsOK(res1)) {
11999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12000 }
12001 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12002 ecode2 = SWIG_AsVal_char(obj1, &val2);
12003 if (!SWIG_IsOK(ecode2)) {
12004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
12005 }
12006 arg2 = static_cast< char >(val2);
12007 {
12008 PyThreadState* __tstate = wxPyBeginAllowThreads();
12009 result = (bool)(arg1)->Ungetch(arg2);
12010 wxPyEndAllowThreads(__tstate);
12011 if (PyErr_Occurred()) SWIG_fail;
12012 }
12013 {
12014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12015 }
12016 return resultobj;
12017 fail:
12018 return NULL;
12019 }
12020
12021
12022 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12023 PyObject *resultobj = 0;
12024 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12025 long arg2 ;
12026 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
12027 long result;
12028 void *argp1 = 0 ;
12029 int res1 = 0 ;
12030 long val2 ;
12031 int ecode2 = 0 ;
12032 int val3 ;
12033 int ecode3 = 0 ;
12034 PyObject * obj0 = 0 ;
12035 PyObject * obj1 = 0 ;
12036 PyObject * obj2 = 0 ;
12037 char * kwnames[] = {
12038 (char *) "self",(char *) "pos",(char *) "mode", NULL
12039 };
12040
12041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12043 if (!SWIG_IsOK(res1)) {
12044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12045 }
12046 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12047 ecode2 = SWIG_AsVal_long(obj1, &val2);
12048 if (!SWIG_IsOK(ecode2)) {
12049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
12050 }
12051 arg2 = static_cast< long >(val2);
12052 if (obj2) {
12053 ecode3 = SWIG_AsVal_int(obj2, &val3);
12054 if (!SWIG_IsOK(ecode3)) {
12055 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
12056 }
12057 arg3 = static_cast< wxSeekMode >(val3);
12058 }
12059 {
12060 PyThreadState* __tstate = wxPyBeginAllowThreads();
12061 result = (long)(arg1)->SeekI(arg2,arg3);
12062 wxPyEndAllowThreads(__tstate);
12063 if (PyErr_Occurred()) SWIG_fail;
12064 }
12065 resultobj = SWIG_From_long(static_cast< long >(result));
12066 return resultobj;
12067 fail:
12068 return NULL;
12069 }
12070
12071
12072 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12073 PyObject *resultobj = 0;
12074 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12075 long result;
12076 void *argp1 = 0 ;
12077 int res1 = 0 ;
12078 PyObject *swig_obj[1] ;
12079
12080 if (!args) SWIG_fail;
12081 swig_obj[0] = args;
12082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12083 if (!SWIG_IsOK(res1)) {
12084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12085 }
12086 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12087 {
12088 PyThreadState* __tstate = wxPyBeginAllowThreads();
12089 result = (long)(arg1)->TellI();
12090 wxPyEndAllowThreads(__tstate);
12091 if (PyErr_Occurred()) SWIG_fail;
12092 }
12093 resultobj = SWIG_From_long(static_cast< long >(result));
12094 return resultobj;
12095 fail:
12096 return NULL;
12097 }
12098
12099
12100 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12101 PyObject *obj;
12102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12103 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12104 return SWIG_Py_Void();
12105 }
12106
12107 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12108 return SWIG_Python_InitShadowInstance(args);
12109 }
12110
12111 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12112 PyObject *resultobj = 0;
12113 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12114 PyObject *arg2 = (PyObject *) 0 ;
12115 void *argp1 = 0 ;
12116 int res1 = 0 ;
12117 PyObject * obj0 = 0 ;
12118 PyObject * obj1 = 0 ;
12119 char * kwnames[] = {
12120 (char *) "self",(char *) "obj", NULL
12121 };
12122
12123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12125 if (!SWIG_IsOK(res1)) {
12126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12127 }
12128 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12129 arg2 = obj1;
12130 {
12131 PyThreadState* __tstate = wxPyBeginAllowThreads();
12132 wxOutputStream_write(arg1,arg2);
12133 wxPyEndAllowThreads(__tstate);
12134 if (PyErr_Occurred()) SWIG_fail;
12135 }
12136 resultobj = SWIG_Py_Void();
12137 return resultobj;
12138 fail:
12139 return NULL;
12140 }
12141
12142
12143 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12144 PyObject *resultobj = 0;
12145 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12146 size_t result;
12147 void *argp1 = 0 ;
12148 int res1 = 0 ;
12149 PyObject *swig_obj[1] ;
12150
12151 if (!args) SWIG_fail;
12152 swig_obj[0] = args;
12153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12154 if (!SWIG_IsOK(res1)) {
12155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12156 }
12157 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12158 {
12159 PyThreadState* __tstate = wxPyBeginAllowThreads();
12160 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12161 wxPyEndAllowThreads(__tstate);
12162 if (PyErr_Occurred()) SWIG_fail;
12163 }
12164 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12165 return resultobj;
12166 fail:
12167 return NULL;
12168 }
12169
12170
12171 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12172 PyObject *obj;
12173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12174 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12175 return SWIG_Py_Void();
12176 }
12177
12178 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12179 PyObject *resultobj = 0;
12180 wxInputStream *arg1 = (wxInputStream *) 0 ;
12181 wxString *arg2 = 0 ;
12182 wxString *arg3 = 0 ;
12183 wxString *arg4 = 0 ;
12184 wxDateTime arg5 ;
12185 wxFSFile *result = 0 ;
12186 wxPyInputStream *temp1 ;
12187 bool temp2 = false ;
12188 bool temp3 = false ;
12189 bool temp4 = false ;
12190 void *argp5 ;
12191 int res5 = 0 ;
12192 PyObject * obj0 = 0 ;
12193 PyObject * obj1 = 0 ;
12194 PyObject * obj2 = 0 ;
12195 PyObject * obj3 = 0 ;
12196 PyObject * obj4 = 0 ;
12197 char * kwnames[] = {
12198 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12199 };
12200
12201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12202 {
12203 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12204 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12205 } else {
12206 PyErr_Clear(); // clear the failure of the wxPyConvert above
12207 arg1 = wxPyCBInputStream_create(obj0, true);
12208 if (arg1 == NULL) {
12209 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12210 SWIG_fail;
12211 }
12212 }
12213 }
12214 {
12215 arg2 = wxString_in_helper(obj1);
12216 if (arg2 == NULL) SWIG_fail;
12217 temp2 = true;
12218 }
12219 {
12220 arg3 = wxString_in_helper(obj2);
12221 if (arg3 == NULL) SWIG_fail;
12222 temp3 = true;
12223 }
12224 {
12225 arg4 = wxString_in_helper(obj3);
12226 if (arg4 == NULL) SWIG_fail;
12227 temp4 = true;
12228 }
12229 {
12230 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12231 if (!SWIG_IsOK(res5)) {
12232 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12233 }
12234 if (!argp5) {
12235 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12236 } else {
12237 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12238 arg5 = *temp;
12239 if (SWIG_IsNewObj(res5)) delete temp;
12240 }
12241 }
12242 {
12243 PyThreadState* __tstate = wxPyBeginAllowThreads();
12244 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12245 wxPyEndAllowThreads(__tstate);
12246 if (PyErr_Occurred()) SWIG_fail;
12247 }
12248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12249 {
12250 if (temp2)
12251 delete arg2;
12252 }
12253 {
12254 if (temp3)
12255 delete arg3;
12256 }
12257 {
12258 if (temp4)
12259 delete arg4;
12260 }
12261 return resultobj;
12262 fail:
12263 {
12264 if (temp2)
12265 delete arg2;
12266 }
12267 {
12268 if (temp3)
12269 delete arg3;
12270 }
12271 {
12272 if (temp4)
12273 delete arg4;
12274 }
12275 return NULL;
12276 }
12277
12278
12279 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12280 PyObject *resultobj = 0;
12281 wxFSFile *arg1 = (wxFSFile *) 0 ;
12282 void *argp1 = 0 ;
12283 int res1 = 0 ;
12284 PyObject *swig_obj[1] ;
12285
12286 if (!args) SWIG_fail;
12287 swig_obj[0] = args;
12288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12289 if (!SWIG_IsOK(res1)) {
12290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12291 }
12292 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12293 {
12294 PyThreadState* __tstate = wxPyBeginAllowThreads();
12295 delete arg1;
12296
12297 wxPyEndAllowThreads(__tstate);
12298 if (PyErr_Occurred()) SWIG_fail;
12299 }
12300 resultobj = SWIG_Py_Void();
12301 return resultobj;
12302 fail:
12303 return NULL;
12304 }
12305
12306
12307 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12308 PyObject *resultobj = 0;
12309 wxFSFile *arg1 = (wxFSFile *) 0 ;
12310 wxInputStream *result = 0 ;
12311 void *argp1 = 0 ;
12312 int res1 = 0 ;
12313 PyObject *swig_obj[1] ;
12314
12315 if (!args) SWIG_fail;
12316 swig_obj[0] = args;
12317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12318 if (!SWIG_IsOK(res1)) {
12319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12320 }
12321 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12322 {
12323 PyThreadState* __tstate = wxPyBeginAllowThreads();
12324 result = (wxInputStream *)(arg1)->GetStream();
12325 wxPyEndAllowThreads(__tstate);
12326 if (PyErr_Occurred()) SWIG_fail;
12327 }
12328 {
12329 wxPyInputStream * _ptr = NULL;
12330
12331 if (result) {
12332 _ptr = new wxPyInputStream(result);
12333 }
12334 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12335 }
12336 return resultobj;
12337 fail:
12338 return NULL;
12339 }
12340
12341
12342 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12343 PyObject *resultobj = 0;
12344 wxFSFile *arg1 = (wxFSFile *) 0 ;
12345 void *argp1 = 0 ;
12346 int res1 = 0 ;
12347 PyObject *swig_obj[1] ;
12348
12349 if (!args) SWIG_fail;
12350 swig_obj[0] = args;
12351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12352 if (!SWIG_IsOK(res1)) {
12353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12354 }
12355 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12356 {
12357 PyThreadState* __tstate = wxPyBeginAllowThreads();
12358 (arg1)->DetachStream();
12359 wxPyEndAllowThreads(__tstate);
12360 if (PyErr_Occurred()) SWIG_fail;
12361 }
12362 resultobj = SWIG_Py_Void();
12363 return resultobj;
12364 fail:
12365 return NULL;
12366 }
12367
12368
12369 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12370 PyObject *resultobj = 0;
12371 wxFSFile *arg1 = (wxFSFile *) 0 ;
12372 wxString *result = 0 ;
12373 void *argp1 = 0 ;
12374 int res1 = 0 ;
12375 PyObject *swig_obj[1] ;
12376
12377 if (!args) SWIG_fail;
12378 swig_obj[0] = args;
12379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12380 if (!SWIG_IsOK(res1)) {
12381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12382 }
12383 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12384 {
12385 PyThreadState* __tstate = wxPyBeginAllowThreads();
12386 {
12387 wxString const &_result_ref = (arg1)->GetMimeType();
12388 result = (wxString *) &_result_ref;
12389 }
12390 wxPyEndAllowThreads(__tstate);
12391 if (PyErr_Occurred()) SWIG_fail;
12392 }
12393 {
12394 #if wxUSE_UNICODE
12395 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12396 #else
12397 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12398 #endif
12399 }
12400 return resultobj;
12401 fail:
12402 return NULL;
12403 }
12404
12405
12406 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12407 PyObject *resultobj = 0;
12408 wxFSFile *arg1 = (wxFSFile *) 0 ;
12409 wxString *result = 0 ;
12410 void *argp1 = 0 ;
12411 int res1 = 0 ;
12412 PyObject *swig_obj[1] ;
12413
12414 if (!args) SWIG_fail;
12415 swig_obj[0] = args;
12416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12417 if (!SWIG_IsOK(res1)) {
12418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12419 }
12420 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12421 {
12422 PyThreadState* __tstate = wxPyBeginAllowThreads();
12423 {
12424 wxString const &_result_ref = (arg1)->GetLocation();
12425 result = (wxString *) &_result_ref;
12426 }
12427 wxPyEndAllowThreads(__tstate);
12428 if (PyErr_Occurred()) SWIG_fail;
12429 }
12430 {
12431 #if wxUSE_UNICODE
12432 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12433 #else
12434 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12435 #endif
12436 }
12437 return resultobj;
12438 fail:
12439 return NULL;
12440 }
12441
12442
12443 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12444 PyObject *resultobj = 0;
12445 wxFSFile *arg1 = (wxFSFile *) 0 ;
12446 wxString *result = 0 ;
12447 void *argp1 = 0 ;
12448 int res1 = 0 ;
12449 PyObject *swig_obj[1] ;
12450
12451 if (!args) SWIG_fail;
12452 swig_obj[0] = args;
12453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12454 if (!SWIG_IsOK(res1)) {
12455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12456 }
12457 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12458 {
12459 PyThreadState* __tstate = wxPyBeginAllowThreads();
12460 {
12461 wxString const &_result_ref = (arg1)->GetAnchor();
12462 result = (wxString *) &_result_ref;
12463 }
12464 wxPyEndAllowThreads(__tstate);
12465 if (PyErr_Occurred()) SWIG_fail;
12466 }
12467 {
12468 #if wxUSE_UNICODE
12469 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12470 #else
12471 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12472 #endif
12473 }
12474 return resultobj;
12475 fail:
12476 return NULL;
12477 }
12478
12479
12480 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12481 PyObject *resultobj = 0;
12482 wxFSFile *arg1 = (wxFSFile *) 0 ;
12483 wxDateTime result;
12484 void *argp1 = 0 ;
12485 int res1 = 0 ;
12486 PyObject *swig_obj[1] ;
12487
12488 if (!args) SWIG_fail;
12489 swig_obj[0] = args;
12490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12491 if (!SWIG_IsOK(res1)) {
12492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12493 }
12494 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12495 {
12496 PyThreadState* __tstate = wxPyBeginAllowThreads();
12497 result = (arg1)->GetModificationTime();
12498 wxPyEndAllowThreads(__tstate);
12499 if (PyErr_Occurred()) SWIG_fail;
12500 }
12501 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12502 return resultobj;
12503 fail:
12504 return NULL;
12505 }
12506
12507
12508 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12509 PyObject *obj;
12510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12511 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12512 return SWIG_Py_Void();
12513 }
12514
12515 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12516 return SWIG_Python_InitShadowInstance(args);
12517 }
12518
12519 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12520 PyObject *resultobj = 0;
12521 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12522 void *argp1 = 0 ;
12523 int res1 = 0 ;
12524 PyObject *swig_obj[1] ;
12525
12526 if (!args) SWIG_fail;
12527 swig_obj[0] = args;
12528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12529 if (!SWIG_IsOK(res1)) {
12530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12531 }
12532 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12533 {
12534 PyThreadState* __tstate = wxPyBeginAllowThreads();
12535 delete arg1;
12536
12537 wxPyEndAllowThreads(__tstate);
12538 if (PyErr_Occurred()) SWIG_fail;
12539 }
12540 resultobj = SWIG_Py_Void();
12541 return resultobj;
12542 fail:
12543 return NULL;
12544 }
12545
12546
12547 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12548 PyObject *obj;
12549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12550 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12551 return SWIG_Py_Void();
12552 }
12553
12554 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12555 PyObject *resultobj = 0;
12556 wxPyFileSystemHandler *result = 0 ;
12557
12558 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12559 {
12560 PyThreadState* __tstate = wxPyBeginAllowThreads();
12561 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12562 wxPyEndAllowThreads(__tstate);
12563 if (PyErr_Occurred()) SWIG_fail;
12564 }
12565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12566 return resultobj;
12567 fail:
12568 return NULL;
12569 }
12570
12571
12572 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12573 PyObject *resultobj = 0;
12574 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12575 PyObject *arg2 = (PyObject *) 0 ;
12576 PyObject *arg3 = (PyObject *) 0 ;
12577 void *argp1 = 0 ;
12578 int res1 = 0 ;
12579 PyObject * obj0 = 0 ;
12580 PyObject * obj1 = 0 ;
12581 PyObject * obj2 = 0 ;
12582 char * kwnames[] = {
12583 (char *) "self",(char *) "self",(char *) "_class", NULL
12584 };
12585
12586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12588 if (!SWIG_IsOK(res1)) {
12589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12590 }
12591 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12592 arg2 = obj1;
12593 arg3 = obj2;
12594 {
12595 PyThreadState* __tstate = wxPyBeginAllowThreads();
12596 (arg1)->_setCallbackInfo(arg2,arg3);
12597 wxPyEndAllowThreads(__tstate);
12598 if (PyErr_Occurred()) SWIG_fail;
12599 }
12600 resultobj = SWIG_Py_Void();
12601 return resultobj;
12602 fail:
12603 return NULL;
12604 }
12605
12606
12607 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12608 PyObject *resultobj = 0;
12609 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12610 wxString *arg2 = 0 ;
12611 bool result;
12612 void *argp1 = 0 ;
12613 int res1 = 0 ;
12614 bool temp2 = false ;
12615 PyObject * obj0 = 0 ;
12616 PyObject * obj1 = 0 ;
12617 char * kwnames[] = {
12618 (char *) "self",(char *) "location", NULL
12619 };
12620
12621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12623 if (!SWIG_IsOK(res1)) {
12624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12625 }
12626 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12627 {
12628 arg2 = wxString_in_helper(obj1);
12629 if (arg2 == NULL) SWIG_fail;
12630 temp2 = true;
12631 }
12632 {
12633 PyThreadState* __tstate = wxPyBeginAllowThreads();
12634 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12635 wxPyEndAllowThreads(__tstate);
12636 if (PyErr_Occurred()) SWIG_fail;
12637 }
12638 {
12639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12640 }
12641 {
12642 if (temp2)
12643 delete arg2;
12644 }
12645 return resultobj;
12646 fail:
12647 {
12648 if (temp2)
12649 delete arg2;
12650 }
12651 return NULL;
12652 }
12653
12654
12655 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12656 PyObject *resultobj = 0;
12657 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12658 wxFileSystem *arg2 = 0 ;
12659 wxString *arg3 = 0 ;
12660 wxFSFile *result = 0 ;
12661 void *argp1 = 0 ;
12662 int res1 = 0 ;
12663 void *argp2 = 0 ;
12664 int res2 = 0 ;
12665 bool temp3 = false ;
12666 PyObject * obj0 = 0 ;
12667 PyObject * obj1 = 0 ;
12668 PyObject * obj2 = 0 ;
12669 char * kwnames[] = {
12670 (char *) "self",(char *) "fs",(char *) "location", NULL
12671 };
12672
12673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12675 if (!SWIG_IsOK(res1)) {
12676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12677 }
12678 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12679 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12680 if (!SWIG_IsOK(res2)) {
12681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12682 }
12683 if (!argp2) {
12684 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12685 }
12686 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12687 {
12688 arg3 = wxString_in_helper(obj2);
12689 if (arg3 == NULL) SWIG_fail;
12690 temp3 = true;
12691 }
12692 {
12693 PyThreadState* __tstate = wxPyBeginAllowThreads();
12694 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12695 wxPyEndAllowThreads(__tstate);
12696 if (PyErr_Occurred()) SWIG_fail;
12697 }
12698 {
12699 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12700 }
12701 {
12702 if (temp3)
12703 delete arg3;
12704 }
12705 return resultobj;
12706 fail:
12707 {
12708 if (temp3)
12709 delete arg3;
12710 }
12711 return NULL;
12712 }
12713
12714
12715 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12716 PyObject *resultobj = 0;
12717 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12718 wxString *arg2 = 0 ;
12719 int arg3 = (int) 0 ;
12720 wxString result;
12721 void *argp1 = 0 ;
12722 int res1 = 0 ;
12723 bool temp2 = false ;
12724 int val3 ;
12725 int ecode3 = 0 ;
12726 PyObject * obj0 = 0 ;
12727 PyObject * obj1 = 0 ;
12728 PyObject * obj2 = 0 ;
12729 char * kwnames[] = {
12730 (char *) "self",(char *) "spec",(char *) "flags", NULL
12731 };
12732
12733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12735 if (!SWIG_IsOK(res1)) {
12736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12737 }
12738 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12739 {
12740 arg2 = wxString_in_helper(obj1);
12741 if (arg2 == NULL) SWIG_fail;
12742 temp2 = true;
12743 }
12744 if (obj2) {
12745 ecode3 = SWIG_AsVal_int(obj2, &val3);
12746 if (!SWIG_IsOK(ecode3)) {
12747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12748 }
12749 arg3 = static_cast< int >(val3);
12750 }
12751 {
12752 PyThreadState* __tstate = wxPyBeginAllowThreads();
12753 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12754 wxPyEndAllowThreads(__tstate);
12755 if (PyErr_Occurred()) SWIG_fail;
12756 }
12757 {
12758 #if wxUSE_UNICODE
12759 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12760 #else
12761 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12762 #endif
12763 }
12764 {
12765 if (temp2)
12766 delete arg2;
12767 }
12768 return resultobj;
12769 fail:
12770 {
12771 if (temp2)
12772 delete arg2;
12773 }
12774 return NULL;
12775 }
12776
12777
12778 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12779 PyObject *resultobj = 0;
12780 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12781 wxString result;
12782 void *argp1 = 0 ;
12783 int res1 = 0 ;
12784 PyObject *swig_obj[1] ;
12785
12786 if (!args) SWIG_fail;
12787 swig_obj[0] = args;
12788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12789 if (!SWIG_IsOK(res1)) {
12790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12791 }
12792 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12793 {
12794 PyThreadState* __tstate = wxPyBeginAllowThreads();
12795 result = (arg1)->FindNext();
12796 wxPyEndAllowThreads(__tstate);
12797 if (PyErr_Occurred()) SWIG_fail;
12798 }
12799 {
12800 #if wxUSE_UNICODE
12801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12802 #else
12803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12804 #endif
12805 }
12806 return resultobj;
12807 fail:
12808 return NULL;
12809 }
12810
12811
12812 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12813 PyObject *resultobj = 0;
12814 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12815 wxString *arg2 = 0 ;
12816 wxString result;
12817 void *argp1 = 0 ;
12818 int res1 = 0 ;
12819 bool temp2 = false ;
12820 PyObject * obj0 = 0 ;
12821 PyObject * obj1 = 0 ;
12822 char * kwnames[] = {
12823 (char *) "self",(char *) "location", NULL
12824 };
12825
12826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12828 if (!SWIG_IsOK(res1)) {
12829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12830 }
12831 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12832 {
12833 arg2 = wxString_in_helper(obj1);
12834 if (arg2 == NULL) SWIG_fail;
12835 temp2 = true;
12836 }
12837 {
12838 PyThreadState* __tstate = wxPyBeginAllowThreads();
12839 result = (arg1)->GetProtocol((wxString const &)*arg2);
12840 wxPyEndAllowThreads(__tstate);
12841 if (PyErr_Occurred()) SWIG_fail;
12842 }
12843 {
12844 #if wxUSE_UNICODE
12845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12846 #else
12847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12848 #endif
12849 }
12850 {
12851 if (temp2)
12852 delete arg2;
12853 }
12854 return resultobj;
12855 fail:
12856 {
12857 if (temp2)
12858 delete arg2;
12859 }
12860 return NULL;
12861 }
12862
12863
12864 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12865 PyObject *resultobj = 0;
12866 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12867 wxString *arg2 = 0 ;
12868 wxString result;
12869 void *argp1 = 0 ;
12870 int res1 = 0 ;
12871 bool temp2 = false ;
12872 PyObject * obj0 = 0 ;
12873 PyObject * obj1 = 0 ;
12874 char * kwnames[] = {
12875 (char *) "self",(char *) "location", NULL
12876 };
12877
12878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12880 if (!SWIG_IsOK(res1)) {
12881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12882 }
12883 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12884 {
12885 arg2 = wxString_in_helper(obj1);
12886 if (arg2 == NULL) SWIG_fail;
12887 temp2 = true;
12888 }
12889 {
12890 PyThreadState* __tstate = wxPyBeginAllowThreads();
12891 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12892 wxPyEndAllowThreads(__tstate);
12893 if (PyErr_Occurred()) SWIG_fail;
12894 }
12895 {
12896 #if wxUSE_UNICODE
12897 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12898 #else
12899 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12900 #endif
12901 }
12902 {
12903 if (temp2)
12904 delete arg2;
12905 }
12906 return resultobj;
12907 fail:
12908 {
12909 if (temp2)
12910 delete arg2;
12911 }
12912 return NULL;
12913 }
12914
12915
12916 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12917 PyObject *resultobj = 0;
12918 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12919 wxString *arg2 = 0 ;
12920 wxString result;
12921 void *argp1 = 0 ;
12922 int res1 = 0 ;
12923 bool temp2 = false ;
12924 PyObject * obj0 = 0 ;
12925 PyObject * obj1 = 0 ;
12926 char * kwnames[] = {
12927 (char *) "self",(char *) "location", NULL
12928 };
12929
12930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12932 if (!SWIG_IsOK(res1)) {
12933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12934 }
12935 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12936 {
12937 arg2 = wxString_in_helper(obj1);
12938 if (arg2 == NULL) SWIG_fail;
12939 temp2 = true;
12940 }
12941 {
12942 PyThreadState* __tstate = wxPyBeginAllowThreads();
12943 result = (arg1)->GetAnchor((wxString const &)*arg2);
12944 wxPyEndAllowThreads(__tstate);
12945 if (PyErr_Occurred()) SWIG_fail;
12946 }
12947 {
12948 #if wxUSE_UNICODE
12949 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12950 #else
12951 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12952 #endif
12953 }
12954 {
12955 if (temp2)
12956 delete arg2;
12957 }
12958 return resultobj;
12959 fail:
12960 {
12961 if (temp2)
12962 delete arg2;
12963 }
12964 return NULL;
12965 }
12966
12967
12968 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12969 PyObject *resultobj = 0;
12970 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12971 wxString *arg2 = 0 ;
12972 wxString result;
12973 void *argp1 = 0 ;
12974 int res1 = 0 ;
12975 bool temp2 = false ;
12976 PyObject * obj0 = 0 ;
12977 PyObject * obj1 = 0 ;
12978 char * kwnames[] = {
12979 (char *) "self",(char *) "location", NULL
12980 };
12981
12982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12984 if (!SWIG_IsOK(res1)) {
12985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12986 }
12987 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12988 {
12989 arg2 = wxString_in_helper(obj1);
12990 if (arg2 == NULL) SWIG_fail;
12991 temp2 = true;
12992 }
12993 {
12994 PyThreadState* __tstate = wxPyBeginAllowThreads();
12995 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12996 wxPyEndAllowThreads(__tstate);
12997 if (PyErr_Occurred()) SWIG_fail;
12998 }
12999 {
13000 #if wxUSE_UNICODE
13001 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13002 #else
13003 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13004 #endif
13005 }
13006 {
13007 if (temp2)
13008 delete arg2;
13009 }
13010 return resultobj;
13011 fail:
13012 {
13013 if (temp2)
13014 delete arg2;
13015 }
13016 return NULL;
13017 }
13018
13019
13020 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13021 PyObject *resultobj = 0;
13022 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13023 wxString *arg2 = 0 ;
13024 wxString result;
13025 void *argp1 = 0 ;
13026 int res1 = 0 ;
13027 bool temp2 = false ;
13028 PyObject * obj0 = 0 ;
13029 PyObject * obj1 = 0 ;
13030 char * kwnames[] = {
13031 (char *) "self",(char *) "location", NULL
13032 };
13033
13034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
13035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13036 if (!SWIG_IsOK(res1)) {
13037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13038 }
13039 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13040 {
13041 arg2 = wxString_in_helper(obj1);
13042 if (arg2 == NULL) SWIG_fail;
13043 temp2 = true;
13044 }
13045 {
13046 PyThreadState* __tstate = wxPyBeginAllowThreads();
13047 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
13048 wxPyEndAllowThreads(__tstate);
13049 if (PyErr_Occurred()) SWIG_fail;
13050 }
13051 {
13052 #if wxUSE_UNICODE
13053 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13054 #else
13055 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13056 #endif
13057 }
13058 {
13059 if (temp2)
13060 delete arg2;
13061 }
13062 return resultobj;
13063 fail:
13064 {
13065 if (temp2)
13066 delete arg2;
13067 }
13068 return NULL;
13069 }
13070
13071
13072 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13073 PyObject *obj;
13074 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13075 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13076 return SWIG_Py_Void();
13077 }
13078
13079 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13080 return SWIG_Python_InitShadowInstance(args);
13081 }
13082
13083 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13084 PyObject *resultobj = 0;
13085 wxFileSystem *result = 0 ;
13086
13087 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13088 {
13089 PyThreadState* __tstate = wxPyBeginAllowThreads();
13090 result = (wxFileSystem *)new wxFileSystem();
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13095 return resultobj;
13096 fail:
13097 return NULL;
13098 }
13099
13100
13101 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13102 PyObject *resultobj = 0;
13103 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13104 void *argp1 = 0 ;
13105 int res1 = 0 ;
13106 PyObject *swig_obj[1] ;
13107
13108 if (!args) SWIG_fail;
13109 swig_obj[0] = args;
13110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13111 if (!SWIG_IsOK(res1)) {
13112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13113 }
13114 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13115 {
13116 PyThreadState* __tstate = wxPyBeginAllowThreads();
13117 delete arg1;
13118
13119 wxPyEndAllowThreads(__tstate);
13120 if (PyErr_Occurred()) SWIG_fail;
13121 }
13122 resultobj = SWIG_Py_Void();
13123 return resultobj;
13124 fail:
13125 return NULL;
13126 }
13127
13128
13129 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13130 PyObject *resultobj = 0;
13131 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13132 wxString *arg2 = 0 ;
13133 bool arg3 = (bool) false ;
13134 void *argp1 = 0 ;
13135 int res1 = 0 ;
13136 bool temp2 = false ;
13137 bool val3 ;
13138 int ecode3 = 0 ;
13139 PyObject * obj0 = 0 ;
13140 PyObject * obj1 = 0 ;
13141 PyObject * obj2 = 0 ;
13142 char * kwnames[] = {
13143 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13144 };
13145
13146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13148 if (!SWIG_IsOK(res1)) {
13149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13150 }
13151 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13152 {
13153 arg2 = wxString_in_helper(obj1);
13154 if (arg2 == NULL) SWIG_fail;
13155 temp2 = true;
13156 }
13157 if (obj2) {
13158 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13159 if (!SWIG_IsOK(ecode3)) {
13160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13161 }
13162 arg3 = static_cast< bool >(val3);
13163 }
13164 {
13165 PyThreadState* __tstate = wxPyBeginAllowThreads();
13166 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13167 wxPyEndAllowThreads(__tstate);
13168 if (PyErr_Occurred()) SWIG_fail;
13169 }
13170 resultobj = SWIG_Py_Void();
13171 {
13172 if (temp2)
13173 delete arg2;
13174 }
13175 return resultobj;
13176 fail:
13177 {
13178 if (temp2)
13179 delete arg2;
13180 }
13181 return NULL;
13182 }
13183
13184
13185 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13186 PyObject *resultobj = 0;
13187 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13188 wxString result;
13189 void *argp1 = 0 ;
13190 int res1 = 0 ;
13191 PyObject *swig_obj[1] ;
13192
13193 if (!args) SWIG_fail;
13194 swig_obj[0] = args;
13195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13196 if (!SWIG_IsOK(res1)) {
13197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13198 }
13199 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13200 {
13201 PyThreadState* __tstate = wxPyBeginAllowThreads();
13202 result = (arg1)->GetPath();
13203 wxPyEndAllowThreads(__tstate);
13204 if (PyErr_Occurred()) SWIG_fail;
13205 }
13206 {
13207 #if wxUSE_UNICODE
13208 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13209 #else
13210 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13211 #endif
13212 }
13213 return resultobj;
13214 fail:
13215 return NULL;
13216 }
13217
13218
13219 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13220 PyObject *resultobj = 0;
13221 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13222 wxString *arg2 = 0 ;
13223 wxFSFile *result = 0 ;
13224 void *argp1 = 0 ;
13225 int res1 = 0 ;
13226 bool temp2 = false ;
13227 PyObject * obj0 = 0 ;
13228 PyObject * obj1 = 0 ;
13229 char * kwnames[] = {
13230 (char *) "self",(char *) "location", NULL
13231 };
13232
13233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13235 if (!SWIG_IsOK(res1)) {
13236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13237 }
13238 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13239 {
13240 arg2 = wxString_in_helper(obj1);
13241 if (arg2 == NULL) SWIG_fail;
13242 temp2 = true;
13243 }
13244 {
13245 PyThreadState* __tstate = wxPyBeginAllowThreads();
13246 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13247 wxPyEndAllowThreads(__tstate);
13248 if (PyErr_Occurred()) SWIG_fail;
13249 }
13250 {
13251 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13252 }
13253 {
13254 if (temp2)
13255 delete arg2;
13256 }
13257 return resultobj;
13258 fail:
13259 {
13260 if (temp2)
13261 delete arg2;
13262 }
13263 return NULL;
13264 }
13265
13266
13267 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13268 PyObject *resultobj = 0;
13269 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13270 wxString *arg2 = 0 ;
13271 int arg3 = (int) 0 ;
13272 wxString result;
13273 void *argp1 = 0 ;
13274 int res1 = 0 ;
13275 bool temp2 = false ;
13276 int val3 ;
13277 int ecode3 = 0 ;
13278 PyObject * obj0 = 0 ;
13279 PyObject * obj1 = 0 ;
13280 PyObject * obj2 = 0 ;
13281 char * kwnames[] = {
13282 (char *) "self",(char *) "spec",(char *) "flags", NULL
13283 };
13284
13285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13287 if (!SWIG_IsOK(res1)) {
13288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13289 }
13290 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13291 {
13292 arg2 = wxString_in_helper(obj1);
13293 if (arg2 == NULL) SWIG_fail;
13294 temp2 = true;
13295 }
13296 if (obj2) {
13297 ecode3 = SWIG_AsVal_int(obj2, &val3);
13298 if (!SWIG_IsOK(ecode3)) {
13299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13300 }
13301 arg3 = static_cast< int >(val3);
13302 }
13303 {
13304 PyThreadState* __tstate = wxPyBeginAllowThreads();
13305 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13306 wxPyEndAllowThreads(__tstate);
13307 if (PyErr_Occurred()) SWIG_fail;
13308 }
13309 {
13310 #if wxUSE_UNICODE
13311 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13312 #else
13313 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13314 #endif
13315 }
13316 {
13317 if (temp2)
13318 delete arg2;
13319 }
13320 return resultobj;
13321 fail:
13322 {
13323 if (temp2)
13324 delete arg2;
13325 }
13326 return NULL;
13327 }
13328
13329
13330 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13331 PyObject *resultobj = 0;
13332 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13333 wxString result;
13334 void *argp1 = 0 ;
13335 int res1 = 0 ;
13336 PyObject *swig_obj[1] ;
13337
13338 if (!args) SWIG_fail;
13339 swig_obj[0] = args;
13340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13341 if (!SWIG_IsOK(res1)) {
13342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13343 }
13344 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13345 {
13346 PyThreadState* __tstate = wxPyBeginAllowThreads();
13347 result = (arg1)->FindNext();
13348 wxPyEndAllowThreads(__tstate);
13349 if (PyErr_Occurred()) SWIG_fail;
13350 }
13351 {
13352 #if wxUSE_UNICODE
13353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13354 #else
13355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13356 #endif
13357 }
13358 return resultobj;
13359 fail:
13360 return NULL;
13361 }
13362
13363
13364 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13365 PyObject *resultobj = 0;
13366 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13367 int res1 = 0 ;
13368 PyObject * obj0 = 0 ;
13369 char * kwnames[] = {
13370 (char *) "handler", NULL
13371 };
13372
13373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13374 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13375 if (!SWIG_IsOK(res1)) {
13376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13377 }
13378 {
13379 PyThreadState* __tstate = wxPyBeginAllowThreads();
13380 wxFileSystem::AddHandler(arg1);
13381 wxPyEndAllowThreads(__tstate);
13382 if (PyErr_Occurred()) SWIG_fail;
13383 }
13384 resultobj = SWIG_Py_Void();
13385 return resultobj;
13386 fail:
13387 return NULL;
13388 }
13389
13390
13391 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13392 PyObject *resultobj = 0;
13393 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13394 wxFileSystemHandler *result = 0 ;
13395 void *argp1 = 0 ;
13396 int res1 = 0 ;
13397 PyObject * obj0 = 0 ;
13398 char * kwnames[] = {
13399 (char *) "handler", NULL
13400 };
13401
13402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13404 if (!SWIG_IsOK(res1)) {
13405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13406 }
13407 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13408 {
13409 PyThreadState* __tstate = wxPyBeginAllowThreads();
13410 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13411 wxPyEndAllowThreads(__tstate);
13412 if (PyErr_Occurred()) SWIG_fail;
13413 }
13414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13415 return resultobj;
13416 fail:
13417 return NULL;
13418 }
13419
13420
13421 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13422 PyObject *resultobj = 0;
13423
13424 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13425 {
13426 PyThreadState* __tstate = wxPyBeginAllowThreads();
13427 wxFileSystem::CleanUpHandlers();
13428 wxPyEndAllowThreads(__tstate);
13429 if (PyErr_Occurred()) SWIG_fail;
13430 }
13431 resultobj = SWIG_Py_Void();
13432 return resultobj;
13433 fail:
13434 return NULL;
13435 }
13436
13437
13438 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13439 PyObject *resultobj = 0;
13440 wxString *arg1 = 0 ;
13441 wxString result;
13442 bool temp1 = false ;
13443 PyObject * obj0 = 0 ;
13444 char * kwnames[] = {
13445 (char *) "filename", NULL
13446 };
13447
13448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13449 {
13450 arg1 = wxString_in_helper(obj0);
13451 if (arg1 == NULL) SWIG_fail;
13452 temp1 = true;
13453 }
13454 {
13455 PyThreadState* __tstate = wxPyBeginAllowThreads();
13456 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13457 wxPyEndAllowThreads(__tstate);
13458 if (PyErr_Occurred()) SWIG_fail;
13459 }
13460 {
13461 #if wxUSE_UNICODE
13462 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13463 #else
13464 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13465 #endif
13466 }
13467 {
13468 if (temp1)
13469 delete arg1;
13470 }
13471 return resultobj;
13472 fail:
13473 {
13474 if (temp1)
13475 delete arg1;
13476 }
13477 return NULL;
13478 }
13479
13480
13481 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13482 PyObject *resultobj = 0;
13483 wxString *arg1 = 0 ;
13484 wxString result;
13485 bool temp1 = false ;
13486 PyObject * obj0 = 0 ;
13487 char * kwnames[] = {
13488 (char *) "url", NULL
13489 };
13490
13491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13492 {
13493 arg1 = wxString_in_helper(obj0);
13494 if (arg1 == NULL) SWIG_fail;
13495 temp1 = true;
13496 }
13497 {
13498 PyThreadState* __tstate = wxPyBeginAllowThreads();
13499 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13500 wxPyEndAllowThreads(__tstate);
13501 if (PyErr_Occurred()) SWIG_fail;
13502 }
13503 {
13504 #if wxUSE_UNICODE
13505 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13506 #else
13507 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13508 #endif
13509 }
13510 {
13511 if (temp1)
13512 delete arg1;
13513 }
13514 return resultobj;
13515 fail:
13516 {
13517 if (temp1)
13518 delete arg1;
13519 }
13520 return NULL;
13521 }
13522
13523
13524 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13525 PyObject *obj;
13526 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13527 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13528 return SWIG_Py_Void();
13529 }
13530
13531 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13532 return SWIG_Python_InitShadowInstance(args);
13533 }
13534
13535 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13536 PyObject *resultobj = 0;
13537 wxInternetFSHandler *result = 0 ;
13538
13539 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13540 {
13541 PyThreadState* __tstate = wxPyBeginAllowThreads();
13542 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13543 wxPyEndAllowThreads(__tstate);
13544 if (PyErr_Occurred()) SWIG_fail;
13545 }
13546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13547 return resultobj;
13548 fail:
13549 return NULL;
13550 }
13551
13552
13553 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13554 PyObject *resultobj = 0;
13555 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13556 wxString *arg2 = 0 ;
13557 bool result;
13558 void *argp1 = 0 ;
13559 int res1 = 0 ;
13560 bool temp2 = false ;
13561 PyObject * obj0 = 0 ;
13562 PyObject * obj1 = 0 ;
13563 char * kwnames[] = {
13564 (char *) "self",(char *) "location", NULL
13565 };
13566
13567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13569 if (!SWIG_IsOK(res1)) {
13570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13571 }
13572 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13573 {
13574 arg2 = wxString_in_helper(obj1);
13575 if (arg2 == NULL) SWIG_fail;
13576 temp2 = true;
13577 }
13578 {
13579 PyThreadState* __tstate = wxPyBeginAllowThreads();
13580 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13581 wxPyEndAllowThreads(__tstate);
13582 if (PyErr_Occurred()) SWIG_fail;
13583 }
13584 {
13585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13586 }
13587 {
13588 if (temp2)
13589 delete arg2;
13590 }
13591 return resultobj;
13592 fail:
13593 {
13594 if (temp2)
13595 delete arg2;
13596 }
13597 return NULL;
13598 }
13599
13600
13601 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13602 PyObject *resultobj = 0;
13603 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13604 wxFileSystem *arg2 = 0 ;
13605 wxString *arg3 = 0 ;
13606 wxFSFile *result = 0 ;
13607 void *argp1 = 0 ;
13608 int res1 = 0 ;
13609 void *argp2 = 0 ;
13610 int res2 = 0 ;
13611 bool temp3 = false ;
13612 PyObject * obj0 = 0 ;
13613 PyObject * obj1 = 0 ;
13614 PyObject * obj2 = 0 ;
13615 char * kwnames[] = {
13616 (char *) "self",(char *) "fs",(char *) "location", NULL
13617 };
13618
13619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13621 if (!SWIG_IsOK(res1)) {
13622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13623 }
13624 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13625 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13626 if (!SWIG_IsOK(res2)) {
13627 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13628 }
13629 if (!argp2) {
13630 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13631 }
13632 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13633 {
13634 arg3 = wxString_in_helper(obj2);
13635 if (arg3 == NULL) SWIG_fail;
13636 temp3 = true;
13637 }
13638 {
13639 PyThreadState* __tstate = wxPyBeginAllowThreads();
13640 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13641 wxPyEndAllowThreads(__tstate);
13642 if (PyErr_Occurred()) SWIG_fail;
13643 }
13644 {
13645 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13646 }
13647 {
13648 if (temp3)
13649 delete arg3;
13650 }
13651 return resultobj;
13652 fail:
13653 {
13654 if (temp3)
13655 delete arg3;
13656 }
13657 return NULL;
13658 }
13659
13660
13661 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13662 PyObject *obj;
13663 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13664 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13665 return SWIG_Py_Void();
13666 }
13667
13668 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13669 return SWIG_Python_InitShadowInstance(args);
13670 }
13671
13672 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13673 PyObject *resultobj = 0;
13674 wxZipFSHandler *result = 0 ;
13675
13676 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13677 {
13678 PyThreadState* __tstate = wxPyBeginAllowThreads();
13679 result = (wxZipFSHandler *)new wxZipFSHandler();
13680 wxPyEndAllowThreads(__tstate);
13681 if (PyErr_Occurred()) SWIG_fail;
13682 }
13683 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13684 return resultobj;
13685 fail:
13686 return NULL;
13687 }
13688
13689
13690 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13691 PyObject *resultobj = 0;
13692 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13693 wxString *arg2 = 0 ;
13694 bool result;
13695 void *argp1 = 0 ;
13696 int res1 = 0 ;
13697 bool temp2 = false ;
13698 PyObject * obj0 = 0 ;
13699 PyObject * obj1 = 0 ;
13700 char * kwnames[] = {
13701 (char *) "self",(char *) "location", NULL
13702 };
13703
13704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13706 if (!SWIG_IsOK(res1)) {
13707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13708 }
13709 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13710 {
13711 arg2 = wxString_in_helper(obj1);
13712 if (arg2 == NULL) SWIG_fail;
13713 temp2 = true;
13714 }
13715 {
13716 PyThreadState* __tstate = wxPyBeginAllowThreads();
13717 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13718 wxPyEndAllowThreads(__tstate);
13719 if (PyErr_Occurred()) SWIG_fail;
13720 }
13721 {
13722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13723 }
13724 {
13725 if (temp2)
13726 delete arg2;
13727 }
13728 return resultobj;
13729 fail:
13730 {
13731 if (temp2)
13732 delete arg2;
13733 }
13734 return NULL;
13735 }
13736
13737
13738 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13739 PyObject *resultobj = 0;
13740 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13741 wxFileSystem *arg2 = 0 ;
13742 wxString *arg3 = 0 ;
13743 wxFSFile *result = 0 ;
13744 void *argp1 = 0 ;
13745 int res1 = 0 ;
13746 void *argp2 = 0 ;
13747 int res2 = 0 ;
13748 bool temp3 = false ;
13749 PyObject * obj0 = 0 ;
13750 PyObject * obj1 = 0 ;
13751 PyObject * obj2 = 0 ;
13752 char * kwnames[] = {
13753 (char *) "self",(char *) "fs",(char *) "location", NULL
13754 };
13755
13756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13758 if (!SWIG_IsOK(res1)) {
13759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13760 }
13761 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13762 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13763 if (!SWIG_IsOK(res2)) {
13764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13765 }
13766 if (!argp2) {
13767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13768 }
13769 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13770 {
13771 arg3 = wxString_in_helper(obj2);
13772 if (arg3 == NULL) SWIG_fail;
13773 temp3 = true;
13774 }
13775 {
13776 PyThreadState* __tstate = wxPyBeginAllowThreads();
13777 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13778 wxPyEndAllowThreads(__tstate);
13779 if (PyErr_Occurred()) SWIG_fail;
13780 }
13781 {
13782 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13783 }
13784 {
13785 if (temp3)
13786 delete arg3;
13787 }
13788 return resultobj;
13789 fail:
13790 {
13791 if (temp3)
13792 delete arg3;
13793 }
13794 return NULL;
13795 }
13796
13797
13798 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13799 PyObject *resultobj = 0;
13800 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13801 wxString *arg2 = 0 ;
13802 int arg3 = (int) 0 ;
13803 wxString result;
13804 void *argp1 = 0 ;
13805 int res1 = 0 ;
13806 bool temp2 = false ;
13807 int val3 ;
13808 int ecode3 = 0 ;
13809 PyObject * obj0 = 0 ;
13810 PyObject * obj1 = 0 ;
13811 PyObject * obj2 = 0 ;
13812 char * kwnames[] = {
13813 (char *) "self",(char *) "spec",(char *) "flags", NULL
13814 };
13815
13816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13818 if (!SWIG_IsOK(res1)) {
13819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13820 }
13821 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13822 {
13823 arg2 = wxString_in_helper(obj1);
13824 if (arg2 == NULL) SWIG_fail;
13825 temp2 = true;
13826 }
13827 if (obj2) {
13828 ecode3 = SWIG_AsVal_int(obj2, &val3);
13829 if (!SWIG_IsOK(ecode3)) {
13830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13831 }
13832 arg3 = static_cast< int >(val3);
13833 }
13834 {
13835 PyThreadState* __tstate = wxPyBeginAllowThreads();
13836 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13837 wxPyEndAllowThreads(__tstate);
13838 if (PyErr_Occurred()) SWIG_fail;
13839 }
13840 {
13841 #if wxUSE_UNICODE
13842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13843 #else
13844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13845 #endif
13846 }
13847 {
13848 if (temp2)
13849 delete arg2;
13850 }
13851 return resultobj;
13852 fail:
13853 {
13854 if (temp2)
13855 delete arg2;
13856 }
13857 return NULL;
13858 }
13859
13860
13861 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13862 PyObject *resultobj = 0;
13863 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13864 wxString result;
13865 void *argp1 = 0 ;
13866 int res1 = 0 ;
13867 PyObject *swig_obj[1] ;
13868
13869 if (!args) SWIG_fail;
13870 swig_obj[0] = args;
13871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13872 if (!SWIG_IsOK(res1)) {
13873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13874 }
13875 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13876 {
13877 PyThreadState* __tstate = wxPyBeginAllowThreads();
13878 result = (arg1)->FindNext();
13879 wxPyEndAllowThreads(__tstate);
13880 if (PyErr_Occurred()) SWIG_fail;
13881 }
13882 {
13883 #if wxUSE_UNICODE
13884 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13885 #else
13886 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13887 #endif
13888 }
13889 return resultobj;
13890 fail:
13891 return NULL;
13892 }
13893
13894
13895 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13896 PyObject *obj;
13897 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13898 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13899 return SWIG_Py_Void();
13900 }
13901
13902 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13903 return SWIG_Python_InitShadowInstance(args);
13904 }
13905
13906 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13907 PyObject *resultobj = 0;
13908 wxString *arg1 = 0 ;
13909 wxImage *arg2 = 0 ;
13910 long arg3 ;
13911 bool temp1 = false ;
13912 void *argp2 = 0 ;
13913 int res2 = 0 ;
13914 long val3 ;
13915 int ecode3 = 0 ;
13916 PyObject * obj0 = 0 ;
13917 PyObject * obj1 = 0 ;
13918 PyObject * obj2 = 0 ;
13919 char * kwnames[] = {
13920 (char *) "filename",(char *) "image",(char *) "type", NULL
13921 };
13922
13923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13924 {
13925 arg1 = wxString_in_helper(obj0);
13926 if (arg1 == NULL) SWIG_fail;
13927 temp1 = true;
13928 }
13929 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13930 if (!SWIG_IsOK(res2)) {
13931 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13932 }
13933 if (!argp2) {
13934 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13935 }
13936 arg2 = reinterpret_cast< wxImage * >(argp2);
13937 ecode3 = SWIG_AsVal_long(obj2, &val3);
13938 if (!SWIG_IsOK(ecode3)) {
13939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13940 }
13941 arg3 = static_cast< long >(val3);
13942 {
13943 PyThreadState* __tstate = wxPyBeginAllowThreads();
13944 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13945 wxPyEndAllowThreads(__tstate);
13946 if (PyErr_Occurred()) SWIG_fail;
13947 }
13948 resultobj = SWIG_Py_Void();
13949 {
13950 if (temp1)
13951 delete arg1;
13952 }
13953 return resultobj;
13954 fail:
13955 {
13956 if (temp1)
13957 delete arg1;
13958 }
13959 return NULL;
13960 }
13961
13962
13963 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13964 PyObject *resultobj = 0;
13965 wxString *arg1 = 0 ;
13966 wxBitmap *arg2 = 0 ;
13967 long arg3 ;
13968 bool temp1 = false ;
13969 void *argp2 = 0 ;
13970 int res2 = 0 ;
13971 long val3 ;
13972 int ecode3 = 0 ;
13973 PyObject * obj0 = 0 ;
13974 PyObject * obj1 = 0 ;
13975 PyObject * obj2 = 0 ;
13976 char * kwnames[] = {
13977 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13978 };
13979
13980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13981 {
13982 arg1 = wxString_in_helper(obj0);
13983 if (arg1 == NULL) SWIG_fail;
13984 temp1 = true;
13985 }
13986 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13987 if (!SWIG_IsOK(res2)) {
13988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13989 }
13990 if (!argp2) {
13991 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13992 }
13993 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13994 ecode3 = SWIG_AsVal_long(obj2, &val3);
13995 if (!SWIG_IsOK(ecode3)) {
13996 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13997 }
13998 arg3 = static_cast< long >(val3);
13999 {
14000 PyThreadState* __tstate = wxPyBeginAllowThreads();
14001 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
14002 wxPyEndAllowThreads(__tstate);
14003 if (PyErr_Occurred()) SWIG_fail;
14004 }
14005 resultobj = SWIG_Py_Void();
14006 {
14007 if (temp1)
14008 delete arg1;
14009 }
14010 return resultobj;
14011 fail:
14012 {
14013 if (temp1)
14014 delete arg1;
14015 }
14016 return NULL;
14017 }
14018
14019
14020 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14021 PyObject *resultobj = 0;
14022 wxString *arg1 = 0 ;
14023 PyObject *arg2 = (PyObject *) 0 ;
14024 bool temp1 = false ;
14025 PyObject * obj0 = 0 ;
14026 PyObject * obj1 = 0 ;
14027 char * kwnames[] = {
14028 (char *) "filename",(char *) "data", NULL
14029 };
14030
14031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
14032 {
14033 arg1 = wxString_in_helper(obj0);
14034 if (arg1 == NULL) SWIG_fail;
14035 temp1 = true;
14036 }
14037 arg2 = obj1;
14038 {
14039 PyThreadState* __tstate = wxPyBeginAllowThreads();
14040 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
14041 wxPyEndAllowThreads(__tstate);
14042 if (PyErr_Occurred()) SWIG_fail;
14043 }
14044 resultobj = SWIG_Py_Void();
14045 {
14046 if (temp1)
14047 delete arg1;
14048 }
14049 return resultobj;
14050 fail:
14051 {
14052 if (temp1)
14053 delete arg1;
14054 }
14055 return NULL;
14056 }
14057
14058
14059 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14060 PyObject *resultobj = 0;
14061 wxMemoryFSHandler *result = 0 ;
14062
14063 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
14064 {
14065 PyThreadState* __tstate = wxPyBeginAllowThreads();
14066 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
14067 wxPyEndAllowThreads(__tstate);
14068 if (PyErr_Occurred()) SWIG_fail;
14069 }
14070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
14071 return resultobj;
14072 fail:
14073 return NULL;
14074 }
14075
14076
14077 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14078 PyObject *resultobj = 0;
14079 wxString *arg1 = 0 ;
14080 bool temp1 = false ;
14081 PyObject * obj0 = 0 ;
14082 char * kwnames[] = {
14083 (char *) "filename", NULL
14084 };
14085
14086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14087 {
14088 arg1 = wxString_in_helper(obj0);
14089 if (arg1 == NULL) SWIG_fail;
14090 temp1 = true;
14091 }
14092 {
14093 PyThreadState* __tstate = wxPyBeginAllowThreads();
14094 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14095 wxPyEndAllowThreads(__tstate);
14096 if (PyErr_Occurred()) SWIG_fail;
14097 }
14098 resultobj = SWIG_Py_Void();
14099 {
14100 if (temp1)
14101 delete arg1;
14102 }
14103 return resultobj;
14104 fail:
14105 {
14106 if (temp1)
14107 delete arg1;
14108 }
14109 return NULL;
14110 }
14111
14112
14113 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14114 PyObject *resultobj = 0;
14115 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14116 wxString *arg2 = 0 ;
14117 bool result;
14118 void *argp1 = 0 ;
14119 int res1 = 0 ;
14120 bool temp2 = false ;
14121 PyObject * obj0 = 0 ;
14122 PyObject * obj1 = 0 ;
14123 char * kwnames[] = {
14124 (char *) "self",(char *) "location", NULL
14125 };
14126
14127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14129 if (!SWIG_IsOK(res1)) {
14130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14131 }
14132 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14133 {
14134 arg2 = wxString_in_helper(obj1);
14135 if (arg2 == NULL) SWIG_fail;
14136 temp2 = true;
14137 }
14138 {
14139 PyThreadState* __tstate = wxPyBeginAllowThreads();
14140 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14141 wxPyEndAllowThreads(__tstate);
14142 if (PyErr_Occurred()) SWIG_fail;
14143 }
14144 {
14145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14146 }
14147 {
14148 if (temp2)
14149 delete arg2;
14150 }
14151 return resultobj;
14152 fail:
14153 {
14154 if (temp2)
14155 delete arg2;
14156 }
14157 return NULL;
14158 }
14159
14160
14161 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14162 PyObject *resultobj = 0;
14163 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14164 wxFileSystem *arg2 = 0 ;
14165 wxString *arg3 = 0 ;
14166 wxFSFile *result = 0 ;
14167 void *argp1 = 0 ;
14168 int res1 = 0 ;
14169 void *argp2 = 0 ;
14170 int res2 = 0 ;
14171 bool temp3 = false ;
14172 PyObject * obj0 = 0 ;
14173 PyObject * obj1 = 0 ;
14174 PyObject * obj2 = 0 ;
14175 char * kwnames[] = {
14176 (char *) "self",(char *) "fs",(char *) "location", NULL
14177 };
14178
14179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14181 if (!SWIG_IsOK(res1)) {
14182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14183 }
14184 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14185 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14186 if (!SWIG_IsOK(res2)) {
14187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14188 }
14189 if (!argp2) {
14190 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14191 }
14192 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14193 {
14194 arg3 = wxString_in_helper(obj2);
14195 if (arg3 == NULL) SWIG_fail;
14196 temp3 = true;
14197 }
14198 {
14199 PyThreadState* __tstate = wxPyBeginAllowThreads();
14200 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14201 wxPyEndAllowThreads(__tstate);
14202 if (PyErr_Occurred()) SWIG_fail;
14203 }
14204 {
14205 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14206 }
14207 {
14208 if (temp3)
14209 delete arg3;
14210 }
14211 return resultobj;
14212 fail:
14213 {
14214 if (temp3)
14215 delete arg3;
14216 }
14217 return NULL;
14218 }
14219
14220
14221 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14222 PyObject *resultobj = 0;
14223 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14224 wxString *arg2 = 0 ;
14225 int arg3 = (int) 0 ;
14226 wxString result;
14227 void *argp1 = 0 ;
14228 int res1 = 0 ;
14229 bool temp2 = false ;
14230 int val3 ;
14231 int ecode3 = 0 ;
14232 PyObject * obj0 = 0 ;
14233 PyObject * obj1 = 0 ;
14234 PyObject * obj2 = 0 ;
14235 char * kwnames[] = {
14236 (char *) "self",(char *) "spec",(char *) "flags", NULL
14237 };
14238
14239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14241 if (!SWIG_IsOK(res1)) {
14242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14243 }
14244 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14245 {
14246 arg2 = wxString_in_helper(obj1);
14247 if (arg2 == NULL) SWIG_fail;
14248 temp2 = true;
14249 }
14250 if (obj2) {
14251 ecode3 = SWIG_AsVal_int(obj2, &val3);
14252 if (!SWIG_IsOK(ecode3)) {
14253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14254 }
14255 arg3 = static_cast< int >(val3);
14256 }
14257 {
14258 PyThreadState* __tstate = wxPyBeginAllowThreads();
14259 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14260 wxPyEndAllowThreads(__tstate);
14261 if (PyErr_Occurred()) SWIG_fail;
14262 }
14263 {
14264 #if wxUSE_UNICODE
14265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14266 #else
14267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14268 #endif
14269 }
14270 {
14271 if (temp2)
14272 delete arg2;
14273 }
14274 return resultobj;
14275 fail:
14276 {
14277 if (temp2)
14278 delete arg2;
14279 }
14280 return NULL;
14281 }
14282
14283
14284 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14285 PyObject *resultobj = 0;
14286 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14287 wxString result;
14288 void *argp1 = 0 ;
14289 int res1 = 0 ;
14290 PyObject *swig_obj[1] ;
14291
14292 if (!args) SWIG_fail;
14293 swig_obj[0] = args;
14294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14295 if (!SWIG_IsOK(res1)) {
14296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14297 }
14298 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14299 {
14300 PyThreadState* __tstate = wxPyBeginAllowThreads();
14301 result = (arg1)->FindNext();
14302 wxPyEndAllowThreads(__tstate);
14303 if (PyErr_Occurred()) SWIG_fail;
14304 }
14305 {
14306 #if wxUSE_UNICODE
14307 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14308 #else
14309 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14310 #endif
14311 }
14312 return resultobj;
14313 fail:
14314 return NULL;
14315 }
14316
14317
14318 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14319 PyObject *obj;
14320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14321 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14322 return SWIG_Py_Void();
14323 }
14324
14325 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14326 return SWIG_Python_InitShadowInstance(args);
14327 }
14328
14329 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14330 PyObject *resultobj = 0;
14331 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14332 wxString result;
14333 void *argp1 = 0 ;
14334 int res1 = 0 ;
14335 PyObject *swig_obj[1] ;
14336
14337 if (!args) SWIG_fail;
14338 swig_obj[0] = args;
14339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14340 if (!SWIG_IsOK(res1)) {
14341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14342 }
14343 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14344 {
14345 PyThreadState* __tstate = wxPyBeginAllowThreads();
14346 result = (arg1)->GetName();
14347 wxPyEndAllowThreads(__tstate);
14348 if (PyErr_Occurred()) SWIG_fail;
14349 }
14350 {
14351 #if wxUSE_UNICODE
14352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14353 #else
14354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14355 #endif
14356 }
14357 return resultobj;
14358 fail:
14359 return NULL;
14360 }
14361
14362
14363 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14364 PyObject *resultobj = 0;
14365 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14366 wxString result;
14367 void *argp1 = 0 ;
14368 int res1 = 0 ;
14369 PyObject *swig_obj[1] ;
14370
14371 if (!args) SWIG_fail;
14372 swig_obj[0] = args;
14373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14374 if (!SWIG_IsOK(res1)) {
14375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14376 }
14377 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14378 {
14379 PyThreadState* __tstate = wxPyBeginAllowThreads();
14380 result = (arg1)->GetExtension();
14381 wxPyEndAllowThreads(__tstate);
14382 if (PyErr_Occurred()) SWIG_fail;
14383 }
14384 {
14385 #if wxUSE_UNICODE
14386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14387 #else
14388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14389 #endif
14390 }
14391 return resultobj;
14392 fail:
14393 return NULL;
14394 }
14395
14396
14397 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14398 PyObject *resultobj = 0;
14399 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14400 long result;
14401 void *argp1 = 0 ;
14402 int res1 = 0 ;
14403 PyObject *swig_obj[1] ;
14404
14405 if (!args) SWIG_fail;
14406 swig_obj[0] = args;
14407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14408 if (!SWIG_IsOK(res1)) {
14409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14410 }
14411 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14412 {
14413 PyThreadState* __tstate = wxPyBeginAllowThreads();
14414 result = (long)(arg1)->GetType();
14415 wxPyEndAllowThreads(__tstate);
14416 if (PyErr_Occurred()) SWIG_fail;
14417 }
14418 resultobj = SWIG_From_long(static_cast< long >(result));
14419 return resultobj;
14420 fail:
14421 return NULL;
14422 }
14423
14424
14425 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14426 PyObject *resultobj = 0;
14427 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14428 wxString result;
14429 void *argp1 = 0 ;
14430 int res1 = 0 ;
14431 PyObject *swig_obj[1] ;
14432
14433 if (!args) SWIG_fail;
14434 swig_obj[0] = args;
14435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14436 if (!SWIG_IsOK(res1)) {
14437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14438 }
14439 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14440 {
14441 PyThreadState* __tstate = wxPyBeginAllowThreads();
14442 result = (arg1)->GetMimeType();
14443 wxPyEndAllowThreads(__tstate);
14444 if (PyErr_Occurred()) SWIG_fail;
14445 }
14446 {
14447 #if wxUSE_UNICODE
14448 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14449 #else
14450 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14451 #endif
14452 }
14453 return resultobj;
14454 fail:
14455 return NULL;
14456 }
14457
14458
14459 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14460 PyObject *resultobj = 0;
14461 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14462 wxString *arg2 = 0 ;
14463 bool result;
14464 void *argp1 = 0 ;
14465 int res1 = 0 ;
14466 bool temp2 = false ;
14467 PyObject * obj0 = 0 ;
14468 PyObject * obj1 = 0 ;
14469 char * kwnames[] = {
14470 (char *) "self",(char *) "name", NULL
14471 };
14472
14473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14475 if (!SWIG_IsOK(res1)) {
14476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14477 }
14478 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14479 {
14480 arg2 = wxString_in_helper(obj1);
14481 if (arg2 == NULL) SWIG_fail;
14482 temp2 = true;
14483 }
14484 {
14485 PyThreadState* __tstate = wxPyBeginAllowThreads();
14486 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14487 wxPyEndAllowThreads(__tstate);
14488 if (PyErr_Occurred()) SWIG_fail;
14489 }
14490 {
14491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14492 }
14493 {
14494 if (temp2)
14495 delete arg2;
14496 }
14497 return resultobj;
14498 fail:
14499 {
14500 if (temp2)
14501 delete arg2;
14502 }
14503 return NULL;
14504 }
14505
14506
14507 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14508 PyObject *resultobj = 0;
14509 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14510 wxInputStream *arg2 = 0 ;
14511 bool result;
14512 void *argp1 = 0 ;
14513 int res1 = 0 ;
14514 wxPyInputStream *temp2 ;
14515 bool created2 ;
14516 PyObject * obj0 = 0 ;
14517 PyObject * obj1 = 0 ;
14518 char * kwnames[] = {
14519 (char *) "self",(char *) "stream", NULL
14520 };
14521
14522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14524 if (!SWIG_IsOK(res1)) {
14525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14526 }
14527 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14528 {
14529 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14530 arg2 = temp2->m_wxis;
14531 created2 = false;
14532 } else {
14533 PyErr_Clear(); // clear the failure of the wxPyConvert above
14534 arg2 = wxPyCBInputStream_create(obj1, false);
14535 if (arg2 == NULL) {
14536 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14537 SWIG_fail;
14538 }
14539 created2 = true;
14540 }
14541 }
14542 {
14543 PyThreadState* __tstate = wxPyBeginAllowThreads();
14544 result = (bool)(arg1)->CanRead(*arg2);
14545 wxPyEndAllowThreads(__tstate);
14546 if (PyErr_Occurred()) SWIG_fail;
14547 }
14548 {
14549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14550 }
14551 {
14552 if (created2) delete arg2;
14553 }
14554 return resultobj;
14555 fail:
14556 {
14557 if (created2) delete arg2;
14558 }
14559 return NULL;
14560 }
14561
14562
14563 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14564 PyObject *resultobj = 0;
14565 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14566 wxString *arg2 = 0 ;
14567 void *argp1 = 0 ;
14568 int res1 = 0 ;
14569 bool temp2 = false ;
14570 PyObject * obj0 = 0 ;
14571 PyObject * obj1 = 0 ;
14572 char * kwnames[] = {
14573 (char *) "self",(char *) "name", NULL
14574 };
14575
14576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14578 if (!SWIG_IsOK(res1)) {
14579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14580 }
14581 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14582 {
14583 arg2 = wxString_in_helper(obj1);
14584 if (arg2 == NULL) SWIG_fail;
14585 temp2 = true;
14586 }
14587 {
14588 PyThreadState* __tstate = wxPyBeginAllowThreads();
14589 (arg1)->SetName((wxString const &)*arg2);
14590 wxPyEndAllowThreads(__tstate);
14591 if (PyErr_Occurred()) SWIG_fail;
14592 }
14593 resultobj = SWIG_Py_Void();
14594 {
14595 if (temp2)
14596 delete arg2;
14597 }
14598 return resultobj;
14599 fail:
14600 {
14601 if (temp2)
14602 delete arg2;
14603 }
14604 return NULL;
14605 }
14606
14607
14608 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14609 PyObject *resultobj = 0;
14610 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14611 wxString *arg2 = 0 ;
14612 void *argp1 = 0 ;
14613 int res1 = 0 ;
14614 bool temp2 = false ;
14615 PyObject * obj0 = 0 ;
14616 PyObject * obj1 = 0 ;
14617 char * kwnames[] = {
14618 (char *) "self",(char *) "extension", NULL
14619 };
14620
14621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14623 if (!SWIG_IsOK(res1)) {
14624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14625 }
14626 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14627 {
14628 arg2 = wxString_in_helper(obj1);
14629 if (arg2 == NULL) SWIG_fail;
14630 temp2 = true;
14631 }
14632 {
14633 PyThreadState* __tstate = wxPyBeginAllowThreads();
14634 (arg1)->SetExtension((wxString const &)*arg2);
14635 wxPyEndAllowThreads(__tstate);
14636 if (PyErr_Occurred()) SWIG_fail;
14637 }
14638 resultobj = SWIG_Py_Void();
14639 {
14640 if (temp2)
14641 delete arg2;
14642 }
14643 return resultobj;
14644 fail:
14645 {
14646 if (temp2)
14647 delete arg2;
14648 }
14649 return NULL;
14650 }
14651
14652
14653 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14654 PyObject *resultobj = 0;
14655 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14656 long arg2 ;
14657 void *argp1 = 0 ;
14658 int res1 = 0 ;
14659 long val2 ;
14660 int ecode2 = 0 ;
14661 PyObject * obj0 = 0 ;
14662 PyObject * obj1 = 0 ;
14663 char * kwnames[] = {
14664 (char *) "self",(char *) "type", NULL
14665 };
14666
14667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14669 if (!SWIG_IsOK(res1)) {
14670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14671 }
14672 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14673 ecode2 = SWIG_AsVal_long(obj1, &val2);
14674 if (!SWIG_IsOK(ecode2)) {
14675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14676 }
14677 arg2 = static_cast< long >(val2);
14678 {
14679 PyThreadState* __tstate = wxPyBeginAllowThreads();
14680 (arg1)->SetType(arg2);
14681 wxPyEndAllowThreads(__tstate);
14682 if (PyErr_Occurred()) SWIG_fail;
14683 }
14684 resultobj = SWIG_Py_Void();
14685 return resultobj;
14686 fail:
14687 return NULL;
14688 }
14689
14690
14691 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14692 PyObject *resultobj = 0;
14693 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14694 wxString *arg2 = 0 ;
14695 void *argp1 = 0 ;
14696 int res1 = 0 ;
14697 bool temp2 = false ;
14698 PyObject * obj0 = 0 ;
14699 PyObject * obj1 = 0 ;
14700 char * kwnames[] = {
14701 (char *) "self",(char *) "mimetype", NULL
14702 };
14703
14704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14706 if (!SWIG_IsOK(res1)) {
14707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14708 }
14709 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14710 {
14711 arg2 = wxString_in_helper(obj1);
14712 if (arg2 == NULL) SWIG_fail;
14713 temp2 = true;
14714 }
14715 {
14716 PyThreadState* __tstate = wxPyBeginAllowThreads();
14717 (arg1)->SetMimeType((wxString const &)*arg2);
14718 wxPyEndAllowThreads(__tstate);
14719 if (PyErr_Occurred()) SWIG_fail;
14720 }
14721 resultobj = SWIG_Py_Void();
14722 {
14723 if (temp2)
14724 delete arg2;
14725 }
14726 return resultobj;
14727 fail:
14728 {
14729 if (temp2)
14730 delete arg2;
14731 }
14732 return NULL;
14733 }
14734
14735
14736 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14737 PyObject *obj;
14738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14739 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14740 return SWIG_Py_Void();
14741 }
14742
14743 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14744 PyObject *resultobj = 0;
14745 wxPyImageHandler *result = 0 ;
14746
14747 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14748 {
14749 PyThreadState* __tstate = wxPyBeginAllowThreads();
14750 result = (wxPyImageHandler *)new wxPyImageHandler();
14751 wxPyEndAllowThreads(__tstate);
14752 if (PyErr_Occurred()) SWIG_fail;
14753 }
14754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14755 return resultobj;
14756 fail:
14757 return NULL;
14758 }
14759
14760
14761 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14762 PyObject *resultobj = 0;
14763 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14764 PyObject *arg2 = (PyObject *) 0 ;
14765 void *argp1 = 0 ;
14766 int res1 = 0 ;
14767 PyObject * obj0 = 0 ;
14768 PyObject * obj1 = 0 ;
14769 char * kwnames[] = {
14770 (char *) "self",(char *) "self", NULL
14771 };
14772
14773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14775 if (!SWIG_IsOK(res1)) {
14776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14777 }
14778 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14779 arg2 = obj1;
14780 {
14781 PyThreadState* __tstate = wxPyBeginAllowThreads();
14782 (arg1)->_SetSelf(arg2);
14783 wxPyEndAllowThreads(__tstate);
14784 if (PyErr_Occurred()) SWIG_fail;
14785 }
14786 resultobj = SWIG_Py_Void();
14787 return resultobj;
14788 fail:
14789 return NULL;
14790 }
14791
14792
14793 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14794 PyObject *obj;
14795 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14796 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14797 return SWIG_Py_Void();
14798 }
14799
14800 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14801 return SWIG_Python_InitShadowInstance(args);
14802 }
14803
14804 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14805 PyObject *resultobj = 0;
14806 wxImageHistogram *result = 0 ;
14807
14808 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14809 {
14810 PyThreadState* __tstate = wxPyBeginAllowThreads();
14811 result = (wxImageHistogram *)new wxImageHistogram();
14812 wxPyEndAllowThreads(__tstate);
14813 if (PyErr_Occurred()) SWIG_fail;
14814 }
14815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14816 return resultobj;
14817 fail:
14818 return NULL;
14819 }
14820
14821
14822 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14823 PyObject *resultobj = 0;
14824 byte arg1 ;
14825 byte arg2 ;
14826 byte arg3 ;
14827 unsigned long result;
14828 unsigned char val1 ;
14829 int ecode1 = 0 ;
14830 unsigned char val2 ;
14831 int ecode2 = 0 ;
14832 unsigned char val3 ;
14833 int ecode3 = 0 ;
14834 PyObject * obj0 = 0 ;
14835 PyObject * obj1 = 0 ;
14836 PyObject * obj2 = 0 ;
14837 char * kwnames[] = {
14838 (char *) "r",(char *) "g",(char *) "b", NULL
14839 };
14840
14841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14842 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14843 if (!SWIG_IsOK(ecode1)) {
14844 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14845 }
14846 arg1 = static_cast< byte >(val1);
14847 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14848 if (!SWIG_IsOK(ecode2)) {
14849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14850 }
14851 arg2 = static_cast< byte >(val2);
14852 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14853 if (!SWIG_IsOK(ecode3)) {
14854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14855 }
14856 arg3 = static_cast< byte >(val3);
14857 {
14858 PyThreadState* __tstate = wxPyBeginAllowThreads();
14859 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14860 wxPyEndAllowThreads(__tstate);
14861 if (PyErr_Occurred()) SWIG_fail;
14862 }
14863 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14864 return resultobj;
14865 fail:
14866 return NULL;
14867 }
14868
14869
14870 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14871 PyObject *resultobj = 0;
14872 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14873 byte *arg2 = (byte *) 0 ;
14874 byte *arg3 = (byte *) 0 ;
14875 byte *arg4 = (byte *) 0 ;
14876 byte arg5 = (byte) 1 ;
14877 byte arg6 = (byte) 0 ;
14878 byte arg7 = (byte) 0 ;
14879 bool result;
14880 void *argp1 = 0 ;
14881 int res1 = 0 ;
14882 byte temp2 ;
14883 int res2 = SWIG_TMPOBJ ;
14884 byte temp3 ;
14885 int res3 = SWIG_TMPOBJ ;
14886 byte temp4 ;
14887 int res4 = SWIG_TMPOBJ ;
14888 unsigned char val5 ;
14889 int ecode5 = 0 ;
14890 unsigned char val6 ;
14891 int ecode6 = 0 ;
14892 unsigned char val7 ;
14893 int ecode7 = 0 ;
14894 PyObject * obj0 = 0 ;
14895 PyObject * obj1 = 0 ;
14896 PyObject * obj2 = 0 ;
14897 PyObject * obj3 = 0 ;
14898 char * kwnames[] = {
14899 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14900 };
14901
14902 arg2 = &temp2;
14903 arg3 = &temp3;
14904 arg4 = &temp4;
14905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14907 if (!SWIG_IsOK(res1)) {
14908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14909 }
14910 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14911 if (obj1) {
14912 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14913 if (!SWIG_IsOK(ecode5)) {
14914 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14915 }
14916 arg5 = static_cast< byte >(val5);
14917 }
14918 if (obj2) {
14919 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14920 if (!SWIG_IsOK(ecode6)) {
14921 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14922 }
14923 arg6 = static_cast< byte >(val6);
14924 }
14925 if (obj3) {
14926 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14927 if (!SWIG_IsOK(ecode7)) {
14928 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14929 }
14930 arg7 = static_cast< byte >(val7);
14931 }
14932 {
14933 PyThreadState* __tstate = wxPyBeginAllowThreads();
14934 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14935 wxPyEndAllowThreads(__tstate);
14936 if (PyErr_Occurred()) SWIG_fail;
14937 }
14938 {
14939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14940 }
14941 if (SWIG_IsTmpObj(res2)) {
14942 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14943 } else {
14944 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14945 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14946 }
14947 if (SWIG_IsTmpObj(res3)) {
14948 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14949 } else {
14950 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14951 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14952 }
14953 if (SWIG_IsTmpObj(res4)) {
14954 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14955 } else {
14956 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14957 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14958 }
14959 return resultobj;
14960 fail:
14961 return NULL;
14962 }
14963
14964
14965 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14966 PyObject *resultobj = 0;
14967 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14968 unsigned long arg2 ;
14969 unsigned long result;
14970 void *argp1 = 0 ;
14971 int res1 = 0 ;
14972 unsigned long val2 ;
14973 int ecode2 = 0 ;
14974 PyObject * obj0 = 0 ;
14975 PyObject * obj1 = 0 ;
14976 char * kwnames[] = {
14977 (char *) "self",(char *) "key", NULL
14978 };
14979
14980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14982 if (!SWIG_IsOK(res1)) {
14983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14984 }
14985 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14986 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14987 if (!SWIG_IsOK(ecode2)) {
14988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14989 }
14990 arg2 = static_cast< unsigned long >(val2);
14991 {
14992 PyThreadState* __tstate = wxPyBeginAllowThreads();
14993 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14994 wxPyEndAllowThreads(__tstate);
14995 if (PyErr_Occurred()) SWIG_fail;
14996 }
14997 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14998 return resultobj;
14999 fail:
15000 return NULL;
15001 }
15002
15003
15004 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15005 PyObject *resultobj = 0;
15006 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15007 byte arg2 ;
15008 byte arg3 ;
15009 byte arg4 ;
15010 unsigned long result;
15011 void *argp1 = 0 ;
15012 int res1 = 0 ;
15013 unsigned char val2 ;
15014 int ecode2 = 0 ;
15015 unsigned char val3 ;
15016 int ecode3 = 0 ;
15017 unsigned char val4 ;
15018 int ecode4 = 0 ;
15019 PyObject * obj0 = 0 ;
15020 PyObject * obj1 = 0 ;
15021 PyObject * obj2 = 0 ;
15022 PyObject * obj3 = 0 ;
15023 char * kwnames[] = {
15024 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15025 };
15026
15027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15029 if (!SWIG_IsOK(res1)) {
15030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15031 }
15032 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15033 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15034 if (!SWIG_IsOK(ecode2)) {
15035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
15036 }
15037 arg2 = static_cast< byte >(val2);
15038 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15039 if (!SWIG_IsOK(ecode3)) {
15040 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
15041 }
15042 arg3 = static_cast< byte >(val3);
15043 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15044 if (!SWIG_IsOK(ecode4)) {
15045 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
15046 }
15047 arg4 = static_cast< byte >(val4);
15048 {
15049 PyThreadState* __tstate = wxPyBeginAllowThreads();
15050 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
15051 wxPyEndAllowThreads(__tstate);
15052 if (PyErr_Occurred()) SWIG_fail;
15053 }
15054 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15055 return resultobj;
15056 fail:
15057 return NULL;
15058 }
15059
15060
15061 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15062 PyObject *resultobj = 0;
15063 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15064 wxColour *arg2 = 0 ;
15065 unsigned long result;
15066 void *argp1 = 0 ;
15067 int res1 = 0 ;
15068 wxColour temp2 ;
15069 PyObject * obj0 = 0 ;
15070 PyObject * obj1 = 0 ;
15071 char * kwnames[] = {
15072 (char *) "self",(char *) "colour", NULL
15073 };
15074
15075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15077 if (!SWIG_IsOK(res1)) {
15078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15079 }
15080 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15081 {
15082 arg2 = &temp2;
15083 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15084 }
15085 {
15086 PyThreadState* __tstate = wxPyBeginAllowThreads();
15087 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15088 wxPyEndAllowThreads(__tstate);
15089 if (PyErr_Occurred()) SWIG_fail;
15090 }
15091 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15092 return resultobj;
15093 fail:
15094 return NULL;
15095 }
15096
15097
15098 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15099 PyObject *obj;
15100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15101 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15102 return SWIG_Py_Void();
15103 }
15104
15105 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15106 return SWIG_Python_InitShadowInstance(args);
15107 }
15108
15109 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15110 PyObject *resultobj = 0;
15111 byte arg1 = (byte) 0 ;
15112 byte arg2 = (byte) 0 ;
15113 byte arg3 = (byte) 0 ;
15114 wxImage_RGBValue *result = 0 ;
15115 unsigned char val1 ;
15116 int ecode1 = 0 ;
15117 unsigned char val2 ;
15118 int ecode2 = 0 ;
15119 unsigned char val3 ;
15120 int ecode3 = 0 ;
15121 PyObject * obj0 = 0 ;
15122 PyObject * obj1 = 0 ;
15123 PyObject * obj2 = 0 ;
15124 char * kwnames[] = {
15125 (char *) "r",(char *) "g",(char *) "b", NULL
15126 };
15127
15128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15129 if (obj0) {
15130 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15131 if (!SWIG_IsOK(ecode1)) {
15132 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15133 }
15134 arg1 = static_cast< byte >(val1);
15135 }
15136 if (obj1) {
15137 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15138 if (!SWIG_IsOK(ecode2)) {
15139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15140 }
15141 arg2 = static_cast< byte >(val2);
15142 }
15143 if (obj2) {
15144 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15145 if (!SWIG_IsOK(ecode3)) {
15146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15147 }
15148 arg3 = static_cast< byte >(val3);
15149 }
15150 {
15151 PyThreadState* __tstate = wxPyBeginAllowThreads();
15152 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15153 wxPyEndAllowThreads(__tstate);
15154 if (PyErr_Occurred()) SWIG_fail;
15155 }
15156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15157 return resultobj;
15158 fail:
15159 return NULL;
15160 }
15161
15162
15163 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15164 PyObject *resultobj = 0;
15165 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15166 byte arg2 ;
15167 void *argp1 = 0 ;
15168 int res1 = 0 ;
15169 unsigned char val2 ;
15170 int ecode2 = 0 ;
15171 PyObject *swig_obj[2] ;
15172
15173 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15175 if (!SWIG_IsOK(res1)) {
15176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15177 }
15178 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15179 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15180 if (!SWIG_IsOK(ecode2)) {
15181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15182 }
15183 arg2 = static_cast< byte >(val2);
15184 if (arg1) (arg1)->red = arg2;
15185
15186 resultobj = SWIG_Py_Void();
15187 return resultobj;
15188 fail:
15189 return NULL;
15190 }
15191
15192
15193 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15194 PyObject *resultobj = 0;
15195 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15196 byte result;
15197 void *argp1 = 0 ;
15198 int res1 = 0 ;
15199 PyObject *swig_obj[1] ;
15200
15201 if (!args) SWIG_fail;
15202 swig_obj[0] = args;
15203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15204 if (!SWIG_IsOK(res1)) {
15205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15206 }
15207 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15208 result = (byte) ((arg1)->red);
15209 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15210 return resultobj;
15211 fail:
15212 return NULL;
15213 }
15214
15215
15216 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15217 PyObject *resultobj = 0;
15218 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15219 byte arg2 ;
15220 void *argp1 = 0 ;
15221 int res1 = 0 ;
15222 unsigned char val2 ;
15223 int ecode2 = 0 ;
15224 PyObject *swig_obj[2] ;
15225
15226 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15228 if (!SWIG_IsOK(res1)) {
15229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15230 }
15231 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15232 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15233 if (!SWIG_IsOK(ecode2)) {
15234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15235 }
15236 arg2 = static_cast< byte >(val2);
15237 if (arg1) (arg1)->green = arg2;
15238
15239 resultobj = SWIG_Py_Void();
15240 return resultobj;
15241 fail:
15242 return NULL;
15243 }
15244
15245
15246 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15247 PyObject *resultobj = 0;
15248 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15249 byte result;
15250 void *argp1 = 0 ;
15251 int res1 = 0 ;
15252 PyObject *swig_obj[1] ;
15253
15254 if (!args) SWIG_fail;
15255 swig_obj[0] = args;
15256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15257 if (!SWIG_IsOK(res1)) {
15258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15259 }
15260 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15261 result = (byte) ((arg1)->green);
15262 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15263 return resultobj;
15264 fail:
15265 return NULL;
15266 }
15267
15268
15269 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15270 PyObject *resultobj = 0;
15271 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15272 byte arg2 ;
15273 void *argp1 = 0 ;
15274 int res1 = 0 ;
15275 unsigned char val2 ;
15276 int ecode2 = 0 ;
15277 PyObject *swig_obj[2] ;
15278
15279 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15281 if (!SWIG_IsOK(res1)) {
15282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15283 }
15284 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15285 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15286 if (!SWIG_IsOK(ecode2)) {
15287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15288 }
15289 arg2 = static_cast< byte >(val2);
15290 if (arg1) (arg1)->blue = arg2;
15291
15292 resultobj = SWIG_Py_Void();
15293 return resultobj;
15294 fail:
15295 return NULL;
15296 }
15297
15298
15299 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15300 PyObject *resultobj = 0;
15301 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15302 byte result;
15303 void *argp1 = 0 ;
15304 int res1 = 0 ;
15305 PyObject *swig_obj[1] ;
15306
15307 if (!args) SWIG_fail;
15308 swig_obj[0] = args;
15309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15310 if (!SWIG_IsOK(res1)) {
15311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15312 }
15313 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15314 result = (byte) ((arg1)->blue);
15315 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15316 return resultobj;
15317 fail:
15318 return NULL;
15319 }
15320
15321
15322 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15323 PyObject *obj;
15324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15325 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15326 return SWIG_Py_Void();
15327 }
15328
15329 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15330 return SWIG_Python_InitShadowInstance(args);
15331 }
15332
15333 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15334 PyObject *resultobj = 0;
15335 double arg1 = (double) 0.0 ;
15336 double arg2 = (double) 0.0 ;
15337 double arg3 = (double) 0.0 ;
15338 wxImage_HSVValue *result = 0 ;
15339 double val1 ;
15340 int ecode1 = 0 ;
15341 double val2 ;
15342 int ecode2 = 0 ;
15343 double val3 ;
15344 int ecode3 = 0 ;
15345 PyObject * obj0 = 0 ;
15346 PyObject * obj1 = 0 ;
15347 PyObject * obj2 = 0 ;
15348 char * kwnames[] = {
15349 (char *) "h",(char *) "s",(char *) "v", NULL
15350 };
15351
15352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15353 if (obj0) {
15354 ecode1 = SWIG_AsVal_double(obj0, &val1);
15355 if (!SWIG_IsOK(ecode1)) {
15356 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15357 }
15358 arg1 = static_cast< double >(val1);
15359 }
15360 if (obj1) {
15361 ecode2 = SWIG_AsVal_double(obj1, &val2);
15362 if (!SWIG_IsOK(ecode2)) {
15363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15364 }
15365 arg2 = static_cast< double >(val2);
15366 }
15367 if (obj2) {
15368 ecode3 = SWIG_AsVal_double(obj2, &val3);
15369 if (!SWIG_IsOK(ecode3)) {
15370 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15371 }
15372 arg3 = static_cast< double >(val3);
15373 }
15374 {
15375 PyThreadState* __tstate = wxPyBeginAllowThreads();
15376 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15377 wxPyEndAllowThreads(__tstate);
15378 if (PyErr_Occurred()) SWIG_fail;
15379 }
15380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15381 return resultobj;
15382 fail:
15383 return NULL;
15384 }
15385
15386
15387 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15388 PyObject *resultobj = 0;
15389 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15390 double arg2 ;
15391 void *argp1 = 0 ;
15392 int res1 = 0 ;
15393 double val2 ;
15394 int ecode2 = 0 ;
15395 PyObject *swig_obj[2] ;
15396
15397 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15399 if (!SWIG_IsOK(res1)) {
15400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15401 }
15402 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15403 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15404 if (!SWIG_IsOK(ecode2)) {
15405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15406 }
15407 arg2 = static_cast< double >(val2);
15408 if (arg1) (arg1)->hue = arg2;
15409
15410 resultobj = SWIG_Py_Void();
15411 return resultobj;
15412 fail:
15413 return NULL;
15414 }
15415
15416
15417 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15418 PyObject *resultobj = 0;
15419 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15420 double result;
15421 void *argp1 = 0 ;
15422 int res1 = 0 ;
15423 PyObject *swig_obj[1] ;
15424
15425 if (!args) SWIG_fail;
15426 swig_obj[0] = args;
15427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15428 if (!SWIG_IsOK(res1)) {
15429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15430 }
15431 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15432 result = (double) ((arg1)->hue);
15433 resultobj = SWIG_From_double(static_cast< double >(result));
15434 return resultobj;
15435 fail:
15436 return NULL;
15437 }
15438
15439
15440 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15441 PyObject *resultobj = 0;
15442 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15443 double arg2 ;
15444 void *argp1 = 0 ;
15445 int res1 = 0 ;
15446 double val2 ;
15447 int ecode2 = 0 ;
15448 PyObject *swig_obj[2] ;
15449
15450 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15452 if (!SWIG_IsOK(res1)) {
15453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15454 }
15455 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15456 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15457 if (!SWIG_IsOK(ecode2)) {
15458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15459 }
15460 arg2 = static_cast< double >(val2);
15461 if (arg1) (arg1)->saturation = arg2;
15462
15463 resultobj = SWIG_Py_Void();
15464 return resultobj;
15465 fail:
15466 return NULL;
15467 }
15468
15469
15470 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15471 PyObject *resultobj = 0;
15472 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15473 double result;
15474 void *argp1 = 0 ;
15475 int res1 = 0 ;
15476 PyObject *swig_obj[1] ;
15477
15478 if (!args) SWIG_fail;
15479 swig_obj[0] = args;
15480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15481 if (!SWIG_IsOK(res1)) {
15482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15483 }
15484 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15485 result = (double) ((arg1)->saturation);
15486 resultobj = SWIG_From_double(static_cast< double >(result));
15487 return resultobj;
15488 fail:
15489 return NULL;
15490 }
15491
15492
15493 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15494 PyObject *resultobj = 0;
15495 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15496 double arg2 ;
15497 void *argp1 = 0 ;
15498 int res1 = 0 ;
15499 double val2 ;
15500 int ecode2 = 0 ;
15501 PyObject *swig_obj[2] ;
15502
15503 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15505 if (!SWIG_IsOK(res1)) {
15506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15507 }
15508 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15509 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15510 if (!SWIG_IsOK(ecode2)) {
15511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15512 }
15513 arg2 = static_cast< double >(val2);
15514 if (arg1) (arg1)->value = arg2;
15515
15516 resultobj = SWIG_Py_Void();
15517 return resultobj;
15518 fail:
15519 return NULL;
15520 }
15521
15522
15523 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15524 PyObject *resultobj = 0;
15525 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15526 double result;
15527 void *argp1 = 0 ;
15528 int res1 = 0 ;
15529 PyObject *swig_obj[1] ;
15530
15531 if (!args) SWIG_fail;
15532 swig_obj[0] = args;
15533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15534 if (!SWIG_IsOK(res1)) {
15535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15536 }
15537 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15538 result = (double) ((arg1)->value);
15539 resultobj = SWIG_From_double(static_cast< double >(result));
15540 return resultobj;
15541 fail:
15542 return NULL;
15543 }
15544
15545
15546 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15547 PyObject *obj;
15548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15549 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15550 return SWIG_Py_Void();
15551 }
15552
15553 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15554 return SWIG_Python_InitShadowInstance(args);
15555 }
15556
15557 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15558 PyObject *resultobj = 0;
15559 wxString *arg1 = 0 ;
15560 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15561 int arg3 = (int) -1 ;
15562 wxImage *result = 0 ;
15563 bool temp1 = false ;
15564 long val2 ;
15565 int ecode2 = 0 ;
15566 int val3 ;
15567 int ecode3 = 0 ;
15568 PyObject * obj0 = 0 ;
15569 PyObject * obj1 = 0 ;
15570 PyObject * obj2 = 0 ;
15571 char * kwnames[] = {
15572 (char *) "name",(char *) "type",(char *) "index", NULL
15573 };
15574
15575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15576 {
15577 arg1 = wxString_in_helper(obj0);
15578 if (arg1 == NULL) SWIG_fail;
15579 temp1 = true;
15580 }
15581 if (obj1) {
15582 ecode2 = SWIG_AsVal_long(obj1, &val2);
15583 if (!SWIG_IsOK(ecode2)) {
15584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15585 }
15586 arg2 = static_cast< long >(val2);
15587 }
15588 if (obj2) {
15589 ecode3 = SWIG_AsVal_int(obj2, &val3);
15590 if (!SWIG_IsOK(ecode3)) {
15591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15592 }
15593 arg3 = static_cast< int >(val3);
15594 }
15595 {
15596 PyThreadState* __tstate = wxPyBeginAllowThreads();
15597 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15598 wxPyEndAllowThreads(__tstate);
15599 if (PyErr_Occurred()) SWIG_fail;
15600 }
15601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15602 {
15603 if (temp1)
15604 delete arg1;
15605 }
15606 return resultobj;
15607 fail:
15608 {
15609 if (temp1)
15610 delete arg1;
15611 }
15612 return NULL;
15613 }
15614
15615
15616 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15617 PyObject *resultobj = 0;
15618 wxImage *arg1 = (wxImage *) 0 ;
15619 void *argp1 = 0 ;
15620 int res1 = 0 ;
15621 PyObject *swig_obj[1] ;
15622
15623 if (!args) SWIG_fail;
15624 swig_obj[0] = args;
15625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15626 if (!SWIG_IsOK(res1)) {
15627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15628 }
15629 arg1 = reinterpret_cast< wxImage * >(argp1);
15630 {
15631 PyThreadState* __tstate = wxPyBeginAllowThreads();
15632 delete arg1;
15633
15634 wxPyEndAllowThreads(__tstate);
15635 if (PyErr_Occurred()) SWIG_fail;
15636 }
15637 resultobj = SWIG_Py_Void();
15638 return resultobj;
15639 fail:
15640 return NULL;
15641 }
15642
15643
15644 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15645 PyObject *resultobj = 0;
15646 wxString *arg1 = 0 ;
15647 wxString *arg2 = 0 ;
15648 int arg3 = (int) -1 ;
15649 wxImage *result = 0 ;
15650 bool temp1 = false ;
15651 bool temp2 = false ;
15652 int val3 ;
15653 int ecode3 = 0 ;
15654 PyObject * obj0 = 0 ;
15655 PyObject * obj1 = 0 ;
15656 PyObject * obj2 = 0 ;
15657 char * kwnames[] = {
15658 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15659 };
15660
15661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15662 {
15663 arg1 = wxString_in_helper(obj0);
15664 if (arg1 == NULL) SWIG_fail;
15665 temp1 = true;
15666 }
15667 {
15668 arg2 = wxString_in_helper(obj1);
15669 if (arg2 == NULL) SWIG_fail;
15670 temp2 = true;
15671 }
15672 if (obj2) {
15673 ecode3 = SWIG_AsVal_int(obj2, &val3);
15674 if (!SWIG_IsOK(ecode3)) {
15675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15676 }
15677 arg3 = static_cast< int >(val3);
15678 }
15679 {
15680 PyThreadState* __tstate = wxPyBeginAllowThreads();
15681 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15682 wxPyEndAllowThreads(__tstate);
15683 if (PyErr_Occurred()) SWIG_fail;
15684 }
15685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15686 {
15687 if (temp1)
15688 delete arg1;
15689 }
15690 {
15691 if (temp2)
15692 delete arg2;
15693 }
15694 return resultobj;
15695 fail:
15696 {
15697 if (temp1)
15698 delete arg1;
15699 }
15700 {
15701 if (temp2)
15702 delete arg2;
15703 }
15704 return NULL;
15705 }
15706
15707
15708 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15709 PyObject *resultobj = 0;
15710 wxInputStream *arg1 = 0 ;
15711 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15712 int arg3 = (int) -1 ;
15713 wxImage *result = 0 ;
15714 wxPyInputStream *temp1 ;
15715 bool created1 ;
15716 long val2 ;
15717 int ecode2 = 0 ;
15718 int val3 ;
15719 int ecode3 = 0 ;
15720 PyObject * obj0 = 0 ;
15721 PyObject * obj1 = 0 ;
15722 PyObject * obj2 = 0 ;
15723 char * kwnames[] = {
15724 (char *) "stream",(char *) "type",(char *) "index", NULL
15725 };
15726
15727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15728 {
15729 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15730 arg1 = temp1->m_wxis;
15731 created1 = false;
15732 } else {
15733 PyErr_Clear(); // clear the failure of the wxPyConvert above
15734 arg1 = wxPyCBInputStream_create(obj0, false);
15735 if (arg1 == NULL) {
15736 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15737 SWIG_fail;
15738 }
15739 created1 = true;
15740 }
15741 }
15742 if (obj1) {
15743 ecode2 = SWIG_AsVal_long(obj1, &val2);
15744 if (!SWIG_IsOK(ecode2)) {
15745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15746 }
15747 arg2 = static_cast< long >(val2);
15748 }
15749 if (obj2) {
15750 ecode3 = SWIG_AsVal_int(obj2, &val3);
15751 if (!SWIG_IsOK(ecode3)) {
15752 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15753 }
15754 arg3 = static_cast< int >(val3);
15755 }
15756 {
15757 PyThreadState* __tstate = wxPyBeginAllowThreads();
15758 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15759 wxPyEndAllowThreads(__tstate);
15760 if (PyErr_Occurred()) SWIG_fail;
15761 }
15762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15763 {
15764 if (created1) delete arg1;
15765 }
15766 return resultobj;
15767 fail:
15768 {
15769 if (created1) delete arg1;
15770 }
15771 return NULL;
15772 }
15773
15774
15775 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15776 PyObject *resultobj = 0;
15777 wxInputStream *arg1 = 0 ;
15778 wxString *arg2 = 0 ;
15779 int arg3 = (int) -1 ;
15780 wxImage *result = 0 ;
15781 wxPyInputStream *temp1 ;
15782 bool created1 ;
15783 bool temp2 = false ;
15784 int val3 ;
15785 int ecode3 = 0 ;
15786 PyObject * obj0 = 0 ;
15787 PyObject * obj1 = 0 ;
15788 PyObject * obj2 = 0 ;
15789 char * kwnames[] = {
15790 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15791 };
15792
15793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15794 {
15795 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15796 arg1 = temp1->m_wxis;
15797 created1 = false;
15798 } else {
15799 PyErr_Clear(); // clear the failure of the wxPyConvert above
15800 arg1 = wxPyCBInputStream_create(obj0, false);
15801 if (arg1 == NULL) {
15802 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15803 SWIG_fail;
15804 }
15805 created1 = true;
15806 }
15807 }
15808 {
15809 arg2 = wxString_in_helper(obj1);
15810 if (arg2 == NULL) SWIG_fail;
15811 temp2 = true;
15812 }
15813 if (obj2) {
15814 ecode3 = SWIG_AsVal_int(obj2, &val3);
15815 if (!SWIG_IsOK(ecode3)) {
15816 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15817 }
15818 arg3 = static_cast< int >(val3);
15819 }
15820 {
15821 PyThreadState* __tstate = wxPyBeginAllowThreads();
15822 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15823 wxPyEndAllowThreads(__tstate);
15824 if (PyErr_Occurred()) SWIG_fail;
15825 }
15826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15827 {
15828 if (created1) delete arg1;
15829 }
15830 {
15831 if (temp2)
15832 delete arg2;
15833 }
15834 return resultobj;
15835 fail:
15836 {
15837 if (created1) delete arg1;
15838 }
15839 {
15840 if (temp2)
15841 delete arg2;
15842 }
15843 return NULL;
15844 }
15845
15846
15847 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15848 PyObject *resultobj = 0;
15849 int arg1 = (int) 0 ;
15850 int arg2 = (int) 0 ;
15851 bool arg3 = (bool) true ;
15852 wxImage *result = 0 ;
15853 int val1 ;
15854 int ecode1 = 0 ;
15855 int val2 ;
15856 int ecode2 = 0 ;
15857 bool val3 ;
15858 int ecode3 = 0 ;
15859 PyObject * obj0 = 0 ;
15860 PyObject * obj1 = 0 ;
15861 PyObject * obj2 = 0 ;
15862 char * kwnames[] = {
15863 (char *) "width",(char *) "height",(char *) "clear", NULL
15864 };
15865
15866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15867 if (obj0) {
15868 ecode1 = SWIG_AsVal_int(obj0, &val1);
15869 if (!SWIG_IsOK(ecode1)) {
15870 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15871 }
15872 arg1 = static_cast< int >(val1);
15873 }
15874 if (obj1) {
15875 ecode2 = SWIG_AsVal_int(obj1, &val2);
15876 if (!SWIG_IsOK(ecode2)) {
15877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15878 }
15879 arg2 = static_cast< int >(val2);
15880 }
15881 if (obj2) {
15882 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15883 if (!SWIG_IsOK(ecode3)) {
15884 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15885 }
15886 arg3 = static_cast< bool >(val3);
15887 }
15888 {
15889 PyThreadState* __tstate = wxPyBeginAllowThreads();
15890 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15891 wxPyEndAllowThreads(__tstate);
15892 if (PyErr_Occurred()) SWIG_fail;
15893 }
15894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15895 return resultobj;
15896 fail:
15897 return NULL;
15898 }
15899
15900
15901 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15902 PyObject *resultobj = 0;
15903 wxBitmap *arg1 = 0 ;
15904 wxImage *result = 0 ;
15905 void *argp1 = 0 ;
15906 int res1 = 0 ;
15907 PyObject * obj0 = 0 ;
15908 char * kwnames[] = {
15909 (char *) "bitmap", NULL
15910 };
15911
15912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15913 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15914 if (!SWIG_IsOK(res1)) {
15915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15916 }
15917 if (!argp1) {
15918 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15919 }
15920 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15921 {
15922 if (!wxPyCheckForApp()) SWIG_fail;
15923 PyThreadState* __tstate = wxPyBeginAllowThreads();
15924 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15925 wxPyEndAllowThreads(__tstate);
15926 if (PyErr_Occurred()) SWIG_fail;
15927 }
15928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15929 return resultobj;
15930 fail:
15931 return NULL;
15932 }
15933
15934
15935 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15936 PyObject *resultobj = 0;
15937 int arg1 ;
15938 int arg2 ;
15939 buffer arg3 ;
15940 int arg4 ;
15941 wxImage *result = 0 ;
15942 int val1 ;
15943 int ecode1 = 0 ;
15944 int val2 ;
15945 int ecode2 = 0 ;
15946 Py_ssize_t temp3 ;
15947 PyObject * obj0 = 0 ;
15948 PyObject * obj1 = 0 ;
15949 PyObject * obj2 = 0 ;
15950 char * kwnames[] = {
15951 (char *) "width",(char *) "height",(char *) "data", NULL
15952 };
15953
15954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15955 ecode1 = SWIG_AsVal_int(obj0, &val1);
15956 if (!SWIG_IsOK(ecode1)) {
15957 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15958 }
15959 arg1 = static_cast< int >(val1);
15960 ecode2 = SWIG_AsVal_int(obj1, &val2);
15961 if (!SWIG_IsOK(ecode2)) {
15962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15963 }
15964 arg2 = static_cast< int >(val2);
15965 {
15966 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15967 arg4 = (int)temp3;
15968 }
15969 {
15970 PyThreadState* __tstate = wxPyBeginAllowThreads();
15971 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15972 wxPyEndAllowThreads(__tstate);
15973 if (PyErr_Occurred()) SWIG_fail;
15974 }
15975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15976 return resultobj;
15977 fail:
15978 return NULL;
15979 }
15980
15981
15982 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15983 PyObject *resultobj = 0;
15984 int arg1 ;
15985 int arg2 ;
15986 buffer arg3 ;
15987 int arg4 ;
15988 buffer arg5 ;
15989 int arg6 ;
15990 wxImage *result = 0 ;
15991 int val1 ;
15992 int ecode1 = 0 ;
15993 int val2 ;
15994 int ecode2 = 0 ;
15995 Py_ssize_t temp3 ;
15996 Py_ssize_t temp5 ;
15997 PyObject * obj0 = 0 ;
15998 PyObject * obj1 = 0 ;
15999 PyObject * obj2 = 0 ;
16000 PyObject * obj3 = 0 ;
16001 char * kwnames[] = {
16002 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
16003 };
16004
16005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16006 ecode1 = SWIG_AsVal_int(obj0, &val1);
16007 if (!SWIG_IsOK(ecode1)) {
16008 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
16009 }
16010 arg1 = static_cast< int >(val1);
16011 ecode2 = SWIG_AsVal_int(obj1, &val2);
16012 if (!SWIG_IsOK(ecode2)) {
16013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
16014 }
16015 arg2 = static_cast< int >(val2);
16016 {
16017 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
16018 arg4 = (int)temp3;
16019 }
16020 {
16021 if (obj3 != Py_None) {
16022 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
16023 arg6 = (int)temp5;
16024 }
16025 }
16026 {
16027 PyThreadState* __tstate = wxPyBeginAllowThreads();
16028 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
16029 wxPyEndAllowThreads(__tstate);
16030 if (PyErr_Occurred()) SWIG_fail;
16031 }
16032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16033 return resultobj;
16034 fail:
16035 return NULL;
16036 }
16037
16038
16039 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16040 PyObject *resultobj = 0;
16041 wxImage *arg1 = (wxImage *) 0 ;
16042 int arg2 ;
16043 int arg3 ;
16044 bool arg4 = (bool) true ;
16045 void *argp1 = 0 ;
16046 int res1 = 0 ;
16047 int val2 ;
16048 int ecode2 = 0 ;
16049 int val3 ;
16050 int ecode3 = 0 ;
16051 bool val4 ;
16052 int ecode4 = 0 ;
16053 PyObject * obj0 = 0 ;
16054 PyObject * obj1 = 0 ;
16055 PyObject * obj2 = 0 ;
16056 PyObject * obj3 = 0 ;
16057 char * kwnames[] = {
16058 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
16059 };
16060
16061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16063 if (!SWIG_IsOK(res1)) {
16064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
16065 }
16066 arg1 = reinterpret_cast< wxImage * >(argp1);
16067 ecode2 = SWIG_AsVal_int(obj1, &val2);
16068 if (!SWIG_IsOK(ecode2)) {
16069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
16070 }
16071 arg2 = static_cast< int >(val2);
16072 ecode3 = SWIG_AsVal_int(obj2, &val3);
16073 if (!SWIG_IsOK(ecode3)) {
16074 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16075 }
16076 arg3 = static_cast< int >(val3);
16077 if (obj3) {
16078 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16079 if (!SWIG_IsOK(ecode4)) {
16080 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16081 }
16082 arg4 = static_cast< bool >(val4);
16083 }
16084 {
16085 PyThreadState* __tstate = wxPyBeginAllowThreads();
16086 (arg1)->Create(arg2,arg3,arg4);
16087 wxPyEndAllowThreads(__tstate);
16088 if (PyErr_Occurred()) SWIG_fail;
16089 }
16090 resultobj = SWIG_Py_Void();
16091 return resultobj;
16092 fail:
16093 return NULL;
16094 }
16095
16096
16097 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16098 PyObject *resultobj = 0;
16099 wxImage *arg1 = (wxImage *) 0 ;
16100 void *argp1 = 0 ;
16101 int res1 = 0 ;
16102 PyObject *swig_obj[1] ;
16103
16104 if (!args) SWIG_fail;
16105 swig_obj[0] = args;
16106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16107 if (!SWIG_IsOK(res1)) {
16108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16109 }
16110 arg1 = reinterpret_cast< wxImage * >(argp1);
16111 {
16112 PyThreadState* __tstate = wxPyBeginAllowThreads();
16113 (arg1)->Destroy();
16114 wxPyEndAllowThreads(__tstate);
16115 if (PyErr_Occurred()) SWIG_fail;
16116 }
16117 resultobj = SWIG_Py_Void();
16118 return resultobj;
16119 fail:
16120 return NULL;
16121 }
16122
16123
16124 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16125 PyObject *resultobj = 0;
16126 wxImage *arg1 = (wxImage *) 0 ;
16127 int arg2 ;
16128 int arg3 ;
16129 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16130 SwigValueWrapper<wxImage > result;
16131 void *argp1 = 0 ;
16132 int res1 = 0 ;
16133 int val2 ;
16134 int ecode2 = 0 ;
16135 int val3 ;
16136 int ecode3 = 0 ;
16137 int val4 ;
16138 int ecode4 = 0 ;
16139 PyObject * obj0 = 0 ;
16140 PyObject * obj1 = 0 ;
16141 PyObject * obj2 = 0 ;
16142 PyObject * obj3 = 0 ;
16143 char * kwnames[] = {
16144 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16145 };
16146
16147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16149 if (!SWIG_IsOK(res1)) {
16150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16151 }
16152 arg1 = reinterpret_cast< wxImage * >(argp1);
16153 ecode2 = SWIG_AsVal_int(obj1, &val2);
16154 if (!SWIG_IsOK(ecode2)) {
16155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16156 }
16157 arg2 = static_cast< int >(val2);
16158 ecode3 = SWIG_AsVal_int(obj2, &val3);
16159 if (!SWIG_IsOK(ecode3)) {
16160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16161 }
16162 arg3 = static_cast< int >(val3);
16163 if (obj3) {
16164 ecode4 = SWIG_AsVal_int(obj3, &val4);
16165 if (!SWIG_IsOK(ecode4)) {
16166 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16167 }
16168 arg4 = static_cast< int >(val4);
16169 }
16170 {
16171 PyThreadState* __tstate = wxPyBeginAllowThreads();
16172 result = (arg1)->Scale(arg2,arg3,arg4);
16173 wxPyEndAllowThreads(__tstate);
16174 if (PyErr_Occurred()) SWIG_fail;
16175 }
16176 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16177 return resultobj;
16178 fail:
16179 return NULL;
16180 }
16181
16182
16183 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16184 PyObject *resultobj = 0;
16185 wxImage *arg1 = (wxImage *) 0 ;
16186 int arg2 ;
16187 int arg3 ;
16188 SwigValueWrapper<wxImage > result;
16189 void *argp1 = 0 ;
16190 int res1 = 0 ;
16191 int val2 ;
16192 int ecode2 = 0 ;
16193 int val3 ;
16194 int ecode3 = 0 ;
16195 PyObject * obj0 = 0 ;
16196 PyObject * obj1 = 0 ;
16197 PyObject * obj2 = 0 ;
16198 char * kwnames[] = {
16199 (char *) "self",(char *) "width",(char *) "height", NULL
16200 };
16201
16202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16204 if (!SWIG_IsOK(res1)) {
16205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16206 }
16207 arg1 = reinterpret_cast< wxImage * >(argp1);
16208 ecode2 = SWIG_AsVal_int(obj1, &val2);
16209 if (!SWIG_IsOK(ecode2)) {
16210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16211 }
16212 arg2 = static_cast< int >(val2);
16213 ecode3 = SWIG_AsVal_int(obj2, &val3);
16214 if (!SWIG_IsOK(ecode3)) {
16215 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16216 }
16217 arg3 = static_cast< int >(val3);
16218 {
16219 PyThreadState* __tstate = wxPyBeginAllowThreads();
16220 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16221 wxPyEndAllowThreads(__tstate);
16222 if (PyErr_Occurred()) SWIG_fail;
16223 }
16224 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16225 return resultobj;
16226 fail:
16227 return NULL;
16228 }
16229
16230
16231 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16232 PyObject *resultobj = 0;
16233 wxImage *arg1 = (wxImage *) 0 ;
16234 int arg2 ;
16235 int arg3 ;
16236 SwigValueWrapper<wxImage > result;
16237 void *argp1 = 0 ;
16238 int res1 = 0 ;
16239 int val2 ;
16240 int ecode2 = 0 ;
16241 int val3 ;
16242 int ecode3 = 0 ;
16243 PyObject * obj0 = 0 ;
16244 PyObject * obj1 = 0 ;
16245 PyObject * obj2 = 0 ;
16246 char * kwnames[] = {
16247 (char *) "self",(char *) "width",(char *) "height", NULL
16248 };
16249
16250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16252 if (!SWIG_IsOK(res1)) {
16253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16254 }
16255 arg1 = reinterpret_cast< wxImage * >(argp1);
16256 ecode2 = SWIG_AsVal_int(obj1, &val2);
16257 if (!SWIG_IsOK(ecode2)) {
16258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16259 }
16260 arg2 = static_cast< int >(val2);
16261 ecode3 = SWIG_AsVal_int(obj2, &val3);
16262 if (!SWIG_IsOK(ecode3)) {
16263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16264 }
16265 arg3 = static_cast< int >(val3);
16266 {
16267 PyThreadState* __tstate = wxPyBeginAllowThreads();
16268 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16269 wxPyEndAllowThreads(__tstate);
16270 if (PyErr_Occurred()) SWIG_fail;
16271 }
16272 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16273 return resultobj;
16274 fail:
16275 return NULL;
16276 }
16277
16278
16279 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16280 PyObject *resultobj = 0;
16281 wxImage *arg1 = (wxImage *) 0 ;
16282 int arg2 ;
16283 SwigValueWrapper<wxImage > result;
16284 void *argp1 = 0 ;
16285 int res1 = 0 ;
16286 int val2 ;
16287 int ecode2 = 0 ;
16288 PyObject * obj0 = 0 ;
16289 PyObject * obj1 = 0 ;
16290 char * kwnames[] = {
16291 (char *) "self",(char *) "radius", NULL
16292 };
16293
16294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16296 if (!SWIG_IsOK(res1)) {
16297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16298 }
16299 arg1 = reinterpret_cast< wxImage * >(argp1);
16300 ecode2 = SWIG_AsVal_int(obj1, &val2);
16301 if (!SWIG_IsOK(ecode2)) {
16302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16303 }
16304 arg2 = static_cast< int >(val2);
16305 {
16306 PyThreadState* __tstate = wxPyBeginAllowThreads();
16307 result = (arg1)->Blur(arg2);
16308 wxPyEndAllowThreads(__tstate);
16309 if (PyErr_Occurred()) SWIG_fail;
16310 }
16311 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16312 return resultobj;
16313 fail:
16314 return NULL;
16315 }
16316
16317
16318 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16319 PyObject *resultobj = 0;
16320 wxImage *arg1 = (wxImage *) 0 ;
16321 int arg2 ;
16322 SwigValueWrapper<wxImage > result;
16323 void *argp1 = 0 ;
16324 int res1 = 0 ;
16325 int val2 ;
16326 int ecode2 = 0 ;
16327 PyObject * obj0 = 0 ;
16328 PyObject * obj1 = 0 ;
16329 char * kwnames[] = {
16330 (char *) "self",(char *) "radius", NULL
16331 };
16332
16333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16335 if (!SWIG_IsOK(res1)) {
16336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16337 }
16338 arg1 = reinterpret_cast< wxImage * >(argp1);
16339 ecode2 = SWIG_AsVal_int(obj1, &val2);
16340 if (!SWIG_IsOK(ecode2)) {
16341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16342 }
16343 arg2 = static_cast< int >(val2);
16344 {
16345 PyThreadState* __tstate = wxPyBeginAllowThreads();
16346 result = (arg1)->BlurHorizontal(arg2);
16347 wxPyEndAllowThreads(__tstate);
16348 if (PyErr_Occurred()) SWIG_fail;
16349 }
16350 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16351 return resultobj;
16352 fail:
16353 return NULL;
16354 }
16355
16356
16357 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16358 PyObject *resultobj = 0;
16359 wxImage *arg1 = (wxImage *) 0 ;
16360 int arg2 ;
16361 SwigValueWrapper<wxImage > result;
16362 void *argp1 = 0 ;
16363 int res1 = 0 ;
16364 int val2 ;
16365 int ecode2 = 0 ;
16366 PyObject * obj0 = 0 ;
16367 PyObject * obj1 = 0 ;
16368 char * kwnames[] = {
16369 (char *) "self",(char *) "radius", NULL
16370 };
16371
16372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16374 if (!SWIG_IsOK(res1)) {
16375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16376 }
16377 arg1 = reinterpret_cast< wxImage * >(argp1);
16378 ecode2 = SWIG_AsVal_int(obj1, &val2);
16379 if (!SWIG_IsOK(ecode2)) {
16380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16381 }
16382 arg2 = static_cast< int >(val2);
16383 {
16384 PyThreadState* __tstate = wxPyBeginAllowThreads();
16385 result = (arg1)->BlurVertical(arg2);
16386 wxPyEndAllowThreads(__tstate);
16387 if (PyErr_Occurred()) SWIG_fail;
16388 }
16389 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16390 return resultobj;
16391 fail:
16392 return NULL;
16393 }
16394
16395
16396 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16397 PyObject *resultobj = 0;
16398 wxImage *arg1 = (wxImage *) 0 ;
16399 int arg2 ;
16400 int arg3 ;
16401 SwigValueWrapper<wxImage > result;
16402 void *argp1 = 0 ;
16403 int res1 = 0 ;
16404 int val2 ;
16405 int ecode2 = 0 ;
16406 int val3 ;
16407 int ecode3 = 0 ;
16408 PyObject * obj0 = 0 ;
16409 PyObject * obj1 = 0 ;
16410 PyObject * obj2 = 0 ;
16411 char * kwnames[] = {
16412 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16413 };
16414
16415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16417 if (!SWIG_IsOK(res1)) {
16418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16419 }
16420 arg1 = reinterpret_cast< wxImage * >(argp1);
16421 ecode2 = SWIG_AsVal_int(obj1, &val2);
16422 if (!SWIG_IsOK(ecode2)) {
16423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16424 }
16425 arg2 = static_cast< int >(val2);
16426 ecode3 = SWIG_AsVal_int(obj2, &val3);
16427 if (!SWIG_IsOK(ecode3)) {
16428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16429 }
16430 arg3 = static_cast< int >(val3);
16431 {
16432 PyThreadState* __tstate = wxPyBeginAllowThreads();
16433 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16434 wxPyEndAllowThreads(__tstate);
16435 if (PyErr_Occurred()) SWIG_fail;
16436 }
16437 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16438 return resultobj;
16439 fail:
16440 return NULL;
16441 }
16442
16443
16444 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16445 PyObject *resultobj = 0;
16446 wxImage *arg1 = (wxImage *) 0 ;
16447 int arg2 ;
16448 int arg3 ;
16449 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16450 wxImage *result = 0 ;
16451 void *argp1 = 0 ;
16452 int res1 = 0 ;
16453 int val2 ;
16454 int ecode2 = 0 ;
16455 int val3 ;
16456 int ecode3 = 0 ;
16457 int val4 ;
16458 int ecode4 = 0 ;
16459 PyObject * obj0 = 0 ;
16460 PyObject * obj1 = 0 ;
16461 PyObject * obj2 = 0 ;
16462 PyObject * obj3 = 0 ;
16463 char * kwnames[] = {
16464 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16465 };
16466
16467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16469 if (!SWIG_IsOK(res1)) {
16470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16471 }
16472 arg1 = reinterpret_cast< wxImage * >(argp1);
16473 ecode2 = SWIG_AsVal_int(obj1, &val2);
16474 if (!SWIG_IsOK(ecode2)) {
16475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16476 }
16477 arg2 = static_cast< int >(val2);
16478 ecode3 = SWIG_AsVal_int(obj2, &val3);
16479 if (!SWIG_IsOK(ecode3)) {
16480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16481 }
16482 arg3 = static_cast< int >(val3);
16483 if (obj3) {
16484 ecode4 = SWIG_AsVal_int(obj3, &val4);
16485 if (!SWIG_IsOK(ecode4)) {
16486 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16487 }
16488 arg4 = static_cast< int >(val4);
16489 }
16490 {
16491 PyThreadState* __tstate = wxPyBeginAllowThreads();
16492 {
16493 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16494 result = (wxImage *) &_result_ref;
16495 }
16496 wxPyEndAllowThreads(__tstate);
16497 if (PyErr_Occurred()) SWIG_fail;
16498 }
16499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16500 return resultobj;
16501 fail:
16502 return NULL;
16503 }
16504
16505
16506 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16507 PyObject *resultobj = 0;
16508 wxImage *arg1 = (wxImage *) 0 ;
16509 wxSize *arg2 = 0 ;
16510 wxPoint *arg3 = 0 ;
16511 int arg4 = (int) -1 ;
16512 int arg5 = (int) -1 ;
16513 int arg6 = (int) -1 ;
16514 wxImage *result = 0 ;
16515 void *argp1 = 0 ;
16516 int res1 = 0 ;
16517 wxSize temp2 ;
16518 wxPoint temp3 ;
16519 int val4 ;
16520 int ecode4 = 0 ;
16521 int val5 ;
16522 int ecode5 = 0 ;
16523 int val6 ;
16524 int ecode6 = 0 ;
16525 PyObject * obj0 = 0 ;
16526 PyObject * obj1 = 0 ;
16527 PyObject * obj2 = 0 ;
16528 PyObject * obj3 = 0 ;
16529 PyObject * obj4 = 0 ;
16530 PyObject * obj5 = 0 ;
16531 char * kwnames[] = {
16532 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16533 };
16534
16535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16537 if (!SWIG_IsOK(res1)) {
16538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16539 }
16540 arg1 = reinterpret_cast< wxImage * >(argp1);
16541 {
16542 arg2 = &temp2;
16543 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16544 }
16545 {
16546 arg3 = &temp3;
16547 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16548 }
16549 if (obj3) {
16550 ecode4 = SWIG_AsVal_int(obj3, &val4);
16551 if (!SWIG_IsOK(ecode4)) {
16552 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16553 }
16554 arg4 = static_cast< int >(val4);
16555 }
16556 if (obj4) {
16557 ecode5 = SWIG_AsVal_int(obj4, &val5);
16558 if (!SWIG_IsOK(ecode5)) {
16559 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16560 }
16561 arg5 = static_cast< int >(val5);
16562 }
16563 if (obj5) {
16564 ecode6 = SWIG_AsVal_int(obj5, &val6);
16565 if (!SWIG_IsOK(ecode6)) {
16566 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16567 }
16568 arg6 = static_cast< int >(val6);
16569 }
16570 {
16571 PyThreadState* __tstate = wxPyBeginAllowThreads();
16572 {
16573 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16574 result = (wxImage *) &_result_ref;
16575 }
16576 wxPyEndAllowThreads(__tstate);
16577 if (PyErr_Occurred()) SWIG_fail;
16578 }
16579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16580 return resultobj;
16581 fail:
16582 return NULL;
16583 }
16584
16585
16586 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16587 PyObject *resultobj = 0;
16588 wxImage *arg1 = (wxImage *) 0 ;
16589 int arg2 ;
16590 int arg3 ;
16591 byte arg4 ;
16592 byte arg5 ;
16593 byte arg6 ;
16594 void *argp1 = 0 ;
16595 int res1 = 0 ;
16596 int val2 ;
16597 int ecode2 = 0 ;
16598 int val3 ;
16599 int ecode3 = 0 ;
16600 unsigned char val4 ;
16601 int ecode4 = 0 ;
16602 unsigned char val5 ;
16603 int ecode5 = 0 ;
16604 unsigned char val6 ;
16605 int ecode6 = 0 ;
16606 PyObject * obj0 = 0 ;
16607 PyObject * obj1 = 0 ;
16608 PyObject * obj2 = 0 ;
16609 PyObject * obj3 = 0 ;
16610 PyObject * obj4 = 0 ;
16611 PyObject * obj5 = 0 ;
16612 char * kwnames[] = {
16613 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16614 };
16615
16616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16618 if (!SWIG_IsOK(res1)) {
16619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16620 }
16621 arg1 = reinterpret_cast< wxImage * >(argp1);
16622 ecode2 = SWIG_AsVal_int(obj1, &val2);
16623 if (!SWIG_IsOK(ecode2)) {
16624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16625 }
16626 arg2 = static_cast< int >(val2);
16627 ecode3 = SWIG_AsVal_int(obj2, &val3);
16628 if (!SWIG_IsOK(ecode3)) {
16629 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16630 }
16631 arg3 = static_cast< int >(val3);
16632 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16633 if (!SWIG_IsOK(ecode4)) {
16634 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16635 }
16636 arg4 = static_cast< byte >(val4);
16637 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16638 if (!SWIG_IsOK(ecode5)) {
16639 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16640 }
16641 arg5 = static_cast< byte >(val5);
16642 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16643 if (!SWIG_IsOK(ecode6)) {
16644 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16645 }
16646 arg6 = static_cast< byte >(val6);
16647 {
16648 PyThreadState* __tstate = wxPyBeginAllowThreads();
16649 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16650 wxPyEndAllowThreads(__tstate);
16651 if (PyErr_Occurred()) SWIG_fail;
16652 }
16653 resultobj = SWIG_Py_Void();
16654 return resultobj;
16655 fail:
16656 return NULL;
16657 }
16658
16659
16660 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16661 PyObject *resultobj = 0;
16662 wxImage *arg1 = (wxImage *) 0 ;
16663 wxRect *arg2 = 0 ;
16664 byte arg3 ;
16665 byte arg4 ;
16666 byte arg5 ;
16667 void *argp1 = 0 ;
16668 int res1 = 0 ;
16669 wxRect temp2 ;
16670 unsigned char val3 ;
16671 int ecode3 = 0 ;
16672 unsigned char val4 ;
16673 int ecode4 = 0 ;
16674 unsigned char val5 ;
16675 int ecode5 = 0 ;
16676 PyObject * obj0 = 0 ;
16677 PyObject * obj1 = 0 ;
16678 PyObject * obj2 = 0 ;
16679 PyObject * obj3 = 0 ;
16680 PyObject * obj4 = 0 ;
16681 char * kwnames[] = {
16682 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16683 };
16684
16685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16687 if (!SWIG_IsOK(res1)) {
16688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16689 }
16690 arg1 = reinterpret_cast< wxImage * >(argp1);
16691 {
16692 arg2 = &temp2;
16693 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16694 }
16695 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16696 if (!SWIG_IsOK(ecode3)) {
16697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16698 }
16699 arg3 = static_cast< byte >(val3);
16700 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16701 if (!SWIG_IsOK(ecode4)) {
16702 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16703 }
16704 arg4 = static_cast< byte >(val4);
16705 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16706 if (!SWIG_IsOK(ecode5)) {
16707 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16708 }
16709 arg5 = static_cast< byte >(val5);
16710 {
16711 PyThreadState* __tstate = wxPyBeginAllowThreads();
16712 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16713 wxPyEndAllowThreads(__tstate);
16714 if (PyErr_Occurred()) SWIG_fail;
16715 }
16716 resultobj = SWIG_Py_Void();
16717 return resultobj;
16718 fail:
16719 return NULL;
16720 }
16721
16722
16723 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16724 PyObject *resultobj = 0;
16725 wxImage *arg1 = (wxImage *) 0 ;
16726 int arg2 ;
16727 int arg3 ;
16728 byte result;
16729 void *argp1 = 0 ;
16730 int res1 = 0 ;
16731 int val2 ;
16732 int ecode2 = 0 ;
16733 int val3 ;
16734 int ecode3 = 0 ;
16735 PyObject * obj0 = 0 ;
16736 PyObject * obj1 = 0 ;
16737 PyObject * obj2 = 0 ;
16738 char * kwnames[] = {
16739 (char *) "self",(char *) "x",(char *) "y", NULL
16740 };
16741
16742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16744 if (!SWIG_IsOK(res1)) {
16745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16746 }
16747 arg1 = reinterpret_cast< wxImage * >(argp1);
16748 ecode2 = SWIG_AsVal_int(obj1, &val2);
16749 if (!SWIG_IsOK(ecode2)) {
16750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16751 }
16752 arg2 = static_cast< int >(val2);
16753 ecode3 = SWIG_AsVal_int(obj2, &val3);
16754 if (!SWIG_IsOK(ecode3)) {
16755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16756 }
16757 arg3 = static_cast< int >(val3);
16758 {
16759 PyThreadState* __tstate = wxPyBeginAllowThreads();
16760 result = (byte)(arg1)->GetRed(arg2,arg3);
16761 wxPyEndAllowThreads(__tstate);
16762 if (PyErr_Occurred()) SWIG_fail;
16763 }
16764 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16765 return resultobj;
16766 fail:
16767 return NULL;
16768 }
16769
16770
16771 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16772 PyObject *resultobj = 0;
16773 wxImage *arg1 = (wxImage *) 0 ;
16774 int arg2 ;
16775 int arg3 ;
16776 byte result;
16777 void *argp1 = 0 ;
16778 int res1 = 0 ;
16779 int val2 ;
16780 int ecode2 = 0 ;
16781 int val3 ;
16782 int ecode3 = 0 ;
16783 PyObject * obj0 = 0 ;
16784 PyObject * obj1 = 0 ;
16785 PyObject * obj2 = 0 ;
16786 char * kwnames[] = {
16787 (char *) "self",(char *) "x",(char *) "y", NULL
16788 };
16789
16790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16792 if (!SWIG_IsOK(res1)) {
16793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16794 }
16795 arg1 = reinterpret_cast< wxImage * >(argp1);
16796 ecode2 = SWIG_AsVal_int(obj1, &val2);
16797 if (!SWIG_IsOK(ecode2)) {
16798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16799 }
16800 arg2 = static_cast< int >(val2);
16801 ecode3 = SWIG_AsVal_int(obj2, &val3);
16802 if (!SWIG_IsOK(ecode3)) {
16803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16804 }
16805 arg3 = static_cast< int >(val3);
16806 {
16807 PyThreadState* __tstate = wxPyBeginAllowThreads();
16808 result = (byte)(arg1)->GetGreen(arg2,arg3);
16809 wxPyEndAllowThreads(__tstate);
16810 if (PyErr_Occurred()) SWIG_fail;
16811 }
16812 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16813 return resultobj;
16814 fail:
16815 return NULL;
16816 }
16817
16818
16819 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16820 PyObject *resultobj = 0;
16821 wxImage *arg1 = (wxImage *) 0 ;
16822 int arg2 ;
16823 int arg3 ;
16824 byte result;
16825 void *argp1 = 0 ;
16826 int res1 = 0 ;
16827 int val2 ;
16828 int ecode2 = 0 ;
16829 int val3 ;
16830 int ecode3 = 0 ;
16831 PyObject * obj0 = 0 ;
16832 PyObject * obj1 = 0 ;
16833 PyObject * obj2 = 0 ;
16834 char * kwnames[] = {
16835 (char *) "self",(char *) "x",(char *) "y", NULL
16836 };
16837
16838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16840 if (!SWIG_IsOK(res1)) {
16841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16842 }
16843 arg1 = reinterpret_cast< wxImage * >(argp1);
16844 ecode2 = SWIG_AsVal_int(obj1, &val2);
16845 if (!SWIG_IsOK(ecode2)) {
16846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16847 }
16848 arg2 = static_cast< int >(val2);
16849 ecode3 = SWIG_AsVal_int(obj2, &val3);
16850 if (!SWIG_IsOK(ecode3)) {
16851 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16852 }
16853 arg3 = static_cast< int >(val3);
16854 {
16855 PyThreadState* __tstate = wxPyBeginAllowThreads();
16856 result = (byte)(arg1)->GetBlue(arg2,arg3);
16857 wxPyEndAllowThreads(__tstate);
16858 if (PyErr_Occurred()) SWIG_fail;
16859 }
16860 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16861 return resultobj;
16862 fail:
16863 return NULL;
16864 }
16865
16866
16867 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16868 PyObject *resultobj = 0;
16869 wxImage *arg1 = (wxImage *) 0 ;
16870 int arg2 ;
16871 int arg3 ;
16872 byte arg4 ;
16873 void *argp1 = 0 ;
16874 int res1 = 0 ;
16875 int val2 ;
16876 int ecode2 = 0 ;
16877 int val3 ;
16878 int ecode3 = 0 ;
16879 unsigned char val4 ;
16880 int ecode4 = 0 ;
16881 PyObject * obj0 = 0 ;
16882 PyObject * obj1 = 0 ;
16883 PyObject * obj2 = 0 ;
16884 PyObject * obj3 = 0 ;
16885 char * kwnames[] = {
16886 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16887 };
16888
16889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16891 if (!SWIG_IsOK(res1)) {
16892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16893 }
16894 arg1 = reinterpret_cast< wxImage * >(argp1);
16895 ecode2 = SWIG_AsVal_int(obj1, &val2);
16896 if (!SWIG_IsOK(ecode2)) {
16897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16898 }
16899 arg2 = static_cast< int >(val2);
16900 ecode3 = SWIG_AsVal_int(obj2, &val3);
16901 if (!SWIG_IsOK(ecode3)) {
16902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16903 }
16904 arg3 = static_cast< int >(val3);
16905 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16906 if (!SWIG_IsOK(ecode4)) {
16907 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16908 }
16909 arg4 = static_cast< byte >(val4);
16910 {
16911 PyThreadState* __tstate = wxPyBeginAllowThreads();
16912 (arg1)->SetAlpha(arg2,arg3,arg4);
16913 wxPyEndAllowThreads(__tstate);
16914 if (PyErr_Occurred()) SWIG_fail;
16915 }
16916 resultobj = SWIG_Py_Void();
16917 return resultobj;
16918 fail:
16919 return NULL;
16920 }
16921
16922
16923 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16924 PyObject *resultobj = 0;
16925 wxImage *arg1 = (wxImage *) 0 ;
16926 int arg2 ;
16927 int arg3 ;
16928 byte result;
16929 void *argp1 = 0 ;
16930 int res1 = 0 ;
16931 int val2 ;
16932 int ecode2 = 0 ;
16933 int val3 ;
16934 int ecode3 = 0 ;
16935 PyObject * obj0 = 0 ;
16936 PyObject * obj1 = 0 ;
16937 PyObject * obj2 = 0 ;
16938 char * kwnames[] = {
16939 (char *) "self",(char *) "x",(char *) "y", NULL
16940 };
16941
16942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16944 if (!SWIG_IsOK(res1)) {
16945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16946 }
16947 arg1 = reinterpret_cast< wxImage * >(argp1);
16948 ecode2 = SWIG_AsVal_int(obj1, &val2);
16949 if (!SWIG_IsOK(ecode2)) {
16950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16951 }
16952 arg2 = static_cast< int >(val2);
16953 ecode3 = SWIG_AsVal_int(obj2, &val3);
16954 if (!SWIG_IsOK(ecode3)) {
16955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16956 }
16957 arg3 = static_cast< int >(val3);
16958 {
16959 PyThreadState* __tstate = wxPyBeginAllowThreads();
16960 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16961 wxPyEndAllowThreads(__tstate);
16962 if (PyErr_Occurred()) SWIG_fail;
16963 }
16964 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16965 return resultobj;
16966 fail:
16967 return NULL;
16968 }
16969
16970
16971 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16972 PyObject *resultobj = 0;
16973 wxImage *arg1 = (wxImage *) 0 ;
16974 bool result;
16975 void *argp1 = 0 ;
16976 int res1 = 0 ;
16977 PyObject *swig_obj[1] ;
16978
16979 if (!args) SWIG_fail;
16980 swig_obj[0] = args;
16981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16982 if (!SWIG_IsOK(res1)) {
16983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16984 }
16985 arg1 = reinterpret_cast< wxImage * >(argp1);
16986 {
16987 PyThreadState* __tstate = wxPyBeginAllowThreads();
16988 result = (bool)(arg1)->HasAlpha();
16989 wxPyEndAllowThreads(__tstate);
16990 if (PyErr_Occurred()) SWIG_fail;
16991 }
16992 {
16993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16994 }
16995 return resultobj;
16996 fail:
16997 return NULL;
16998 }
16999
17000
17001 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17002 PyObject *resultobj = 0;
17003 wxImage *arg1 = (wxImage *) 0 ;
17004 void *argp1 = 0 ;
17005 int res1 = 0 ;
17006 PyObject *swig_obj[1] ;
17007
17008 if (!args) SWIG_fail;
17009 swig_obj[0] = args;
17010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17011 if (!SWIG_IsOK(res1)) {
17012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17013 }
17014 arg1 = reinterpret_cast< wxImage * >(argp1);
17015 {
17016 PyThreadState* __tstate = wxPyBeginAllowThreads();
17017 (arg1)->InitAlpha();
17018 wxPyEndAllowThreads(__tstate);
17019 if (PyErr_Occurred()) SWIG_fail;
17020 }
17021 resultobj = SWIG_Py_Void();
17022 return resultobj;
17023 fail:
17024 return NULL;
17025 }
17026
17027
17028 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17029 PyObject *resultobj = 0;
17030 wxImage *arg1 = (wxImage *) 0 ;
17031 int arg2 ;
17032 int arg3 ;
17033 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17034 bool result;
17035 void *argp1 = 0 ;
17036 int res1 = 0 ;
17037 int val2 ;
17038 int ecode2 = 0 ;
17039 int val3 ;
17040 int ecode3 = 0 ;
17041 unsigned char val4 ;
17042 int ecode4 = 0 ;
17043 PyObject * obj0 = 0 ;
17044 PyObject * obj1 = 0 ;
17045 PyObject * obj2 = 0 ;
17046 PyObject * obj3 = 0 ;
17047 char * kwnames[] = {
17048 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
17049 };
17050
17051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17053 if (!SWIG_IsOK(res1)) {
17054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
17055 }
17056 arg1 = reinterpret_cast< wxImage * >(argp1);
17057 ecode2 = SWIG_AsVal_int(obj1, &val2);
17058 if (!SWIG_IsOK(ecode2)) {
17059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
17060 }
17061 arg2 = static_cast< int >(val2);
17062 ecode3 = SWIG_AsVal_int(obj2, &val3);
17063 if (!SWIG_IsOK(ecode3)) {
17064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
17065 }
17066 arg3 = static_cast< int >(val3);
17067 if (obj3) {
17068 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17069 if (!SWIG_IsOK(ecode4)) {
17070 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
17071 }
17072 arg4 = static_cast< byte >(val4);
17073 }
17074 {
17075 PyThreadState* __tstate = wxPyBeginAllowThreads();
17076 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17077 wxPyEndAllowThreads(__tstate);
17078 if (PyErr_Occurred()) SWIG_fail;
17079 }
17080 {
17081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17082 }
17083 return resultobj;
17084 fail:
17085 return NULL;
17086 }
17087
17088
17089 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17090 PyObject *resultobj = 0;
17091 wxImage *arg1 = (wxImage *) 0 ;
17092 byte *arg2 = (byte *) 0 ;
17093 byte *arg3 = (byte *) 0 ;
17094 byte *arg4 = (byte *) 0 ;
17095 byte arg5 = (byte) 0 ;
17096 byte arg6 = (byte) 0 ;
17097 byte arg7 = (byte) 0 ;
17098 bool result;
17099 void *argp1 = 0 ;
17100 int res1 = 0 ;
17101 byte temp2 ;
17102 int res2 = SWIG_TMPOBJ ;
17103 byte temp3 ;
17104 int res3 = SWIG_TMPOBJ ;
17105 byte temp4 ;
17106 int res4 = SWIG_TMPOBJ ;
17107 unsigned char val5 ;
17108 int ecode5 = 0 ;
17109 unsigned char val6 ;
17110 int ecode6 = 0 ;
17111 unsigned char val7 ;
17112 int ecode7 = 0 ;
17113 PyObject * obj0 = 0 ;
17114 PyObject * obj1 = 0 ;
17115 PyObject * obj2 = 0 ;
17116 PyObject * obj3 = 0 ;
17117 char * kwnames[] = {
17118 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17119 };
17120
17121 arg2 = &temp2;
17122 arg3 = &temp3;
17123 arg4 = &temp4;
17124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17126 if (!SWIG_IsOK(res1)) {
17127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17128 }
17129 arg1 = reinterpret_cast< wxImage * >(argp1);
17130 if (obj1) {
17131 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17132 if (!SWIG_IsOK(ecode5)) {
17133 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17134 }
17135 arg5 = static_cast< byte >(val5);
17136 }
17137 if (obj2) {
17138 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17139 if (!SWIG_IsOK(ecode6)) {
17140 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17141 }
17142 arg6 = static_cast< byte >(val6);
17143 }
17144 if (obj3) {
17145 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17146 if (!SWIG_IsOK(ecode7)) {
17147 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17148 }
17149 arg7 = static_cast< byte >(val7);
17150 }
17151 {
17152 PyThreadState* __tstate = wxPyBeginAllowThreads();
17153 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17154 wxPyEndAllowThreads(__tstate);
17155 if (PyErr_Occurred()) SWIG_fail;
17156 }
17157 {
17158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17159 }
17160 if (SWIG_IsTmpObj(res2)) {
17161 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17162 } else {
17163 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17164 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17165 }
17166 if (SWIG_IsTmpObj(res3)) {
17167 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17168 } else {
17169 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17170 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17171 }
17172 if (SWIG_IsTmpObj(res4)) {
17173 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17174 } else {
17175 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17176 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17177 }
17178 return resultobj;
17179 fail:
17180 return NULL;
17181 }
17182
17183
17184 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17185 PyObject *resultobj = 0;
17186 wxImage *arg1 = (wxImage *) 0 ;
17187 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17188 bool result;
17189 void *argp1 = 0 ;
17190 int res1 = 0 ;
17191 unsigned char val2 ;
17192 int ecode2 = 0 ;
17193 PyObject * obj0 = 0 ;
17194 PyObject * obj1 = 0 ;
17195 char * kwnames[] = {
17196 (char *) "self",(char *) "threshold", NULL
17197 };
17198
17199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17201 if (!SWIG_IsOK(res1)) {
17202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17203 }
17204 arg1 = reinterpret_cast< wxImage * >(argp1);
17205 if (obj1) {
17206 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17207 if (!SWIG_IsOK(ecode2)) {
17208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17209 }
17210 arg2 = static_cast< byte >(val2);
17211 }
17212 {
17213 PyThreadState* __tstate = wxPyBeginAllowThreads();
17214 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17215 wxPyEndAllowThreads(__tstate);
17216 if (PyErr_Occurred()) SWIG_fail;
17217 }
17218 {
17219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17220 }
17221 return resultobj;
17222 fail:
17223 return NULL;
17224 }
17225
17226
17227 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17228 PyObject *resultobj = 0;
17229 wxImage *arg1 = (wxImage *) 0 ;
17230 byte arg2 ;
17231 byte arg3 ;
17232 byte arg4 ;
17233 bool result;
17234 void *argp1 = 0 ;
17235 int res1 = 0 ;
17236 unsigned char val2 ;
17237 int ecode2 = 0 ;
17238 unsigned char val3 ;
17239 int ecode3 = 0 ;
17240 unsigned char val4 ;
17241 int ecode4 = 0 ;
17242 PyObject * obj0 = 0 ;
17243 PyObject * obj1 = 0 ;
17244 PyObject * obj2 = 0 ;
17245 PyObject * obj3 = 0 ;
17246 char * kwnames[] = {
17247 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17248 };
17249
17250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17252 if (!SWIG_IsOK(res1)) {
17253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17254 }
17255 arg1 = reinterpret_cast< wxImage * >(argp1);
17256 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17257 if (!SWIG_IsOK(ecode2)) {
17258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17259 }
17260 arg2 = static_cast< byte >(val2);
17261 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17262 if (!SWIG_IsOK(ecode3)) {
17263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17264 }
17265 arg3 = static_cast< byte >(val3);
17266 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17267 if (!SWIG_IsOK(ecode4)) {
17268 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17269 }
17270 arg4 = static_cast< byte >(val4);
17271 {
17272 PyThreadState* __tstate = wxPyBeginAllowThreads();
17273 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17274 wxPyEndAllowThreads(__tstate);
17275 if (PyErr_Occurred()) SWIG_fail;
17276 }
17277 {
17278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17279 }
17280 return resultobj;
17281 fail:
17282 return NULL;
17283 }
17284
17285
17286 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17287 PyObject *resultobj = 0;
17288 wxImage *arg1 = (wxImage *) 0 ;
17289 wxImage *arg2 = 0 ;
17290 byte arg3 ;
17291 byte arg4 ;
17292 byte arg5 ;
17293 bool result;
17294 void *argp1 = 0 ;
17295 int res1 = 0 ;
17296 void *argp2 = 0 ;
17297 int res2 = 0 ;
17298 unsigned char val3 ;
17299 int ecode3 = 0 ;
17300 unsigned char val4 ;
17301 int ecode4 = 0 ;
17302 unsigned char val5 ;
17303 int ecode5 = 0 ;
17304 PyObject * obj0 = 0 ;
17305 PyObject * obj1 = 0 ;
17306 PyObject * obj2 = 0 ;
17307 PyObject * obj3 = 0 ;
17308 PyObject * obj4 = 0 ;
17309 char * kwnames[] = {
17310 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17311 };
17312
17313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17315 if (!SWIG_IsOK(res1)) {
17316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17317 }
17318 arg1 = reinterpret_cast< wxImage * >(argp1);
17319 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17320 if (!SWIG_IsOK(res2)) {
17321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17322 }
17323 if (!argp2) {
17324 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17325 }
17326 arg2 = reinterpret_cast< wxImage * >(argp2);
17327 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17328 if (!SWIG_IsOK(ecode3)) {
17329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17330 }
17331 arg3 = static_cast< byte >(val3);
17332 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17333 if (!SWIG_IsOK(ecode4)) {
17334 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17335 }
17336 arg4 = static_cast< byte >(val4);
17337 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17338 if (!SWIG_IsOK(ecode5)) {
17339 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17340 }
17341 arg5 = static_cast< byte >(val5);
17342 {
17343 PyThreadState* __tstate = wxPyBeginAllowThreads();
17344 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17345 wxPyEndAllowThreads(__tstate);
17346 if (PyErr_Occurred()) SWIG_fail;
17347 }
17348 {
17349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17350 }
17351 return resultobj;
17352 fail:
17353 return NULL;
17354 }
17355
17356
17357 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17358 PyObject *resultobj = 0;
17359 wxString *arg1 = 0 ;
17360 bool result;
17361 bool temp1 = false ;
17362 PyObject * obj0 = 0 ;
17363 char * kwnames[] = {
17364 (char *) "filename", NULL
17365 };
17366
17367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17368 {
17369 arg1 = wxString_in_helper(obj0);
17370 if (arg1 == NULL) SWIG_fail;
17371 temp1 = true;
17372 }
17373 {
17374 PyThreadState* __tstate = wxPyBeginAllowThreads();
17375 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17376 wxPyEndAllowThreads(__tstate);
17377 if (PyErr_Occurred()) SWIG_fail;
17378 }
17379 {
17380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17381 }
17382 {
17383 if (temp1)
17384 delete arg1;
17385 }
17386 return resultobj;
17387 fail:
17388 {
17389 if (temp1)
17390 delete arg1;
17391 }
17392 return NULL;
17393 }
17394
17395
17396 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17397 PyObject *resultobj = 0;
17398 wxString *arg1 = 0 ;
17399 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17400 int result;
17401 bool temp1 = false ;
17402 long val2 ;
17403 int ecode2 = 0 ;
17404 PyObject * obj0 = 0 ;
17405 PyObject * obj1 = 0 ;
17406 char * kwnames[] = {
17407 (char *) "filename",(char *) "type", NULL
17408 };
17409
17410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17411 {
17412 arg1 = wxString_in_helper(obj0);
17413 if (arg1 == NULL) SWIG_fail;
17414 temp1 = true;
17415 }
17416 if (obj1) {
17417 ecode2 = SWIG_AsVal_long(obj1, &val2);
17418 if (!SWIG_IsOK(ecode2)) {
17419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17420 }
17421 arg2 = static_cast< long >(val2);
17422 }
17423 {
17424 PyThreadState* __tstate = wxPyBeginAllowThreads();
17425 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17426 wxPyEndAllowThreads(__tstate);
17427 if (PyErr_Occurred()) SWIG_fail;
17428 }
17429 resultobj = SWIG_From_int(static_cast< int >(result));
17430 {
17431 if (temp1)
17432 delete arg1;
17433 }
17434 return resultobj;
17435 fail:
17436 {
17437 if (temp1)
17438 delete arg1;
17439 }
17440 return NULL;
17441 }
17442
17443
17444 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17445 PyObject *resultobj = 0;
17446 wxImage *arg1 = (wxImage *) 0 ;
17447 wxString *arg2 = 0 ;
17448 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17449 int arg4 = (int) -1 ;
17450 bool result;
17451 void *argp1 = 0 ;
17452 int res1 = 0 ;
17453 bool temp2 = false ;
17454 long val3 ;
17455 int ecode3 = 0 ;
17456 int val4 ;
17457 int ecode4 = 0 ;
17458 PyObject * obj0 = 0 ;
17459 PyObject * obj1 = 0 ;
17460 PyObject * obj2 = 0 ;
17461 PyObject * obj3 = 0 ;
17462 char * kwnames[] = {
17463 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17464 };
17465
17466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17468 if (!SWIG_IsOK(res1)) {
17469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17470 }
17471 arg1 = reinterpret_cast< wxImage * >(argp1);
17472 {
17473 arg2 = wxString_in_helper(obj1);
17474 if (arg2 == NULL) SWIG_fail;
17475 temp2 = true;
17476 }
17477 if (obj2) {
17478 ecode3 = SWIG_AsVal_long(obj2, &val3);
17479 if (!SWIG_IsOK(ecode3)) {
17480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17481 }
17482 arg3 = static_cast< long >(val3);
17483 }
17484 if (obj3) {
17485 ecode4 = SWIG_AsVal_int(obj3, &val4);
17486 if (!SWIG_IsOK(ecode4)) {
17487 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17488 }
17489 arg4 = static_cast< int >(val4);
17490 }
17491 {
17492 PyThreadState* __tstate = wxPyBeginAllowThreads();
17493 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17494 wxPyEndAllowThreads(__tstate);
17495 if (PyErr_Occurred()) SWIG_fail;
17496 }
17497 {
17498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17499 }
17500 {
17501 if (temp2)
17502 delete arg2;
17503 }
17504 return resultobj;
17505 fail:
17506 {
17507 if (temp2)
17508 delete arg2;
17509 }
17510 return NULL;
17511 }
17512
17513
17514 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17515 PyObject *resultobj = 0;
17516 wxImage *arg1 = (wxImage *) 0 ;
17517 wxString *arg2 = 0 ;
17518 wxString *arg3 = 0 ;
17519 int arg4 = (int) -1 ;
17520 bool result;
17521 void *argp1 = 0 ;
17522 int res1 = 0 ;
17523 bool temp2 = false ;
17524 bool temp3 = false ;
17525 int val4 ;
17526 int ecode4 = 0 ;
17527 PyObject * obj0 = 0 ;
17528 PyObject * obj1 = 0 ;
17529 PyObject * obj2 = 0 ;
17530 PyObject * obj3 = 0 ;
17531 char * kwnames[] = {
17532 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17533 };
17534
17535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17537 if (!SWIG_IsOK(res1)) {
17538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17539 }
17540 arg1 = reinterpret_cast< wxImage * >(argp1);
17541 {
17542 arg2 = wxString_in_helper(obj1);
17543 if (arg2 == NULL) SWIG_fail;
17544 temp2 = true;
17545 }
17546 {
17547 arg3 = wxString_in_helper(obj2);
17548 if (arg3 == NULL) SWIG_fail;
17549 temp3 = true;
17550 }
17551 if (obj3) {
17552 ecode4 = SWIG_AsVal_int(obj3, &val4);
17553 if (!SWIG_IsOK(ecode4)) {
17554 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17555 }
17556 arg4 = static_cast< int >(val4);
17557 }
17558 {
17559 PyThreadState* __tstate = wxPyBeginAllowThreads();
17560 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17561 wxPyEndAllowThreads(__tstate);
17562 if (PyErr_Occurred()) SWIG_fail;
17563 }
17564 {
17565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17566 }
17567 {
17568 if (temp2)
17569 delete arg2;
17570 }
17571 {
17572 if (temp3)
17573 delete arg3;
17574 }
17575 return resultobj;
17576 fail:
17577 {
17578 if (temp2)
17579 delete arg2;
17580 }
17581 {
17582 if (temp3)
17583 delete arg3;
17584 }
17585 return NULL;
17586 }
17587
17588
17589 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17590 PyObject *resultobj = 0;
17591 wxImage *arg1 = (wxImage *) 0 ;
17592 wxString *arg2 = 0 ;
17593 int arg3 ;
17594 bool result;
17595 void *argp1 = 0 ;
17596 int res1 = 0 ;
17597 bool temp2 = false ;
17598 int val3 ;
17599 int ecode3 = 0 ;
17600 PyObject * obj0 = 0 ;
17601 PyObject * obj1 = 0 ;
17602 PyObject * obj2 = 0 ;
17603 char * kwnames[] = {
17604 (char *) "self",(char *) "name",(char *) "type", NULL
17605 };
17606
17607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17609 if (!SWIG_IsOK(res1)) {
17610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17611 }
17612 arg1 = reinterpret_cast< wxImage * >(argp1);
17613 {
17614 arg2 = wxString_in_helper(obj1);
17615 if (arg2 == NULL) SWIG_fail;
17616 temp2 = true;
17617 }
17618 ecode3 = SWIG_AsVal_int(obj2, &val3);
17619 if (!SWIG_IsOK(ecode3)) {
17620 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17621 }
17622 arg3 = static_cast< int >(val3);
17623 {
17624 PyThreadState* __tstate = wxPyBeginAllowThreads();
17625 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17626 wxPyEndAllowThreads(__tstate);
17627 if (PyErr_Occurred()) SWIG_fail;
17628 }
17629 {
17630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17631 }
17632 {
17633 if (temp2)
17634 delete arg2;
17635 }
17636 return resultobj;
17637 fail:
17638 {
17639 if (temp2)
17640 delete arg2;
17641 }
17642 return NULL;
17643 }
17644
17645
17646 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17647 PyObject *resultobj = 0;
17648 wxImage *arg1 = (wxImage *) 0 ;
17649 wxString *arg2 = 0 ;
17650 wxString *arg3 = 0 ;
17651 bool result;
17652 void *argp1 = 0 ;
17653 int res1 = 0 ;
17654 bool temp2 = false ;
17655 bool temp3 = false ;
17656 PyObject * obj0 = 0 ;
17657 PyObject * obj1 = 0 ;
17658 PyObject * obj2 = 0 ;
17659 char * kwnames[] = {
17660 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17661 };
17662
17663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17665 if (!SWIG_IsOK(res1)) {
17666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17667 }
17668 arg1 = reinterpret_cast< wxImage * >(argp1);
17669 {
17670 arg2 = wxString_in_helper(obj1);
17671 if (arg2 == NULL) SWIG_fail;
17672 temp2 = true;
17673 }
17674 {
17675 arg3 = wxString_in_helper(obj2);
17676 if (arg3 == NULL) SWIG_fail;
17677 temp3 = true;
17678 }
17679 {
17680 PyThreadState* __tstate = wxPyBeginAllowThreads();
17681 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17682 wxPyEndAllowThreads(__tstate);
17683 if (PyErr_Occurred()) SWIG_fail;
17684 }
17685 {
17686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17687 }
17688 {
17689 if (temp2)
17690 delete arg2;
17691 }
17692 {
17693 if (temp3)
17694 delete arg3;
17695 }
17696 return resultobj;
17697 fail:
17698 {
17699 if (temp2)
17700 delete arg2;
17701 }
17702 {
17703 if (temp3)
17704 delete arg3;
17705 }
17706 return NULL;
17707 }
17708
17709
17710 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17711 PyObject *resultobj = 0;
17712 wxInputStream *arg1 = 0 ;
17713 bool result;
17714 wxPyInputStream *temp1 ;
17715 bool created1 ;
17716 PyObject * obj0 = 0 ;
17717 char * kwnames[] = {
17718 (char *) "stream", NULL
17719 };
17720
17721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17722 {
17723 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17724 arg1 = temp1->m_wxis;
17725 created1 = false;
17726 } else {
17727 PyErr_Clear(); // clear the failure of the wxPyConvert above
17728 arg1 = wxPyCBInputStream_create(obj0, false);
17729 if (arg1 == NULL) {
17730 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17731 SWIG_fail;
17732 }
17733 created1 = true;
17734 }
17735 }
17736 {
17737 PyThreadState* __tstate = wxPyBeginAllowThreads();
17738 result = (bool)wxImage::CanRead(*arg1);
17739 wxPyEndAllowThreads(__tstate);
17740 if (PyErr_Occurred()) SWIG_fail;
17741 }
17742 {
17743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17744 }
17745 {
17746 if (created1) delete arg1;
17747 }
17748 return resultobj;
17749 fail:
17750 {
17751 if (created1) delete arg1;
17752 }
17753 return NULL;
17754 }
17755
17756
17757 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17758 PyObject *resultobj = 0;
17759 wxImage *arg1 = (wxImage *) 0 ;
17760 wxInputStream *arg2 = 0 ;
17761 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17762 int arg4 = (int) -1 ;
17763 bool result;
17764 void *argp1 = 0 ;
17765 int res1 = 0 ;
17766 wxPyInputStream *temp2 ;
17767 bool created2 ;
17768 long val3 ;
17769 int ecode3 = 0 ;
17770 int val4 ;
17771 int ecode4 = 0 ;
17772 PyObject * obj0 = 0 ;
17773 PyObject * obj1 = 0 ;
17774 PyObject * obj2 = 0 ;
17775 PyObject * obj3 = 0 ;
17776 char * kwnames[] = {
17777 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17778 };
17779
17780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17782 if (!SWIG_IsOK(res1)) {
17783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17784 }
17785 arg1 = reinterpret_cast< wxImage * >(argp1);
17786 {
17787 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17788 arg2 = temp2->m_wxis;
17789 created2 = false;
17790 } else {
17791 PyErr_Clear(); // clear the failure of the wxPyConvert above
17792 arg2 = wxPyCBInputStream_create(obj1, false);
17793 if (arg2 == NULL) {
17794 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17795 SWIG_fail;
17796 }
17797 created2 = true;
17798 }
17799 }
17800 if (obj2) {
17801 ecode3 = SWIG_AsVal_long(obj2, &val3);
17802 if (!SWIG_IsOK(ecode3)) {
17803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17804 }
17805 arg3 = static_cast< long >(val3);
17806 }
17807 if (obj3) {
17808 ecode4 = SWIG_AsVal_int(obj3, &val4);
17809 if (!SWIG_IsOK(ecode4)) {
17810 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17811 }
17812 arg4 = static_cast< int >(val4);
17813 }
17814 {
17815 PyThreadState* __tstate = wxPyBeginAllowThreads();
17816 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17817 wxPyEndAllowThreads(__tstate);
17818 if (PyErr_Occurred()) SWIG_fail;
17819 }
17820 {
17821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17822 }
17823 {
17824 if (created2) delete arg2;
17825 }
17826 return resultobj;
17827 fail:
17828 {
17829 if (created2) delete arg2;
17830 }
17831 return NULL;
17832 }
17833
17834
17835 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17836 PyObject *resultobj = 0;
17837 wxImage *arg1 = (wxImage *) 0 ;
17838 wxInputStream *arg2 = 0 ;
17839 wxString *arg3 = 0 ;
17840 int arg4 = (int) -1 ;
17841 bool result;
17842 void *argp1 = 0 ;
17843 int res1 = 0 ;
17844 wxPyInputStream *temp2 ;
17845 bool created2 ;
17846 bool temp3 = false ;
17847 int val4 ;
17848 int ecode4 = 0 ;
17849 PyObject * obj0 = 0 ;
17850 PyObject * obj1 = 0 ;
17851 PyObject * obj2 = 0 ;
17852 PyObject * obj3 = 0 ;
17853 char * kwnames[] = {
17854 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17855 };
17856
17857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17859 if (!SWIG_IsOK(res1)) {
17860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17861 }
17862 arg1 = reinterpret_cast< wxImage * >(argp1);
17863 {
17864 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17865 arg2 = temp2->m_wxis;
17866 created2 = false;
17867 } else {
17868 PyErr_Clear(); // clear the failure of the wxPyConvert above
17869 arg2 = wxPyCBInputStream_create(obj1, false);
17870 if (arg2 == NULL) {
17871 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17872 SWIG_fail;
17873 }
17874 created2 = true;
17875 }
17876 }
17877 {
17878 arg3 = wxString_in_helper(obj2);
17879 if (arg3 == NULL) SWIG_fail;
17880 temp3 = true;
17881 }
17882 if (obj3) {
17883 ecode4 = SWIG_AsVal_int(obj3, &val4);
17884 if (!SWIG_IsOK(ecode4)) {
17885 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17886 }
17887 arg4 = static_cast< int >(val4);
17888 }
17889 {
17890 PyThreadState* __tstate = wxPyBeginAllowThreads();
17891 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17892 wxPyEndAllowThreads(__tstate);
17893 if (PyErr_Occurred()) SWIG_fail;
17894 }
17895 {
17896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17897 }
17898 {
17899 if (created2) delete arg2;
17900 }
17901 {
17902 if (temp3)
17903 delete arg3;
17904 }
17905 return resultobj;
17906 fail:
17907 {
17908 if (created2) delete arg2;
17909 }
17910 {
17911 if (temp3)
17912 delete arg3;
17913 }
17914 return NULL;
17915 }
17916
17917
17918 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17919 PyObject *resultobj = 0;
17920 wxImage *arg1 = (wxImage *) 0 ;
17921 bool result;
17922 void *argp1 = 0 ;
17923 int res1 = 0 ;
17924 PyObject *swig_obj[1] ;
17925
17926 if (!args) SWIG_fail;
17927 swig_obj[0] = args;
17928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17929 if (!SWIG_IsOK(res1)) {
17930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17931 }
17932 arg1 = reinterpret_cast< wxImage * >(argp1);
17933 {
17934 PyThreadState* __tstate = wxPyBeginAllowThreads();
17935 result = (bool)(arg1)->IsOk();
17936 wxPyEndAllowThreads(__tstate);
17937 if (PyErr_Occurred()) SWIG_fail;
17938 }
17939 {
17940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17941 }
17942 return resultobj;
17943 fail:
17944 return NULL;
17945 }
17946
17947
17948 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17949 PyObject *resultobj = 0;
17950 wxImage *arg1 = (wxImage *) 0 ;
17951 int result;
17952 void *argp1 = 0 ;
17953 int res1 = 0 ;
17954 PyObject *swig_obj[1] ;
17955
17956 if (!args) SWIG_fail;
17957 swig_obj[0] = args;
17958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17959 if (!SWIG_IsOK(res1)) {
17960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17961 }
17962 arg1 = reinterpret_cast< wxImage * >(argp1);
17963 {
17964 PyThreadState* __tstate = wxPyBeginAllowThreads();
17965 result = (int)(arg1)->GetWidth();
17966 wxPyEndAllowThreads(__tstate);
17967 if (PyErr_Occurred()) SWIG_fail;
17968 }
17969 resultobj = SWIG_From_int(static_cast< int >(result));
17970 return resultobj;
17971 fail:
17972 return NULL;
17973 }
17974
17975
17976 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17977 PyObject *resultobj = 0;
17978 wxImage *arg1 = (wxImage *) 0 ;
17979 int result;
17980 void *argp1 = 0 ;
17981 int res1 = 0 ;
17982 PyObject *swig_obj[1] ;
17983
17984 if (!args) SWIG_fail;
17985 swig_obj[0] = args;
17986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17987 if (!SWIG_IsOK(res1)) {
17988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17989 }
17990 arg1 = reinterpret_cast< wxImage * >(argp1);
17991 {
17992 PyThreadState* __tstate = wxPyBeginAllowThreads();
17993 result = (int)(arg1)->GetHeight();
17994 wxPyEndAllowThreads(__tstate);
17995 if (PyErr_Occurred()) SWIG_fail;
17996 }
17997 resultobj = SWIG_From_int(static_cast< int >(result));
17998 return resultobj;
17999 fail:
18000 return NULL;
18001 }
18002
18003
18004 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18005 PyObject *resultobj = 0;
18006 wxImage *arg1 = (wxImage *) 0 ;
18007 wxSize result;
18008 void *argp1 = 0 ;
18009 int res1 = 0 ;
18010 PyObject *swig_obj[1] ;
18011
18012 if (!args) SWIG_fail;
18013 swig_obj[0] = args;
18014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18015 if (!SWIG_IsOK(res1)) {
18016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
18017 }
18018 arg1 = reinterpret_cast< wxImage * >(argp1);
18019 {
18020 PyThreadState* __tstate = wxPyBeginAllowThreads();
18021 result = wxImage_GetSize(arg1);
18022 wxPyEndAllowThreads(__tstate);
18023 if (PyErr_Occurred()) SWIG_fail;
18024 }
18025 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
18026 return resultobj;
18027 fail:
18028 return NULL;
18029 }
18030
18031
18032 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18033 PyObject *resultobj = 0;
18034 wxImage *arg1 = (wxImage *) 0 ;
18035 wxRect *arg2 = 0 ;
18036 SwigValueWrapper<wxImage > result;
18037 void *argp1 = 0 ;
18038 int res1 = 0 ;
18039 wxRect temp2 ;
18040 PyObject * obj0 = 0 ;
18041 PyObject * obj1 = 0 ;
18042 char * kwnames[] = {
18043 (char *) "self",(char *) "rect", NULL
18044 };
18045
18046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
18047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18048 if (!SWIG_IsOK(res1)) {
18049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
18050 }
18051 arg1 = reinterpret_cast< wxImage * >(argp1);
18052 {
18053 arg2 = &temp2;
18054 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18055 }
18056 {
18057 PyThreadState* __tstate = wxPyBeginAllowThreads();
18058 result = (arg1)->GetSubImage((wxRect const &)*arg2);
18059 wxPyEndAllowThreads(__tstate);
18060 if (PyErr_Occurred()) SWIG_fail;
18061 }
18062 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18063 return resultobj;
18064 fail:
18065 return NULL;
18066 }
18067
18068
18069 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18070 PyObject *resultobj = 0;
18071 wxImage *arg1 = (wxImage *) 0 ;
18072 wxSize *arg2 = 0 ;
18073 wxPoint *arg3 = 0 ;
18074 int arg4 = (int) -1 ;
18075 int arg5 = (int) -1 ;
18076 int arg6 = (int) -1 ;
18077 SwigValueWrapper<wxImage > result;
18078 void *argp1 = 0 ;
18079 int res1 = 0 ;
18080 wxSize temp2 ;
18081 wxPoint temp3 ;
18082 int val4 ;
18083 int ecode4 = 0 ;
18084 int val5 ;
18085 int ecode5 = 0 ;
18086 int val6 ;
18087 int ecode6 = 0 ;
18088 PyObject * obj0 = 0 ;
18089 PyObject * obj1 = 0 ;
18090 PyObject * obj2 = 0 ;
18091 PyObject * obj3 = 0 ;
18092 PyObject * obj4 = 0 ;
18093 PyObject * obj5 = 0 ;
18094 char * kwnames[] = {
18095 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18096 };
18097
18098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18100 if (!SWIG_IsOK(res1)) {
18101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18102 }
18103 arg1 = reinterpret_cast< wxImage * >(argp1);
18104 {
18105 arg2 = &temp2;
18106 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18107 }
18108 {
18109 arg3 = &temp3;
18110 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18111 }
18112 if (obj3) {
18113 ecode4 = SWIG_AsVal_int(obj3, &val4);
18114 if (!SWIG_IsOK(ecode4)) {
18115 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18116 }
18117 arg4 = static_cast< int >(val4);
18118 }
18119 if (obj4) {
18120 ecode5 = SWIG_AsVal_int(obj4, &val5);
18121 if (!SWIG_IsOK(ecode5)) {
18122 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18123 }
18124 arg5 = static_cast< int >(val5);
18125 }
18126 if (obj5) {
18127 ecode6 = SWIG_AsVal_int(obj5, &val6);
18128 if (!SWIG_IsOK(ecode6)) {
18129 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18130 }
18131 arg6 = static_cast< int >(val6);
18132 }
18133 {
18134 PyThreadState* __tstate = wxPyBeginAllowThreads();
18135 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18136 wxPyEndAllowThreads(__tstate);
18137 if (PyErr_Occurred()) SWIG_fail;
18138 }
18139 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18140 return resultobj;
18141 fail:
18142 return NULL;
18143 }
18144
18145
18146 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18147 PyObject *resultobj = 0;
18148 wxImage *arg1 = (wxImage *) 0 ;
18149 SwigValueWrapper<wxImage > result;
18150 void *argp1 = 0 ;
18151 int res1 = 0 ;
18152 PyObject *swig_obj[1] ;
18153
18154 if (!args) SWIG_fail;
18155 swig_obj[0] = args;
18156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18157 if (!SWIG_IsOK(res1)) {
18158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18159 }
18160 arg1 = reinterpret_cast< wxImage * >(argp1);
18161 {
18162 PyThreadState* __tstate = wxPyBeginAllowThreads();
18163 result = (arg1)->Copy();
18164 wxPyEndAllowThreads(__tstate);
18165 if (PyErr_Occurred()) SWIG_fail;
18166 }
18167 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18168 return resultobj;
18169 fail:
18170 return NULL;
18171 }
18172
18173
18174 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18175 PyObject *resultobj = 0;
18176 wxImage *arg1 = (wxImage *) 0 ;
18177 wxImage *arg2 = 0 ;
18178 int arg3 ;
18179 int arg4 ;
18180 void *argp1 = 0 ;
18181 int res1 = 0 ;
18182 void *argp2 = 0 ;
18183 int res2 = 0 ;
18184 int val3 ;
18185 int ecode3 = 0 ;
18186 int val4 ;
18187 int ecode4 = 0 ;
18188 PyObject * obj0 = 0 ;
18189 PyObject * obj1 = 0 ;
18190 PyObject * obj2 = 0 ;
18191 PyObject * obj3 = 0 ;
18192 char * kwnames[] = {
18193 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18194 };
18195
18196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18198 if (!SWIG_IsOK(res1)) {
18199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18200 }
18201 arg1 = reinterpret_cast< wxImage * >(argp1);
18202 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18203 if (!SWIG_IsOK(res2)) {
18204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18205 }
18206 if (!argp2) {
18207 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18208 }
18209 arg2 = reinterpret_cast< wxImage * >(argp2);
18210 ecode3 = SWIG_AsVal_int(obj2, &val3);
18211 if (!SWIG_IsOK(ecode3)) {
18212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18213 }
18214 arg3 = static_cast< int >(val3);
18215 ecode4 = SWIG_AsVal_int(obj3, &val4);
18216 if (!SWIG_IsOK(ecode4)) {
18217 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18218 }
18219 arg4 = static_cast< int >(val4);
18220 {
18221 PyThreadState* __tstate = wxPyBeginAllowThreads();
18222 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18223 wxPyEndAllowThreads(__tstate);
18224 if (PyErr_Occurred()) SWIG_fail;
18225 }
18226 resultobj = SWIG_Py_Void();
18227 return resultobj;
18228 fail:
18229 return NULL;
18230 }
18231
18232
18233 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18234 PyObject *resultobj = 0;
18235 wxImage *arg1 = (wxImage *) 0 ;
18236 PyObject *result = 0 ;
18237 void *argp1 = 0 ;
18238 int res1 = 0 ;
18239 PyObject *swig_obj[1] ;
18240
18241 if (!args) SWIG_fail;
18242 swig_obj[0] = args;
18243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18244 if (!SWIG_IsOK(res1)) {
18245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18246 }
18247 arg1 = reinterpret_cast< wxImage * >(argp1);
18248 {
18249 PyThreadState* __tstate = wxPyBeginAllowThreads();
18250 result = (PyObject *)wxImage_GetData(arg1);
18251 wxPyEndAllowThreads(__tstate);
18252 if (PyErr_Occurred()) SWIG_fail;
18253 }
18254 resultobj = result;
18255 return resultobj;
18256 fail:
18257 return NULL;
18258 }
18259
18260
18261 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18262 PyObject *resultobj = 0;
18263 wxImage *arg1 = (wxImage *) 0 ;
18264 buffer arg2 ;
18265 int arg3 ;
18266 void *argp1 = 0 ;
18267 int res1 = 0 ;
18268 Py_ssize_t temp2 ;
18269 PyObject * obj0 = 0 ;
18270 PyObject * obj1 = 0 ;
18271 char * kwnames[] = {
18272 (char *) "self",(char *) "data", NULL
18273 };
18274
18275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18277 if (!SWIG_IsOK(res1)) {
18278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18279 }
18280 arg1 = reinterpret_cast< wxImage * >(argp1);
18281 {
18282 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18283 arg3 = (int)temp2;
18284 }
18285 {
18286 PyThreadState* __tstate = wxPyBeginAllowThreads();
18287 wxImage_SetData(arg1,arg2,arg3);
18288 wxPyEndAllowThreads(__tstate);
18289 if (PyErr_Occurred()) SWIG_fail;
18290 }
18291 resultobj = SWIG_Py_Void();
18292 return resultobj;
18293 fail:
18294 return NULL;
18295 }
18296
18297
18298 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18299 PyObject *resultobj = 0;
18300 wxImage *arg1 = (wxImage *) 0 ;
18301 PyObject *result = 0 ;
18302 void *argp1 = 0 ;
18303 int res1 = 0 ;
18304 PyObject *swig_obj[1] ;
18305
18306 if (!args) SWIG_fail;
18307 swig_obj[0] = args;
18308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18309 if (!SWIG_IsOK(res1)) {
18310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18311 }
18312 arg1 = reinterpret_cast< wxImage * >(argp1);
18313 {
18314 PyThreadState* __tstate = wxPyBeginAllowThreads();
18315 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18316 wxPyEndAllowThreads(__tstate);
18317 if (PyErr_Occurred()) SWIG_fail;
18318 }
18319 resultobj = result;
18320 return resultobj;
18321 fail:
18322 return NULL;
18323 }
18324
18325
18326 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18327 PyObject *resultobj = 0;
18328 wxImage *arg1 = (wxImage *) 0 ;
18329 buffer arg2 ;
18330 int arg3 ;
18331 void *argp1 = 0 ;
18332 int res1 = 0 ;
18333 Py_ssize_t temp2 ;
18334 PyObject * obj0 = 0 ;
18335 PyObject * obj1 = 0 ;
18336 char * kwnames[] = {
18337 (char *) "self",(char *) "data", NULL
18338 };
18339
18340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18342 if (!SWIG_IsOK(res1)) {
18343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18344 }
18345 arg1 = reinterpret_cast< wxImage * >(argp1);
18346 {
18347 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18348 arg3 = (int)temp2;
18349 }
18350 {
18351 PyThreadState* __tstate = wxPyBeginAllowThreads();
18352 wxImage_SetDataBuffer(arg1,arg2,arg3);
18353 wxPyEndAllowThreads(__tstate);
18354 if (PyErr_Occurred()) SWIG_fail;
18355 }
18356 resultobj = SWIG_Py_Void();
18357 return resultobj;
18358 fail:
18359 return NULL;
18360 }
18361
18362
18363 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18364 PyObject *resultobj = 0;
18365 wxImage *arg1 = (wxImage *) 0 ;
18366 PyObject *result = 0 ;
18367 void *argp1 = 0 ;
18368 int res1 = 0 ;
18369 PyObject *swig_obj[1] ;
18370
18371 if (!args) SWIG_fail;
18372 swig_obj[0] = args;
18373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18374 if (!SWIG_IsOK(res1)) {
18375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18376 }
18377 arg1 = reinterpret_cast< wxImage * >(argp1);
18378 {
18379 PyThreadState* __tstate = wxPyBeginAllowThreads();
18380 result = (PyObject *)wxImage_GetAlphaData(arg1);
18381 wxPyEndAllowThreads(__tstate);
18382 if (PyErr_Occurred()) SWIG_fail;
18383 }
18384 resultobj = result;
18385 return resultobj;
18386 fail:
18387 return NULL;
18388 }
18389
18390
18391 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18392 PyObject *resultobj = 0;
18393 wxImage *arg1 = (wxImage *) 0 ;
18394 buffer arg2 ;
18395 int arg3 ;
18396 void *argp1 = 0 ;
18397 int res1 = 0 ;
18398 Py_ssize_t temp2 ;
18399 PyObject * obj0 = 0 ;
18400 PyObject * obj1 = 0 ;
18401 char * kwnames[] = {
18402 (char *) "self",(char *) "alpha", NULL
18403 };
18404
18405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18407 if (!SWIG_IsOK(res1)) {
18408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18409 }
18410 arg1 = reinterpret_cast< wxImage * >(argp1);
18411 {
18412 if (obj1 != Py_None) {
18413 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18414 arg3 = (int)temp2;
18415 }
18416 }
18417 {
18418 PyThreadState* __tstate = wxPyBeginAllowThreads();
18419 wxImage_SetAlphaData(arg1,arg2,arg3);
18420 wxPyEndAllowThreads(__tstate);
18421 if (PyErr_Occurred()) SWIG_fail;
18422 }
18423 resultobj = SWIG_Py_Void();
18424 return resultobj;
18425 fail:
18426 return NULL;
18427 }
18428
18429
18430 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18431 PyObject *resultobj = 0;
18432 wxImage *arg1 = (wxImage *) 0 ;
18433 PyObject *result = 0 ;
18434 void *argp1 = 0 ;
18435 int res1 = 0 ;
18436 PyObject *swig_obj[1] ;
18437
18438 if (!args) SWIG_fail;
18439 swig_obj[0] = args;
18440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18441 if (!SWIG_IsOK(res1)) {
18442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18443 }
18444 arg1 = reinterpret_cast< wxImage * >(argp1);
18445 {
18446 PyThreadState* __tstate = wxPyBeginAllowThreads();
18447 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18448 wxPyEndAllowThreads(__tstate);
18449 if (PyErr_Occurred()) SWIG_fail;
18450 }
18451 resultobj = result;
18452 return resultobj;
18453 fail:
18454 return NULL;
18455 }
18456
18457
18458 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18459 PyObject *resultobj = 0;
18460 wxImage *arg1 = (wxImage *) 0 ;
18461 buffer arg2 ;
18462 int arg3 ;
18463 void *argp1 = 0 ;
18464 int res1 = 0 ;
18465 Py_ssize_t temp2 ;
18466 PyObject * obj0 = 0 ;
18467 PyObject * obj1 = 0 ;
18468 char * kwnames[] = {
18469 (char *) "self",(char *) "alpha", NULL
18470 };
18471
18472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18474 if (!SWIG_IsOK(res1)) {
18475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18476 }
18477 arg1 = reinterpret_cast< wxImage * >(argp1);
18478 {
18479 if (obj1 != Py_None) {
18480 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18481 arg3 = (int)temp2;
18482 }
18483 }
18484 {
18485 PyThreadState* __tstate = wxPyBeginAllowThreads();
18486 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18487 wxPyEndAllowThreads(__tstate);
18488 if (PyErr_Occurred()) SWIG_fail;
18489 }
18490 resultobj = SWIG_Py_Void();
18491 return resultobj;
18492 fail:
18493 return NULL;
18494 }
18495
18496
18497 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18498 PyObject *resultobj = 0;
18499 wxImage *arg1 = (wxImage *) 0 ;
18500 byte arg2 ;
18501 byte arg3 ;
18502 byte arg4 ;
18503 void *argp1 = 0 ;
18504 int res1 = 0 ;
18505 unsigned char val2 ;
18506 int ecode2 = 0 ;
18507 unsigned char val3 ;
18508 int ecode3 = 0 ;
18509 unsigned char val4 ;
18510 int ecode4 = 0 ;
18511 PyObject * obj0 = 0 ;
18512 PyObject * obj1 = 0 ;
18513 PyObject * obj2 = 0 ;
18514 PyObject * obj3 = 0 ;
18515 char * kwnames[] = {
18516 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18517 };
18518
18519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18521 if (!SWIG_IsOK(res1)) {
18522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18523 }
18524 arg1 = reinterpret_cast< wxImage * >(argp1);
18525 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18526 if (!SWIG_IsOK(ecode2)) {
18527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18528 }
18529 arg2 = static_cast< byte >(val2);
18530 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18531 if (!SWIG_IsOK(ecode3)) {
18532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18533 }
18534 arg3 = static_cast< byte >(val3);
18535 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18536 if (!SWIG_IsOK(ecode4)) {
18537 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18538 }
18539 arg4 = static_cast< byte >(val4);
18540 {
18541 PyThreadState* __tstate = wxPyBeginAllowThreads();
18542 (arg1)->SetMaskColour(arg2,arg3,arg4);
18543 wxPyEndAllowThreads(__tstate);
18544 if (PyErr_Occurred()) SWIG_fail;
18545 }
18546 resultobj = SWIG_Py_Void();
18547 return resultobj;
18548 fail:
18549 return NULL;
18550 }
18551
18552
18553 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18554 PyObject *resultobj = 0;
18555 wxImage *arg1 = (wxImage *) 0 ;
18556 byte *arg2 = (byte *) 0 ;
18557 byte *arg3 = (byte *) 0 ;
18558 byte *arg4 = (byte *) 0 ;
18559 void *argp1 = 0 ;
18560 int res1 = 0 ;
18561 byte temp2 ;
18562 int res2 = SWIG_TMPOBJ ;
18563 byte temp3 ;
18564 int res3 = SWIG_TMPOBJ ;
18565 byte temp4 ;
18566 int res4 = SWIG_TMPOBJ ;
18567 PyObject *swig_obj[1] ;
18568
18569 arg2 = &temp2;
18570 arg3 = &temp3;
18571 arg4 = &temp4;
18572 if (!args) SWIG_fail;
18573 swig_obj[0] = args;
18574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18575 if (!SWIG_IsOK(res1)) {
18576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18577 }
18578 arg1 = reinterpret_cast< wxImage * >(argp1);
18579 {
18580 PyThreadState* __tstate = wxPyBeginAllowThreads();
18581 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18582 wxPyEndAllowThreads(__tstate);
18583 if (PyErr_Occurred()) SWIG_fail;
18584 }
18585 resultobj = SWIG_Py_Void();
18586 if (SWIG_IsTmpObj(res2)) {
18587 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18588 } else {
18589 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18590 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18591 }
18592 if (SWIG_IsTmpObj(res3)) {
18593 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18594 } else {
18595 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18596 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18597 }
18598 if (SWIG_IsTmpObj(res4)) {
18599 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18600 } else {
18601 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18602 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18603 }
18604 return resultobj;
18605 fail:
18606 return NULL;
18607 }
18608
18609
18610 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18611 PyObject *resultobj = 0;
18612 wxImage *arg1 = (wxImage *) 0 ;
18613 byte result;
18614 void *argp1 = 0 ;
18615 int res1 = 0 ;
18616 PyObject *swig_obj[1] ;
18617
18618 if (!args) SWIG_fail;
18619 swig_obj[0] = args;
18620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18621 if (!SWIG_IsOK(res1)) {
18622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18623 }
18624 arg1 = reinterpret_cast< wxImage * >(argp1);
18625 {
18626 PyThreadState* __tstate = wxPyBeginAllowThreads();
18627 result = (byte)(arg1)->GetMaskRed();
18628 wxPyEndAllowThreads(__tstate);
18629 if (PyErr_Occurred()) SWIG_fail;
18630 }
18631 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18632 return resultobj;
18633 fail:
18634 return NULL;
18635 }
18636
18637
18638 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18639 PyObject *resultobj = 0;
18640 wxImage *arg1 = (wxImage *) 0 ;
18641 byte result;
18642 void *argp1 = 0 ;
18643 int res1 = 0 ;
18644 PyObject *swig_obj[1] ;
18645
18646 if (!args) SWIG_fail;
18647 swig_obj[0] = args;
18648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18649 if (!SWIG_IsOK(res1)) {
18650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18651 }
18652 arg1 = reinterpret_cast< wxImage * >(argp1);
18653 {
18654 PyThreadState* __tstate = wxPyBeginAllowThreads();
18655 result = (byte)(arg1)->GetMaskGreen();
18656 wxPyEndAllowThreads(__tstate);
18657 if (PyErr_Occurred()) SWIG_fail;
18658 }
18659 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18660 return resultobj;
18661 fail:
18662 return NULL;
18663 }
18664
18665
18666 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18667 PyObject *resultobj = 0;
18668 wxImage *arg1 = (wxImage *) 0 ;
18669 byte result;
18670 void *argp1 = 0 ;
18671 int res1 = 0 ;
18672 PyObject *swig_obj[1] ;
18673
18674 if (!args) SWIG_fail;
18675 swig_obj[0] = args;
18676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18677 if (!SWIG_IsOK(res1)) {
18678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18679 }
18680 arg1 = reinterpret_cast< wxImage * >(argp1);
18681 {
18682 PyThreadState* __tstate = wxPyBeginAllowThreads();
18683 result = (byte)(arg1)->GetMaskBlue();
18684 wxPyEndAllowThreads(__tstate);
18685 if (PyErr_Occurred()) SWIG_fail;
18686 }
18687 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18688 return resultobj;
18689 fail:
18690 return NULL;
18691 }
18692
18693
18694 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18695 PyObject *resultobj = 0;
18696 wxImage *arg1 = (wxImage *) 0 ;
18697 bool arg2 = (bool) true ;
18698 void *argp1 = 0 ;
18699 int res1 = 0 ;
18700 bool val2 ;
18701 int ecode2 = 0 ;
18702 PyObject * obj0 = 0 ;
18703 PyObject * obj1 = 0 ;
18704 char * kwnames[] = {
18705 (char *) "self",(char *) "mask", NULL
18706 };
18707
18708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18710 if (!SWIG_IsOK(res1)) {
18711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18712 }
18713 arg1 = reinterpret_cast< wxImage * >(argp1);
18714 if (obj1) {
18715 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18716 if (!SWIG_IsOK(ecode2)) {
18717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18718 }
18719 arg2 = static_cast< bool >(val2);
18720 }
18721 {
18722 PyThreadState* __tstate = wxPyBeginAllowThreads();
18723 (arg1)->SetMask(arg2);
18724 wxPyEndAllowThreads(__tstate);
18725 if (PyErr_Occurred()) SWIG_fail;
18726 }
18727 resultobj = SWIG_Py_Void();
18728 return resultobj;
18729 fail:
18730 return NULL;
18731 }
18732
18733
18734 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18735 PyObject *resultobj = 0;
18736 wxImage *arg1 = (wxImage *) 0 ;
18737 bool result;
18738 void *argp1 = 0 ;
18739 int res1 = 0 ;
18740 PyObject *swig_obj[1] ;
18741
18742 if (!args) SWIG_fail;
18743 swig_obj[0] = args;
18744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18745 if (!SWIG_IsOK(res1)) {
18746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18747 }
18748 arg1 = reinterpret_cast< wxImage * >(argp1);
18749 {
18750 PyThreadState* __tstate = wxPyBeginAllowThreads();
18751 result = (bool)(arg1)->HasMask();
18752 wxPyEndAllowThreads(__tstate);
18753 if (PyErr_Occurred()) SWIG_fail;
18754 }
18755 {
18756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18757 }
18758 return resultobj;
18759 fail:
18760 return NULL;
18761 }
18762
18763
18764 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18765 PyObject *resultobj = 0;
18766 wxImage *arg1 = (wxImage *) 0 ;
18767 double arg2 ;
18768 wxPoint *arg3 = 0 ;
18769 bool arg4 = (bool) true ;
18770 wxPoint *arg5 = (wxPoint *) NULL ;
18771 SwigValueWrapper<wxImage > result;
18772 void *argp1 = 0 ;
18773 int res1 = 0 ;
18774 double val2 ;
18775 int ecode2 = 0 ;
18776 wxPoint temp3 ;
18777 bool val4 ;
18778 int ecode4 = 0 ;
18779 void *argp5 = 0 ;
18780 int res5 = 0 ;
18781 PyObject * obj0 = 0 ;
18782 PyObject * obj1 = 0 ;
18783 PyObject * obj2 = 0 ;
18784 PyObject * obj3 = 0 ;
18785 PyObject * obj4 = 0 ;
18786 char * kwnames[] = {
18787 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18788 };
18789
18790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18792 if (!SWIG_IsOK(res1)) {
18793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18794 }
18795 arg1 = reinterpret_cast< wxImage * >(argp1);
18796 ecode2 = SWIG_AsVal_double(obj1, &val2);
18797 if (!SWIG_IsOK(ecode2)) {
18798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18799 }
18800 arg2 = static_cast< double >(val2);
18801 {
18802 arg3 = &temp3;
18803 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18804 }
18805 if (obj3) {
18806 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18807 if (!SWIG_IsOK(ecode4)) {
18808 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18809 }
18810 arg4 = static_cast< bool >(val4);
18811 }
18812 if (obj4) {
18813 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18814 if (!SWIG_IsOK(res5)) {
18815 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18816 }
18817 arg5 = reinterpret_cast< wxPoint * >(argp5);
18818 }
18819 {
18820 PyThreadState* __tstate = wxPyBeginAllowThreads();
18821 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18822 wxPyEndAllowThreads(__tstate);
18823 if (PyErr_Occurred()) SWIG_fail;
18824 }
18825 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18826 return resultobj;
18827 fail:
18828 return NULL;
18829 }
18830
18831
18832 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18833 PyObject *resultobj = 0;
18834 wxImage *arg1 = (wxImage *) 0 ;
18835 bool arg2 = (bool) true ;
18836 SwigValueWrapper<wxImage > result;
18837 void *argp1 = 0 ;
18838 int res1 = 0 ;
18839 bool val2 ;
18840 int ecode2 = 0 ;
18841 PyObject * obj0 = 0 ;
18842 PyObject * obj1 = 0 ;
18843 char * kwnames[] = {
18844 (char *) "self",(char *) "clockwise", NULL
18845 };
18846
18847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18849 if (!SWIG_IsOK(res1)) {
18850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18851 }
18852 arg1 = reinterpret_cast< wxImage * >(argp1);
18853 if (obj1) {
18854 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18855 if (!SWIG_IsOK(ecode2)) {
18856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18857 }
18858 arg2 = static_cast< bool >(val2);
18859 }
18860 {
18861 PyThreadState* __tstate = wxPyBeginAllowThreads();
18862 result = (arg1)->Rotate90(arg2);
18863 wxPyEndAllowThreads(__tstate);
18864 if (PyErr_Occurred()) SWIG_fail;
18865 }
18866 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18867 return resultobj;
18868 fail:
18869 return NULL;
18870 }
18871
18872
18873 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18874 PyObject *resultobj = 0;
18875 wxImage *arg1 = (wxImage *) 0 ;
18876 bool arg2 = (bool) true ;
18877 SwigValueWrapper<wxImage > result;
18878 void *argp1 = 0 ;
18879 int res1 = 0 ;
18880 bool val2 ;
18881 int ecode2 = 0 ;
18882 PyObject * obj0 = 0 ;
18883 PyObject * obj1 = 0 ;
18884 char * kwnames[] = {
18885 (char *) "self",(char *) "horizontally", NULL
18886 };
18887
18888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18890 if (!SWIG_IsOK(res1)) {
18891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18892 }
18893 arg1 = reinterpret_cast< wxImage * >(argp1);
18894 if (obj1) {
18895 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18896 if (!SWIG_IsOK(ecode2)) {
18897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18898 }
18899 arg2 = static_cast< bool >(val2);
18900 }
18901 {
18902 PyThreadState* __tstate = wxPyBeginAllowThreads();
18903 result = (arg1)->Mirror(arg2);
18904 wxPyEndAllowThreads(__tstate);
18905 if (PyErr_Occurred()) SWIG_fail;
18906 }
18907 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18908 return resultobj;
18909 fail:
18910 return NULL;
18911 }
18912
18913
18914 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18915 PyObject *resultobj = 0;
18916 wxImage *arg1 = (wxImage *) 0 ;
18917 byte arg2 ;
18918 byte arg3 ;
18919 byte arg4 ;
18920 byte arg5 ;
18921 byte arg6 ;
18922 byte arg7 ;
18923 void *argp1 = 0 ;
18924 int res1 = 0 ;
18925 unsigned char val2 ;
18926 int ecode2 = 0 ;
18927 unsigned char val3 ;
18928 int ecode3 = 0 ;
18929 unsigned char val4 ;
18930 int ecode4 = 0 ;
18931 unsigned char val5 ;
18932 int ecode5 = 0 ;
18933 unsigned char val6 ;
18934 int ecode6 = 0 ;
18935 unsigned char val7 ;
18936 int ecode7 = 0 ;
18937 PyObject * obj0 = 0 ;
18938 PyObject * obj1 = 0 ;
18939 PyObject * obj2 = 0 ;
18940 PyObject * obj3 = 0 ;
18941 PyObject * obj4 = 0 ;
18942 PyObject * obj5 = 0 ;
18943 PyObject * obj6 = 0 ;
18944 char * kwnames[] = {
18945 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18946 };
18947
18948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18950 if (!SWIG_IsOK(res1)) {
18951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18952 }
18953 arg1 = reinterpret_cast< wxImage * >(argp1);
18954 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18955 if (!SWIG_IsOK(ecode2)) {
18956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18957 }
18958 arg2 = static_cast< byte >(val2);
18959 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18960 if (!SWIG_IsOK(ecode3)) {
18961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18962 }
18963 arg3 = static_cast< byte >(val3);
18964 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18965 if (!SWIG_IsOK(ecode4)) {
18966 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18967 }
18968 arg4 = static_cast< byte >(val4);
18969 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18970 if (!SWIG_IsOK(ecode5)) {
18971 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18972 }
18973 arg5 = static_cast< byte >(val5);
18974 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18975 if (!SWIG_IsOK(ecode6)) {
18976 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18977 }
18978 arg6 = static_cast< byte >(val6);
18979 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18980 if (!SWIG_IsOK(ecode7)) {
18981 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18982 }
18983 arg7 = static_cast< byte >(val7);
18984 {
18985 PyThreadState* __tstate = wxPyBeginAllowThreads();
18986 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18987 wxPyEndAllowThreads(__tstate);
18988 if (PyErr_Occurred()) SWIG_fail;
18989 }
18990 resultobj = SWIG_Py_Void();
18991 return resultobj;
18992 fail:
18993 return NULL;
18994 }
18995
18996
18997 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18998 PyObject *resultobj = 0;
18999 wxImage *arg1 = (wxImage *) 0 ;
19000 double arg2 = (double) 0.299 ;
19001 double arg3 = (double) 0.587 ;
19002 double arg4 = (double) 0.114 ;
19003 SwigValueWrapper<wxImage > result;
19004 void *argp1 = 0 ;
19005 int res1 = 0 ;
19006 double val2 ;
19007 int ecode2 = 0 ;
19008 double val3 ;
19009 int ecode3 = 0 ;
19010 double val4 ;
19011 int ecode4 = 0 ;
19012 PyObject * obj0 = 0 ;
19013 PyObject * obj1 = 0 ;
19014 PyObject * obj2 = 0 ;
19015 PyObject * obj3 = 0 ;
19016 char * kwnames[] = {
19017 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
19018 };
19019
19020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19022 if (!SWIG_IsOK(res1)) {
19023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
19024 }
19025 arg1 = reinterpret_cast< wxImage * >(argp1);
19026 if (obj1) {
19027 ecode2 = SWIG_AsVal_double(obj1, &val2);
19028 if (!SWIG_IsOK(ecode2)) {
19029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
19030 }
19031 arg2 = static_cast< double >(val2);
19032 }
19033 if (obj2) {
19034 ecode3 = SWIG_AsVal_double(obj2, &val3);
19035 if (!SWIG_IsOK(ecode3)) {
19036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
19037 }
19038 arg3 = static_cast< double >(val3);
19039 }
19040 if (obj3) {
19041 ecode4 = SWIG_AsVal_double(obj3, &val4);
19042 if (!SWIG_IsOK(ecode4)) {
19043 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
19044 }
19045 arg4 = static_cast< double >(val4);
19046 }
19047 {
19048 PyThreadState* __tstate = wxPyBeginAllowThreads();
19049 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
19050 wxPyEndAllowThreads(__tstate);
19051 if (PyErr_Occurred()) SWIG_fail;
19052 }
19053 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19054 return resultobj;
19055 fail:
19056 return NULL;
19057 }
19058
19059
19060 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19061 PyObject *resultobj = 0;
19062 wxImage *arg1 = (wxImage *) 0 ;
19063 byte arg2 ;
19064 byte arg3 ;
19065 byte arg4 ;
19066 SwigValueWrapper<wxImage > result;
19067 void *argp1 = 0 ;
19068 int res1 = 0 ;
19069 unsigned char val2 ;
19070 int ecode2 = 0 ;
19071 unsigned char val3 ;
19072 int ecode3 = 0 ;
19073 unsigned char val4 ;
19074 int ecode4 = 0 ;
19075 PyObject * obj0 = 0 ;
19076 PyObject * obj1 = 0 ;
19077 PyObject * obj2 = 0 ;
19078 PyObject * obj3 = 0 ;
19079 char * kwnames[] = {
19080 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19081 };
19082
19083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19085 if (!SWIG_IsOK(res1)) {
19086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19087 }
19088 arg1 = reinterpret_cast< wxImage * >(argp1);
19089 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19090 if (!SWIG_IsOK(ecode2)) {
19091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19092 }
19093 arg2 = static_cast< byte >(val2);
19094 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19095 if (!SWIG_IsOK(ecode3)) {
19096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19097 }
19098 arg3 = static_cast< byte >(val3);
19099 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19100 if (!SWIG_IsOK(ecode4)) {
19101 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19102 }
19103 arg4 = static_cast< byte >(val4);
19104 {
19105 PyThreadState* __tstate = wxPyBeginAllowThreads();
19106 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19107 wxPyEndAllowThreads(__tstate);
19108 if (PyErr_Occurred()) SWIG_fail;
19109 }
19110 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19111 return resultobj;
19112 fail:
19113 return NULL;
19114 }
19115
19116
19117 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19118 PyObject *resultobj = 0;
19119 wxImage *arg1 = (wxImage *) 0 ;
19120 wxString *arg2 = 0 ;
19121 wxString *arg3 = 0 ;
19122 void *argp1 = 0 ;
19123 int res1 = 0 ;
19124 bool temp2 = false ;
19125 bool temp3 = false ;
19126 PyObject * obj0 = 0 ;
19127 PyObject * obj1 = 0 ;
19128 PyObject * obj2 = 0 ;
19129 char * kwnames[] = {
19130 (char *) "self",(char *) "name",(char *) "value", NULL
19131 };
19132
19133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19135 if (!SWIG_IsOK(res1)) {
19136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19137 }
19138 arg1 = reinterpret_cast< wxImage * >(argp1);
19139 {
19140 arg2 = wxString_in_helper(obj1);
19141 if (arg2 == NULL) SWIG_fail;
19142 temp2 = true;
19143 }
19144 {
19145 arg3 = wxString_in_helper(obj2);
19146 if (arg3 == NULL) SWIG_fail;
19147 temp3 = true;
19148 }
19149 {
19150 PyThreadState* __tstate = wxPyBeginAllowThreads();
19151 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19152 wxPyEndAllowThreads(__tstate);
19153 if (PyErr_Occurred()) SWIG_fail;
19154 }
19155 resultobj = SWIG_Py_Void();
19156 {
19157 if (temp2)
19158 delete arg2;
19159 }
19160 {
19161 if (temp3)
19162 delete arg3;
19163 }
19164 return resultobj;
19165 fail:
19166 {
19167 if (temp2)
19168 delete arg2;
19169 }
19170 {
19171 if (temp3)
19172 delete arg3;
19173 }
19174 return NULL;
19175 }
19176
19177
19178 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19179 PyObject *resultobj = 0;
19180 wxImage *arg1 = (wxImage *) 0 ;
19181 wxString *arg2 = 0 ;
19182 int arg3 ;
19183 void *argp1 = 0 ;
19184 int res1 = 0 ;
19185 bool temp2 = false ;
19186 int val3 ;
19187 int ecode3 = 0 ;
19188 PyObject * obj0 = 0 ;
19189 PyObject * obj1 = 0 ;
19190 PyObject * obj2 = 0 ;
19191 char * kwnames[] = {
19192 (char *) "self",(char *) "name",(char *) "value", NULL
19193 };
19194
19195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19197 if (!SWIG_IsOK(res1)) {
19198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19199 }
19200 arg1 = reinterpret_cast< wxImage * >(argp1);
19201 {
19202 arg2 = wxString_in_helper(obj1);
19203 if (arg2 == NULL) SWIG_fail;
19204 temp2 = true;
19205 }
19206 ecode3 = SWIG_AsVal_int(obj2, &val3);
19207 if (!SWIG_IsOK(ecode3)) {
19208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19209 }
19210 arg3 = static_cast< int >(val3);
19211 {
19212 PyThreadState* __tstate = wxPyBeginAllowThreads();
19213 (arg1)->SetOption((wxString const &)*arg2,arg3);
19214 wxPyEndAllowThreads(__tstate);
19215 if (PyErr_Occurred()) SWIG_fail;
19216 }
19217 resultobj = SWIG_Py_Void();
19218 {
19219 if (temp2)
19220 delete arg2;
19221 }
19222 return resultobj;
19223 fail:
19224 {
19225 if (temp2)
19226 delete arg2;
19227 }
19228 return NULL;
19229 }
19230
19231
19232 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19233 PyObject *resultobj = 0;
19234 wxImage *arg1 = (wxImage *) 0 ;
19235 wxString *arg2 = 0 ;
19236 wxString result;
19237 void *argp1 = 0 ;
19238 int res1 = 0 ;
19239 bool temp2 = false ;
19240 PyObject * obj0 = 0 ;
19241 PyObject * obj1 = 0 ;
19242 char * kwnames[] = {
19243 (char *) "self",(char *) "name", NULL
19244 };
19245
19246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19248 if (!SWIG_IsOK(res1)) {
19249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19250 }
19251 arg1 = reinterpret_cast< wxImage * >(argp1);
19252 {
19253 arg2 = wxString_in_helper(obj1);
19254 if (arg2 == NULL) SWIG_fail;
19255 temp2 = true;
19256 }
19257 {
19258 PyThreadState* __tstate = wxPyBeginAllowThreads();
19259 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19260 wxPyEndAllowThreads(__tstate);
19261 if (PyErr_Occurred()) SWIG_fail;
19262 }
19263 {
19264 #if wxUSE_UNICODE
19265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19266 #else
19267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19268 #endif
19269 }
19270 {
19271 if (temp2)
19272 delete arg2;
19273 }
19274 return resultobj;
19275 fail:
19276 {
19277 if (temp2)
19278 delete arg2;
19279 }
19280 return NULL;
19281 }
19282
19283
19284 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19285 PyObject *resultobj = 0;
19286 wxImage *arg1 = (wxImage *) 0 ;
19287 wxString *arg2 = 0 ;
19288 int result;
19289 void *argp1 = 0 ;
19290 int res1 = 0 ;
19291 bool temp2 = false ;
19292 PyObject * obj0 = 0 ;
19293 PyObject * obj1 = 0 ;
19294 char * kwnames[] = {
19295 (char *) "self",(char *) "name", NULL
19296 };
19297
19298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19300 if (!SWIG_IsOK(res1)) {
19301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19302 }
19303 arg1 = reinterpret_cast< wxImage * >(argp1);
19304 {
19305 arg2 = wxString_in_helper(obj1);
19306 if (arg2 == NULL) SWIG_fail;
19307 temp2 = true;
19308 }
19309 {
19310 PyThreadState* __tstate = wxPyBeginAllowThreads();
19311 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19312 wxPyEndAllowThreads(__tstate);
19313 if (PyErr_Occurred()) SWIG_fail;
19314 }
19315 resultobj = SWIG_From_int(static_cast< int >(result));
19316 {
19317 if (temp2)
19318 delete arg2;
19319 }
19320 return resultobj;
19321 fail:
19322 {
19323 if (temp2)
19324 delete arg2;
19325 }
19326 return NULL;
19327 }
19328
19329
19330 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19331 PyObject *resultobj = 0;
19332 wxImage *arg1 = (wxImage *) 0 ;
19333 wxString *arg2 = 0 ;
19334 bool result;
19335 void *argp1 = 0 ;
19336 int res1 = 0 ;
19337 bool temp2 = false ;
19338 PyObject * obj0 = 0 ;
19339 PyObject * obj1 = 0 ;
19340 char * kwnames[] = {
19341 (char *) "self",(char *) "name", NULL
19342 };
19343
19344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19346 if (!SWIG_IsOK(res1)) {
19347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19348 }
19349 arg1 = reinterpret_cast< wxImage * >(argp1);
19350 {
19351 arg2 = wxString_in_helper(obj1);
19352 if (arg2 == NULL) SWIG_fail;
19353 temp2 = true;
19354 }
19355 {
19356 PyThreadState* __tstate = wxPyBeginAllowThreads();
19357 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19358 wxPyEndAllowThreads(__tstate);
19359 if (PyErr_Occurred()) SWIG_fail;
19360 }
19361 {
19362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19363 }
19364 {
19365 if (temp2)
19366 delete arg2;
19367 }
19368 return resultobj;
19369 fail:
19370 {
19371 if (temp2)
19372 delete arg2;
19373 }
19374 return NULL;
19375 }
19376
19377
19378 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19379 PyObject *resultobj = 0;
19380 wxImage *arg1 = (wxImage *) 0 ;
19381 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19382 unsigned long result;
19383 void *argp1 = 0 ;
19384 int res1 = 0 ;
19385 unsigned long val2 ;
19386 int ecode2 = 0 ;
19387 PyObject * obj0 = 0 ;
19388 PyObject * obj1 = 0 ;
19389 char * kwnames[] = {
19390 (char *) "self",(char *) "stopafter", NULL
19391 };
19392
19393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19395 if (!SWIG_IsOK(res1)) {
19396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19397 }
19398 arg1 = reinterpret_cast< wxImage * >(argp1);
19399 if (obj1) {
19400 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19401 if (!SWIG_IsOK(ecode2)) {
19402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19403 }
19404 arg2 = static_cast< unsigned long >(val2);
19405 }
19406 {
19407 PyThreadState* __tstate = wxPyBeginAllowThreads();
19408 result = (unsigned long)(arg1)->CountColours(arg2);
19409 wxPyEndAllowThreads(__tstate);
19410 if (PyErr_Occurred()) SWIG_fail;
19411 }
19412 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19413 return resultobj;
19414 fail:
19415 return NULL;
19416 }
19417
19418
19419 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19420 PyObject *resultobj = 0;
19421 wxImage *arg1 = (wxImage *) 0 ;
19422 wxImageHistogram *arg2 = 0 ;
19423 unsigned long result;
19424 void *argp1 = 0 ;
19425 int res1 = 0 ;
19426 void *argp2 = 0 ;
19427 int res2 = 0 ;
19428 PyObject * obj0 = 0 ;
19429 PyObject * obj1 = 0 ;
19430 char * kwnames[] = {
19431 (char *) "self",(char *) "h", NULL
19432 };
19433
19434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19436 if (!SWIG_IsOK(res1)) {
19437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19438 }
19439 arg1 = reinterpret_cast< wxImage * >(argp1);
19440 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19441 if (!SWIG_IsOK(res2)) {
19442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19443 }
19444 if (!argp2) {
19445 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19446 }
19447 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19448 {
19449 PyThreadState* __tstate = wxPyBeginAllowThreads();
19450 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19451 wxPyEndAllowThreads(__tstate);
19452 if (PyErr_Occurred()) SWIG_fail;
19453 }
19454 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19455 return resultobj;
19456 fail:
19457 return NULL;
19458 }
19459
19460
19461 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19462 PyObject *resultobj = 0;
19463 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19464 void *argp1 = 0 ;
19465 int res1 = 0 ;
19466 PyObject * obj0 = 0 ;
19467 char * kwnames[] = {
19468 (char *) "handler", NULL
19469 };
19470
19471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19473 if (!SWIG_IsOK(res1)) {
19474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19475 }
19476 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19477 {
19478 PyThreadState* __tstate = wxPyBeginAllowThreads();
19479 wxImage::AddHandler(arg1);
19480 wxPyEndAllowThreads(__tstate);
19481 if (PyErr_Occurred()) SWIG_fail;
19482 }
19483 resultobj = SWIG_Py_Void();
19484 return resultobj;
19485 fail:
19486 return NULL;
19487 }
19488
19489
19490 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19491 PyObject *resultobj = 0;
19492 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19493 void *argp1 = 0 ;
19494 int res1 = 0 ;
19495 PyObject * obj0 = 0 ;
19496 char * kwnames[] = {
19497 (char *) "handler", NULL
19498 };
19499
19500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19502 if (!SWIG_IsOK(res1)) {
19503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19504 }
19505 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19506 {
19507 PyThreadState* __tstate = wxPyBeginAllowThreads();
19508 wxImage::InsertHandler(arg1);
19509 wxPyEndAllowThreads(__tstate);
19510 if (PyErr_Occurred()) SWIG_fail;
19511 }
19512 resultobj = SWIG_Py_Void();
19513 return resultobj;
19514 fail:
19515 return NULL;
19516 }
19517
19518
19519 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19520 PyObject *resultobj = 0;
19521 wxString *arg1 = 0 ;
19522 bool result;
19523 bool temp1 = false ;
19524 PyObject * obj0 = 0 ;
19525 char * kwnames[] = {
19526 (char *) "name", NULL
19527 };
19528
19529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19530 {
19531 arg1 = wxString_in_helper(obj0);
19532 if (arg1 == NULL) SWIG_fail;
19533 temp1 = true;
19534 }
19535 {
19536 PyThreadState* __tstate = wxPyBeginAllowThreads();
19537 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19538 wxPyEndAllowThreads(__tstate);
19539 if (PyErr_Occurred()) SWIG_fail;
19540 }
19541 {
19542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19543 }
19544 {
19545 if (temp1)
19546 delete arg1;
19547 }
19548 return resultobj;
19549 fail:
19550 {
19551 if (temp1)
19552 delete arg1;
19553 }
19554 return NULL;
19555 }
19556
19557
19558 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19559 PyObject *resultobj = 0;
19560 PyObject *result = 0 ;
19561
19562 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19563 {
19564 PyThreadState* __tstate = wxPyBeginAllowThreads();
19565 result = (PyObject *)wxImage_GetHandlers();
19566 wxPyEndAllowThreads(__tstate);
19567 if (PyErr_Occurred()) SWIG_fail;
19568 }
19569 resultobj = result;
19570 return resultobj;
19571 fail:
19572 return NULL;
19573 }
19574
19575
19576 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19577 PyObject *resultobj = 0;
19578 wxString result;
19579
19580 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19581 {
19582 PyThreadState* __tstate = wxPyBeginAllowThreads();
19583 result = wxImage::GetImageExtWildcard();
19584 wxPyEndAllowThreads(__tstate);
19585 if (PyErr_Occurred()) SWIG_fail;
19586 }
19587 {
19588 #if wxUSE_UNICODE
19589 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19590 #else
19591 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19592 #endif
19593 }
19594 return resultobj;
19595 fail:
19596 return NULL;
19597 }
19598
19599
19600 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19601 PyObject *resultobj = 0;
19602 wxImage *arg1 = (wxImage *) 0 ;
19603 int arg2 = (int) -1 ;
19604 wxBitmap result;
19605 void *argp1 = 0 ;
19606 int res1 = 0 ;
19607 int val2 ;
19608 int ecode2 = 0 ;
19609 PyObject * obj0 = 0 ;
19610 PyObject * obj1 = 0 ;
19611 char * kwnames[] = {
19612 (char *) "self",(char *) "depth", NULL
19613 };
19614
19615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19617 if (!SWIG_IsOK(res1)) {
19618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19619 }
19620 arg1 = reinterpret_cast< wxImage * >(argp1);
19621 if (obj1) {
19622 ecode2 = SWIG_AsVal_int(obj1, &val2);
19623 if (!SWIG_IsOK(ecode2)) {
19624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19625 }
19626 arg2 = static_cast< int >(val2);
19627 }
19628 {
19629 if (!wxPyCheckForApp()) SWIG_fail;
19630 PyThreadState* __tstate = wxPyBeginAllowThreads();
19631 result = wxImage_ConvertToBitmap(arg1,arg2);
19632 wxPyEndAllowThreads(__tstate);
19633 if (PyErr_Occurred()) SWIG_fail;
19634 }
19635 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19636 return resultobj;
19637 fail:
19638 return NULL;
19639 }
19640
19641
19642 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19643 PyObject *resultobj = 0;
19644 wxImage *arg1 = (wxImage *) 0 ;
19645 byte arg2 ;
19646 byte arg3 ;
19647 byte arg4 ;
19648 wxBitmap result;
19649 void *argp1 = 0 ;
19650 int res1 = 0 ;
19651 unsigned char val2 ;
19652 int ecode2 = 0 ;
19653 unsigned char val3 ;
19654 int ecode3 = 0 ;
19655 unsigned char val4 ;
19656 int ecode4 = 0 ;
19657 PyObject * obj0 = 0 ;
19658 PyObject * obj1 = 0 ;
19659 PyObject * obj2 = 0 ;
19660 PyObject * obj3 = 0 ;
19661 char * kwnames[] = {
19662 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19663 };
19664
19665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19667 if (!SWIG_IsOK(res1)) {
19668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19669 }
19670 arg1 = reinterpret_cast< wxImage * >(argp1);
19671 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19672 if (!SWIG_IsOK(ecode2)) {
19673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19674 }
19675 arg2 = static_cast< byte >(val2);
19676 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19677 if (!SWIG_IsOK(ecode3)) {
19678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19679 }
19680 arg3 = static_cast< byte >(val3);
19681 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19682 if (!SWIG_IsOK(ecode4)) {
19683 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19684 }
19685 arg4 = static_cast< byte >(val4);
19686 {
19687 if (!wxPyCheckForApp()) SWIG_fail;
19688 PyThreadState* __tstate = wxPyBeginAllowThreads();
19689 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19690 wxPyEndAllowThreads(__tstate);
19691 if (PyErr_Occurred()) SWIG_fail;
19692 }
19693 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19694 return resultobj;
19695 fail:
19696 return NULL;
19697 }
19698
19699
19700 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19701 PyObject *resultobj = 0;
19702 wxImage *arg1 = (wxImage *) 0 ;
19703 double arg2 ;
19704 void *argp1 = 0 ;
19705 int res1 = 0 ;
19706 double val2 ;
19707 int ecode2 = 0 ;
19708 PyObject * obj0 = 0 ;
19709 PyObject * obj1 = 0 ;
19710 char * kwnames[] = {
19711 (char *) "self",(char *) "angle", NULL
19712 };
19713
19714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19716 if (!SWIG_IsOK(res1)) {
19717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19718 }
19719 arg1 = reinterpret_cast< wxImage * >(argp1);
19720 ecode2 = SWIG_AsVal_double(obj1, &val2);
19721 if (!SWIG_IsOK(ecode2)) {
19722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19723 }
19724 arg2 = static_cast< double >(val2);
19725 {
19726 PyThreadState* __tstate = wxPyBeginAllowThreads();
19727 (arg1)->RotateHue(arg2);
19728 wxPyEndAllowThreads(__tstate);
19729 if (PyErr_Occurred()) SWIG_fail;
19730 }
19731 resultobj = SWIG_Py_Void();
19732 return resultobj;
19733 fail:
19734 return NULL;
19735 }
19736
19737
19738 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19739 PyObject *resultobj = 0;
19740 wxImage_RGBValue arg1 ;
19741 wxImage_HSVValue result;
19742 void *argp1 ;
19743 int res1 = 0 ;
19744 PyObject * obj0 = 0 ;
19745 char * kwnames[] = {
19746 (char *) "rgb", NULL
19747 };
19748
19749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19750 {
19751 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19752 if (!SWIG_IsOK(res1)) {
19753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19754 }
19755 if (!argp1) {
19756 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19757 } else {
19758 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19759 arg1 = *temp;
19760 if (SWIG_IsNewObj(res1)) delete temp;
19761 }
19762 }
19763 {
19764 PyThreadState* __tstate = wxPyBeginAllowThreads();
19765 result = wxImage::RGBtoHSV(arg1);
19766 wxPyEndAllowThreads(__tstate);
19767 if (PyErr_Occurred()) SWIG_fail;
19768 }
19769 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19770 return resultobj;
19771 fail:
19772 return NULL;
19773 }
19774
19775
19776 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19777 PyObject *resultobj = 0;
19778 wxImage_HSVValue arg1 ;
19779 wxImage_RGBValue result;
19780 void *argp1 ;
19781 int res1 = 0 ;
19782 PyObject * obj0 = 0 ;
19783 char * kwnames[] = {
19784 (char *) "hsv", NULL
19785 };
19786
19787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19788 {
19789 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19790 if (!SWIG_IsOK(res1)) {
19791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19792 }
19793 if (!argp1) {
19794 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19795 } else {
19796 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19797 arg1 = *temp;
19798 if (SWIG_IsNewObj(res1)) delete temp;
19799 }
19800 }
19801 {
19802 PyThreadState* __tstate = wxPyBeginAllowThreads();
19803 result = wxImage::HSVtoRGB(arg1);
19804 wxPyEndAllowThreads(__tstate);
19805 if (PyErr_Occurred()) SWIG_fail;
19806 }
19807 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19808 return resultobj;
19809 fail:
19810 return NULL;
19811 }
19812
19813
19814 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19815 PyObject *obj;
19816 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19817 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19818 return SWIG_Py_Void();
19819 }
19820
19821 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19822 return SWIG_Python_InitShadowInstance(args);
19823 }
19824
19825 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19826 PyObject *resultobj = 0;
19827 int arg1 ;
19828 int arg2 ;
19829 buffer arg3 ;
19830 int arg4 ;
19831 buffer arg5 = (buffer) NULL ;
19832 int arg6 = (int) 0 ;
19833 wxImage *result = 0 ;
19834 int val1 ;
19835 int ecode1 = 0 ;
19836 int val2 ;
19837 int ecode2 = 0 ;
19838 Py_ssize_t temp3 ;
19839 Py_ssize_t temp5 ;
19840 PyObject * obj0 = 0 ;
19841 PyObject * obj1 = 0 ;
19842 PyObject * obj2 = 0 ;
19843 PyObject * obj3 = 0 ;
19844 char * kwnames[] = {
19845 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19846 };
19847
19848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19849 ecode1 = SWIG_AsVal_int(obj0, &val1);
19850 if (!SWIG_IsOK(ecode1)) {
19851 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19852 }
19853 arg1 = static_cast< int >(val1);
19854 ecode2 = SWIG_AsVal_int(obj1, &val2);
19855 if (!SWIG_IsOK(ecode2)) {
19856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19857 }
19858 arg2 = static_cast< int >(val2);
19859 {
19860 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19861 arg4 = (int)temp3;
19862 }
19863 if (obj3) {
19864 {
19865 if (obj3 != Py_None) {
19866 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19867 arg6 = (int)temp5;
19868 }
19869 }
19870 }
19871 {
19872 PyThreadState* __tstate = wxPyBeginAllowThreads();
19873 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19874 wxPyEndAllowThreads(__tstate);
19875 if (PyErr_Occurred()) SWIG_fail;
19876 }
19877 {
19878 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19879 }
19880 return resultobj;
19881 fail:
19882 return NULL;
19883 }
19884
19885
19886 SWIGINTERN int NullImage_set(PyObject *) {
19887 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19888 return 1;
19889 }
19890
19891
19892 SWIGINTERN PyObject *NullImage_get(void) {
19893 PyObject *pyobj = 0;
19894
19895 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19896 return pyobj;
19897 }
19898
19899
19900 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19901 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19902 return 1;
19903 }
19904
19905
19906 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19907 PyObject *pyobj = 0;
19908
19909 {
19910 #if wxUSE_UNICODE
19911 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19912 #else
19913 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19914 #endif
19915 }
19916 return pyobj;
19917 }
19918
19919
19920 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19921 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19922 return 1;
19923 }
19924
19925
19926 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19927 PyObject *pyobj = 0;
19928
19929 {
19930 #if wxUSE_UNICODE
19931 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19932 #else
19933 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19934 #endif
19935 }
19936 return pyobj;
19937 }
19938
19939
19940 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19941 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19942 return 1;
19943 }
19944
19945
19946 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19947 PyObject *pyobj = 0;
19948
19949 {
19950 #if wxUSE_UNICODE
19951 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19952 #else
19953 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19954 #endif
19955 }
19956 return pyobj;
19957 }
19958
19959
19960 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19961 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19962 return 1;
19963 }
19964
19965
19966 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19967 PyObject *pyobj = 0;
19968
19969 {
19970 #if wxUSE_UNICODE
19971 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19972 #else
19973 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19974 #endif
19975 }
19976 return pyobj;
19977 }
19978
19979
19980 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19981 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19982 return 1;
19983 }
19984
19985
19986 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19987 PyObject *pyobj = 0;
19988
19989 {
19990 #if wxUSE_UNICODE
19991 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19992 #else
19993 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19994 #endif
19995 }
19996 return pyobj;
19997 }
19998
19999
20000 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
20001 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
20002 return 1;
20003 }
20004
20005
20006 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
20007 PyObject *pyobj = 0;
20008
20009 {
20010 #if wxUSE_UNICODE
20011 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
20012 #else
20013 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
20014 #endif
20015 }
20016 return pyobj;
20017 }
20018
20019
20020 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
20021 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
20022 return 1;
20023 }
20024
20025
20026 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
20027 PyObject *pyobj = 0;
20028
20029 {
20030 #if wxUSE_UNICODE
20031 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20032 #else
20033 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20034 #endif
20035 }
20036 return pyobj;
20037 }
20038
20039
20040 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
20041 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
20042 return 1;
20043 }
20044
20045
20046 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
20047 PyObject *pyobj = 0;
20048
20049 {
20050 #if wxUSE_UNICODE
20051 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20052 #else
20053 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20054 #endif
20055 }
20056 return pyobj;
20057 }
20058
20059
20060 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
20061 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
20062 return 1;
20063 }
20064
20065
20066 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
20067 PyObject *pyobj = 0;
20068
20069 {
20070 #if wxUSE_UNICODE
20071 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20072 #else
20073 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20074 #endif
20075 }
20076 return pyobj;
20077 }
20078
20079
20080 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20081 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20082 return 1;
20083 }
20084
20085
20086 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20087 PyObject *pyobj = 0;
20088
20089 {
20090 #if wxUSE_UNICODE
20091 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20092 #else
20093 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20094 #endif
20095 }
20096 return pyobj;
20097 }
20098
20099
20100 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20101 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20102 return 1;
20103 }
20104
20105
20106 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20107 PyObject *pyobj = 0;
20108
20109 {
20110 #if wxUSE_UNICODE
20111 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20112 #else
20113 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20114 #endif
20115 }
20116 return pyobj;
20117 }
20118
20119
20120 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20121 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20122 return 1;
20123 }
20124
20125
20126 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20127 PyObject *pyobj = 0;
20128
20129 {
20130 #if wxUSE_UNICODE
20131 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20132 #else
20133 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20134 #endif
20135 }
20136 return pyobj;
20137 }
20138
20139
20140 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20141 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20142 return 1;
20143 }
20144
20145
20146 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20147 PyObject *pyobj = 0;
20148
20149 {
20150 #if wxUSE_UNICODE
20151 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20152 #else
20153 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20154 #endif
20155 }
20156 return pyobj;
20157 }
20158
20159
20160 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20161 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20162 return 1;
20163 }
20164
20165
20166 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20167 PyObject *pyobj = 0;
20168
20169 {
20170 #if wxUSE_UNICODE
20171 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20172 #else
20173 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20174 #endif
20175 }
20176 return pyobj;
20177 }
20178
20179
20180 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20181 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20182 return 1;
20183 }
20184
20185
20186 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20187 PyObject *pyobj = 0;
20188
20189 {
20190 #if wxUSE_UNICODE
20191 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20192 #else
20193 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20194 #endif
20195 }
20196 return pyobj;
20197 }
20198
20199
20200 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20201 PyObject *resultobj = 0;
20202 wxBMPHandler *result = 0 ;
20203
20204 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20205 {
20206 PyThreadState* __tstate = wxPyBeginAllowThreads();
20207 result = (wxBMPHandler *)new wxBMPHandler();
20208 wxPyEndAllowThreads(__tstate);
20209 if (PyErr_Occurred()) SWIG_fail;
20210 }
20211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20212 return resultobj;
20213 fail:
20214 return NULL;
20215 }
20216
20217
20218 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20219 PyObject *obj;
20220 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20221 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20222 return SWIG_Py_Void();
20223 }
20224
20225 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20226 return SWIG_Python_InitShadowInstance(args);
20227 }
20228
20229 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20230 PyObject *resultobj = 0;
20231 wxICOHandler *result = 0 ;
20232
20233 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20234 {
20235 PyThreadState* __tstate = wxPyBeginAllowThreads();
20236 result = (wxICOHandler *)new wxICOHandler();
20237 wxPyEndAllowThreads(__tstate);
20238 if (PyErr_Occurred()) SWIG_fail;
20239 }
20240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20241 return resultobj;
20242 fail:
20243 return NULL;
20244 }
20245
20246
20247 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20248 PyObject *obj;
20249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20250 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20251 return SWIG_Py_Void();
20252 }
20253
20254 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20255 return SWIG_Python_InitShadowInstance(args);
20256 }
20257
20258 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20259 PyObject *resultobj = 0;
20260 wxCURHandler *result = 0 ;
20261
20262 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20263 {
20264 PyThreadState* __tstate = wxPyBeginAllowThreads();
20265 result = (wxCURHandler *)new wxCURHandler();
20266 wxPyEndAllowThreads(__tstate);
20267 if (PyErr_Occurred()) SWIG_fail;
20268 }
20269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20270 return resultobj;
20271 fail:
20272 return NULL;
20273 }
20274
20275
20276 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20277 PyObject *obj;
20278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20279 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20280 return SWIG_Py_Void();
20281 }
20282
20283 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20284 return SWIG_Python_InitShadowInstance(args);
20285 }
20286
20287 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20288 PyObject *resultobj = 0;
20289 wxANIHandler *result = 0 ;
20290
20291 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20292 {
20293 PyThreadState* __tstate = wxPyBeginAllowThreads();
20294 result = (wxANIHandler *)new wxANIHandler();
20295 wxPyEndAllowThreads(__tstate);
20296 if (PyErr_Occurred()) SWIG_fail;
20297 }
20298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20299 return resultobj;
20300 fail:
20301 return NULL;
20302 }
20303
20304
20305 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20306 PyObject *obj;
20307 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20308 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20309 return SWIG_Py_Void();
20310 }
20311
20312 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20313 return SWIG_Python_InitShadowInstance(args);
20314 }
20315
20316 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20317 PyObject *resultobj = 0;
20318 wxPNGHandler *result = 0 ;
20319
20320 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20321 {
20322 PyThreadState* __tstate = wxPyBeginAllowThreads();
20323 result = (wxPNGHandler *)new wxPNGHandler();
20324 wxPyEndAllowThreads(__tstate);
20325 if (PyErr_Occurred()) SWIG_fail;
20326 }
20327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20328 return resultobj;
20329 fail:
20330 return NULL;
20331 }
20332
20333
20334 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20335 PyObject *obj;
20336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20337 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20338 return SWIG_Py_Void();
20339 }
20340
20341 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20342 return SWIG_Python_InitShadowInstance(args);
20343 }
20344
20345 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20346 PyObject *resultobj = 0;
20347 wxGIFHandler *result = 0 ;
20348
20349 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20350 {
20351 PyThreadState* __tstate = wxPyBeginAllowThreads();
20352 result = (wxGIFHandler *)new wxGIFHandler();
20353 wxPyEndAllowThreads(__tstate);
20354 if (PyErr_Occurred()) SWIG_fail;
20355 }
20356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20357 return resultobj;
20358 fail:
20359 return NULL;
20360 }
20361
20362
20363 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20364 PyObject *obj;
20365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20366 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20367 return SWIG_Py_Void();
20368 }
20369
20370 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20371 return SWIG_Python_InitShadowInstance(args);
20372 }
20373
20374 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20375 PyObject *resultobj = 0;
20376 wxPCXHandler *result = 0 ;
20377
20378 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20379 {
20380 PyThreadState* __tstate = wxPyBeginAllowThreads();
20381 result = (wxPCXHandler *)new wxPCXHandler();
20382 wxPyEndAllowThreads(__tstate);
20383 if (PyErr_Occurred()) SWIG_fail;
20384 }
20385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20386 return resultobj;
20387 fail:
20388 return NULL;
20389 }
20390
20391
20392 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20393 PyObject *obj;
20394 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20395 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20396 return SWIG_Py_Void();
20397 }
20398
20399 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20400 return SWIG_Python_InitShadowInstance(args);
20401 }
20402
20403 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20404 PyObject *resultobj = 0;
20405 wxJPEGHandler *result = 0 ;
20406
20407 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20408 {
20409 PyThreadState* __tstate = wxPyBeginAllowThreads();
20410 result = (wxJPEGHandler *)new wxJPEGHandler();
20411 wxPyEndAllowThreads(__tstate);
20412 if (PyErr_Occurred()) SWIG_fail;
20413 }
20414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20415 return resultobj;
20416 fail:
20417 return NULL;
20418 }
20419
20420
20421 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20422 PyObject *obj;
20423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20424 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20425 return SWIG_Py_Void();
20426 }
20427
20428 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20429 return SWIG_Python_InitShadowInstance(args);
20430 }
20431
20432 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20433 PyObject *resultobj = 0;
20434 wxPNMHandler *result = 0 ;
20435
20436 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20437 {
20438 PyThreadState* __tstate = wxPyBeginAllowThreads();
20439 result = (wxPNMHandler *)new wxPNMHandler();
20440 wxPyEndAllowThreads(__tstate);
20441 if (PyErr_Occurred()) SWIG_fail;
20442 }
20443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20444 return resultobj;
20445 fail:
20446 return NULL;
20447 }
20448
20449
20450 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20451 PyObject *obj;
20452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20453 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20454 return SWIG_Py_Void();
20455 }
20456
20457 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20458 return SWIG_Python_InitShadowInstance(args);
20459 }
20460
20461 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20462 PyObject *resultobj = 0;
20463 wxXPMHandler *result = 0 ;
20464
20465 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20466 {
20467 PyThreadState* __tstate = wxPyBeginAllowThreads();
20468 result = (wxXPMHandler *)new wxXPMHandler();
20469 wxPyEndAllowThreads(__tstate);
20470 if (PyErr_Occurred()) SWIG_fail;
20471 }
20472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20473 return resultobj;
20474 fail:
20475 return NULL;
20476 }
20477
20478
20479 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20480 PyObject *obj;
20481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20482 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20483 return SWIG_Py_Void();
20484 }
20485
20486 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20487 return SWIG_Python_InitShadowInstance(args);
20488 }
20489
20490 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20491 PyObject *resultobj = 0;
20492 wxTIFFHandler *result = 0 ;
20493
20494 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20495 {
20496 PyThreadState* __tstate = wxPyBeginAllowThreads();
20497 result = (wxTIFFHandler *)new wxTIFFHandler();
20498 wxPyEndAllowThreads(__tstate);
20499 if (PyErr_Occurred()) SWIG_fail;
20500 }
20501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20502 return resultobj;
20503 fail:
20504 return NULL;
20505 }
20506
20507
20508 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20509 PyObject *obj;
20510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20511 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20512 return SWIG_Py_Void();
20513 }
20514
20515 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20516 return SWIG_Python_InitShadowInstance(args);
20517 }
20518
20519 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20520 PyObject *resultobj = 0;
20521 wxTGAHandler *result = 0 ;
20522
20523 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
20524 {
20525 PyThreadState* __tstate = wxPyBeginAllowThreads();
20526 result = (wxTGAHandler *)new wxTGAHandler();
20527 wxPyEndAllowThreads(__tstate);
20528 if (PyErr_Occurred()) SWIG_fail;
20529 }
20530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
20531 return resultobj;
20532 fail:
20533 return NULL;
20534 }
20535
20536
20537 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20538 PyObject *obj;
20539 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20540 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
20541 return SWIG_Py_Void();
20542 }
20543
20544 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20545 return SWIG_Python_InitShadowInstance(args);
20546 }
20547
20548 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20549 PyObject *resultobj = 0;
20550 wxImage *arg1 = 0 ;
20551 wxImage *arg2 = 0 ;
20552 int arg3 = (int) 236 ;
20553 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20554 bool result;
20555 void *argp1 = 0 ;
20556 int res1 = 0 ;
20557 void *argp2 = 0 ;
20558 int res2 = 0 ;
20559 int val3 ;
20560 int ecode3 = 0 ;
20561 int val4 ;
20562 int ecode4 = 0 ;
20563 PyObject * obj0 = 0 ;
20564 PyObject * obj1 = 0 ;
20565 PyObject * obj2 = 0 ;
20566 PyObject * obj3 = 0 ;
20567 char * kwnames[] = {
20568 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20569 };
20570
20571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20572 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20573 if (!SWIG_IsOK(res1)) {
20574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20575 }
20576 if (!argp1) {
20577 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20578 }
20579 arg1 = reinterpret_cast< wxImage * >(argp1);
20580 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20581 if (!SWIG_IsOK(res2)) {
20582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20583 }
20584 if (!argp2) {
20585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20586 }
20587 arg2 = reinterpret_cast< wxImage * >(argp2);
20588 if (obj2) {
20589 ecode3 = SWIG_AsVal_int(obj2, &val3);
20590 if (!SWIG_IsOK(ecode3)) {
20591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20592 }
20593 arg3 = static_cast< int >(val3);
20594 }
20595 if (obj3) {
20596 ecode4 = SWIG_AsVal_int(obj3, &val4);
20597 if (!SWIG_IsOK(ecode4)) {
20598 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20599 }
20600 arg4 = static_cast< int >(val4);
20601 }
20602 {
20603 PyThreadState* __tstate = wxPyBeginAllowThreads();
20604 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20605 wxPyEndAllowThreads(__tstate);
20606 if (PyErr_Occurred()) SWIG_fail;
20607 }
20608 {
20609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20610 }
20611 return resultobj;
20612 fail:
20613 return NULL;
20614 }
20615
20616
20617 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20618 PyObject *obj;
20619 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20620 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20621 return SWIG_Py_Void();
20622 }
20623
20624 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20625 PyObject *resultobj = 0;
20626 wxEvtHandler *result = 0 ;
20627
20628 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20629 {
20630 PyThreadState* __tstate = wxPyBeginAllowThreads();
20631 result = (wxEvtHandler *)new wxEvtHandler();
20632 wxPyEndAllowThreads(__tstate);
20633 if (PyErr_Occurred()) SWIG_fail;
20634 }
20635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20636 return resultobj;
20637 fail:
20638 return NULL;
20639 }
20640
20641
20642 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20643 PyObject *resultobj = 0;
20644 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20645 wxEvtHandler *result = 0 ;
20646 void *argp1 = 0 ;
20647 int res1 = 0 ;
20648 PyObject *swig_obj[1] ;
20649
20650 if (!args) SWIG_fail;
20651 swig_obj[0] = args;
20652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20653 if (!SWIG_IsOK(res1)) {
20654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20655 }
20656 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20657 {
20658 PyThreadState* __tstate = wxPyBeginAllowThreads();
20659 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20660 wxPyEndAllowThreads(__tstate);
20661 if (PyErr_Occurred()) SWIG_fail;
20662 }
20663 {
20664 resultobj = wxPyMake_wxObject(result, 0);
20665 }
20666 return resultobj;
20667 fail:
20668 return NULL;
20669 }
20670
20671
20672 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20673 PyObject *resultobj = 0;
20674 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20675 wxEvtHandler *result = 0 ;
20676 void *argp1 = 0 ;
20677 int res1 = 0 ;
20678 PyObject *swig_obj[1] ;
20679
20680 if (!args) SWIG_fail;
20681 swig_obj[0] = args;
20682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20683 if (!SWIG_IsOK(res1)) {
20684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20685 }
20686 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20687 {
20688 PyThreadState* __tstate = wxPyBeginAllowThreads();
20689 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20690 wxPyEndAllowThreads(__tstate);
20691 if (PyErr_Occurred()) SWIG_fail;
20692 }
20693 {
20694 resultobj = wxPyMake_wxObject(result, 0);
20695 }
20696 return resultobj;
20697 fail:
20698 return NULL;
20699 }
20700
20701
20702 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20703 PyObject *resultobj = 0;
20704 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20705 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20706 void *argp1 = 0 ;
20707 int res1 = 0 ;
20708 void *argp2 = 0 ;
20709 int res2 = 0 ;
20710 PyObject * obj0 = 0 ;
20711 PyObject * obj1 = 0 ;
20712 char * kwnames[] = {
20713 (char *) "self",(char *) "handler", NULL
20714 };
20715
20716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20718 if (!SWIG_IsOK(res1)) {
20719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20720 }
20721 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20722 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20723 if (!SWIG_IsOK(res2)) {
20724 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20725 }
20726 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20727 {
20728 PyThreadState* __tstate = wxPyBeginAllowThreads();
20729 (arg1)->SetNextHandler(arg2);
20730 wxPyEndAllowThreads(__tstate);
20731 if (PyErr_Occurred()) SWIG_fail;
20732 }
20733 resultobj = SWIG_Py_Void();
20734 return resultobj;
20735 fail:
20736 return NULL;
20737 }
20738
20739
20740 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20741 PyObject *resultobj = 0;
20742 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20743 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20744 void *argp1 = 0 ;
20745 int res1 = 0 ;
20746 void *argp2 = 0 ;
20747 int res2 = 0 ;
20748 PyObject * obj0 = 0 ;
20749 PyObject * obj1 = 0 ;
20750 char * kwnames[] = {
20751 (char *) "self",(char *) "handler", NULL
20752 };
20753
20754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20756 if (!SWIG_IsOK(res1)) {
20757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20758 }
20759 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20760 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20761 if (!SWIG_IsOK(res2)) {
20762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20763 }
20764 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20765 {
20766 PyThreadState* __tstate = wxPyBeginAllowThreads();
20767 (arg1)->SetPreviousHandler(arg2);
20768 wxPyEndAllowThreads(__tstate);
20769 if (PyErr_Occurred()) SWIG_fail;
20770 }
20771 resultobj = SWIG_Py_Void();
20772 return resultobj;
20773 fail:
20774 return NULL;
20775 }
20776
20777
20778 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20779 PyObject *resultobj = 0;
20780 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20781 bool result;
20782 void *argp1 = 0 ;
20783 int res1 = 0 ;
20784 PyObject *swig_obj[1] ;
20785
20786 if (!args) SWIG_fail;
20787 swig_obj[0] = args;
20788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20789 if (!SWIG_IsOK(res1)) {
20790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20791 }
20792 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20793 {
20794 PyThreadState* __tstate = wxPyBeginAllowThreads();
20795 result = (bool)(arg1)->GetEvtHandlerEnabled();
20796 wxPyEndAllowThreads(__tstate);
20797 if (PyErr_Occurred()) SWIG_fail;
20798 }
20799 {
20800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20801 }
20802 return resultobj;
20803 fail:
20804 return NULL;
20805 }
20806
20807
20808 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20809 PyObject *resultobj = 0;
20810 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20811 bool arg2 ;
20812 void *argp1 = 0 ;
20813 int res1 = 0 ;
20814 bool val2 ;
20815 int ecode2 = 0 ;
20816 PyObject * obj0 = 0 ;
20817 PyObject * obj1 = 0 ;
20818 char * kwnames[] = {
20819 (char *) "self",(char *) "enabled", NULL
20820 };
20821
20822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20824 if (!SWIG_IsOK(res1)) {
20825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20826 }
20827 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20828 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20829 if (!SWIG_IsOK(ecode2)) {
20830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20831 }
20832 arg2 = static_cast< bool >(val2);
20833 {
20834 PyThreadState* __tstate = wxPyBeginAllowThreads();
20835 (arg1)->SetEvtHandlerEnabled(arg2);
20836 wxPyEndAllowThreads(__tstate);
20837 if (PyErr_Occurred()) SWIG_fail;
20838 }
20839 resultobj = SWIG_Py_Void();
20840 return resultobj;
20841 fail:
20842 return NULL;
20843 }
20844
20845
20846 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20847 PyObject *resultobj = 0;
20848 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20849 wxEvent *arg2 = 0 ;
20850 bool result;
20851 void *argp1 = 0 ;
20852 int res1 = 0 ;
20853 void *argp2 = 0 ;
20854 int res2 = 0 ;
20855 PyObject * obj0 = 0 ;
20856 PyObject * obj1 = 0 ;
20857 char * kwnames[] = {
20858 (char *) "self",(char *) "event", NULL
20859 };
20860
20861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20863 if (!SWIG_IsOK(res1)) {
20864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20865 }
20866 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20867 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20868 if (!SWIG_IsOK(res2)) {
20869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20870 }
20871 if (!argp2) {
20872 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20873 }
20874 arg2 = reinterpret_cast< wxEvent * >(argp2);
20875 {
20876 PyThreadState* __tstate = wxPyBeginAllowThreads();
20877 result = (bool)(arg1)->ProcessEvent(*arg2);
20878 wxPyEndAllowThreads(__tstate);
20879 if (PyErr_Occurred()) SWIG_fail;
20880 }
20881 {
20882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20883 }
20884 return resultobj;
20885 fail:
20886 return NULL;
20887 }
20888
20889
20890 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20891 PyObject *resultobj = 0;
20892 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20893 wxEvent *arg2 = 0 ;
20894 void *argp1 = 0 ;
20895 int res1 = 0 ;
20896 void *argp2 = 0 ;
20897 int res2 = 0 ;
20898 PyObject * obj0 = 0 ;
20899 PyObject * obj1 = 0 ;
20900 char * kwnames[] = {
20901 (char *) "self",(char *) "event", NULL
20902 };
20903
20904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20906 if (!SWIG_IsOK(res1)) {
20907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20908 }
20909 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20910 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20911 if (!SWIG_IsOK(res2)) {
20912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20913 }
20914 if (!argp2) {
20915 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20916 }
20917 arg2 = reinterpret_cast< wxEvent * >(argp2);
20918 {
20919 PyThreadState* __tstate = wxPyBeginAllowThreads();
20920 (arg1)->AddPendingEvent(*arg2);
20921 wxPyEndAllowThreads(__tstate);
20922 if (PyErr_Occurred()) SWIG_fail;
20923 }
20924 resultobj = SWIG_Py_Void();
20925 return resultobj;
20926 fail:
20927 return NULL;
20928 }
20929
20930
20931 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20932 PyObject *resultobj = 0;
20933 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20934 void *argp1 = 0 ;
20935 int res1 = 0 ;
20936 PyObject *swig_obj[1] ;
20937
20938 if (!args) SWIG_fail;
20939 swig_obj[0] = args;
20940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20941 if (!SWIG_IsOK(res1)) {
20942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20943 }
20944 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20945 {
20946 PyThreadState* __tstate = wxPyBeginAllowThreads();
20947 (arg1)->ProcessPendingEvents();
20948 wxPyEndAllowThreads(__tstate);
20949 if (PyErr_Occurred()) SWIG_fail;
20950 }
20951 resultobj = SWIG_Py_Void();
20952 return resultobj;
20953 fail:
20954 return NULL;
20955 }
20956
20957
20958 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20959 PyObject *resultobj = 0;
20960 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20961 int arg2 ;
20962 int arg3 ;
20963 int arg4 ;
20964 PyObject *arg5 = (PyObject *) 0 ;
20965 void *argp1 = 0 ;
20966 int res1 = 0 ;
20967 int val2 ;
20968 int ecode2 = 0 ;
20969 int val3 ;
20970 int ecode3 = 0 ;
20971 int val4 ;
20972 int ecode4 = 0 ;
20973 PyObject * obj0 = 0 ;
20974 PyObject * obj1 = 0 ;
20975 PyObject * obj2 = 0 ;
20976 PyObject * obj3 = 0 ;
20977 PyObject * obj4 = 0 ;
20978 char * kwnames[] = {
20979 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20980 };
20981
20982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20984 if (!SWIG_IsOK(res1)) {
20985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20986 }
20987 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20988 ecode2 = SWIG_AsVal_int(obj1, &val2);
20989 if (!SWIG_IsOK(ecode2)) {
20990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20991 }
20992 arg2 = static_cast< int >(val2);
20993 ecode3 = SWIG_AsVal_int(obj2, &val3);
20994 if (!SWIG_IsOK(ecode3)) {
20995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20996 }
20997 arg3 = static_cast< int >(val3);
20998 ecode4 = SWIG_AsVal_int(obj3, &val4);
20999 if (!SWIG_IsOK(ecode4)) {
21000 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
21001 }
21002 arg4 = static_cast< int >(val4);
21003 arg5 = obj4;
21004 {
21005 PyThreadState* __tstate = wxPyBeginAllowThreads();
21006 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
21007 wxPyEndAllowThreads(__tstate);
21008 if (PyErr_Occurred()) SWIG_fail;
21009 }
21010 resultobj = SWIG_Py_Void();
21011 return resultobj;
21012 fail:
21013 return NULL;
21014 }
21015
21016
21017 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21018 PyObject *resultobj = 0;
21019 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21020 int arg2 ;
21021 int arg3 = (int) -1 ;
21022 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
21023 bool result;
21024 void *argp1 = 0 ;
21025 int res1 = 0 ;
21026 int val2 ;
21027 int ecode2 = 0 ;
21028 int val3 ;
21029 int ecode3 = 0 ;
21030 int val4 ;
21031 int ecode4 = 0 ;
21032 PyObject * obj0 = 0 ;
21033 PyObject * obj1 = 0 ;
21034 PyObject * obj2 = 0 ;
21035 PyObject * obj3 = 0 ;
21036 char * kwnames[] = {
21037 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
21038 };
21039
21040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21042 if (!SWIG_IsOK(res1)) {
21043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21044 }
21045 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21046 ecode2 = SWIG_AsVal_int(obj1, &val2);
21047 if (!SWIG_IsOK(ecode2)) {
21048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
21049 }
21050 arg2 = static_cast< int >(val2);
21051 if (obj2) {
21052 ecode3 = SWIG_AsVal_int(obj2, &val3);
21053 if (!SWIG_IsOK(ecode3)) {
21054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
21055 }
21056 arg3 = static_cast< int >(val3);
21057 }
21058 if (obj3) {
21059 ecode4 = SWIG_AsVal_int(obj3, &val4);
21060 if (!SWIG_IsOK(ecode4)) {
21061 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
21062 }
21063 arg4 = static_cast< wxEventType >(val4);
21064 }
21065 {
21066 PyThreadState* __tstate = wxPyBeginAllowThreads();
21067 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
21068 wxPyEndAllowThreads(__tstate);
21069 if (PyErr_Occurred()) SWIG_fail;
21070 }
21071 {
21072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21073 }
21074 return resultobj;
21075 fail:
21076 return NULL;
21077 }
21078
21079
21080 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21081 PyObject *resultobj = 0;
21082 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21083 PyObject *arg2 = (PyObject *) 0 ;
21084 bool arg3 = (bool) true ;
21085 void *argp1 = 0 ;
21086 int res1 = 0 ;
21087 bool val3 ;
21088 int ecode3 = 0 ;
21089 PyObject * obj0 = 0 ;
21090 PyObject * obj1 = 0 ;
21091 PyObject * obj2 = 0 ;
21092 char * kwnames[] = {
21093 (char *) "self",(char *) "_self",(char *) "incref", NULL
21094 };
21095
21096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21098 if (!SWIG_IsOK(res1)) {
21099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21100 }
21101 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21102 arg2 = obj1;
21103 if (obj2) {
21104 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21105 if (!SWIG_IsOK(ecode3)) {
21106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21107 }
21108 arg3 = static_cast< bool >(val3);
21109 }
21110 {
21111 PyThreadState* __tstate = wxPyBeginAllowThreads();
21112 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21113 wxPyEndAllowThreads(__tstate);
21114 if (PyErr_Occurred()) SWIG_fail;
21115 }
21116 resultobj = SWIG_Py_Void();
21117 return resultobj;
21118 fail:
21119 return NULL;
21120 }
21121
21122
21123 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21124 PyObject *obj;
21125 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21126 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21127 return SWIG_Py_Void();
21128 }
21129
21130 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21131 return SWIG_Python_InitShadowInstance(args);
21132 }
21133
21134 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21135 PyObject *resultobj = 0;
21136 wxEventType result;
21137
21138 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21139 {
21140 PyThreadState* __tstate = wxPyBeginAllowThreads();
21141 result = (wxEventType)wxNewEventType();
21142 wxPyEndAllowThreads(__tstate);
21143 if (PyErr_Occurred()) SWIG_fail;
21144 }
21145 resultobj = SWIG_From_int(static_cast< int >(result));
21146 return resultobj;
21147 fail:
21148 return NULL;
21149 }
21150
21151
21152 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21153 PyObject *resultobj = 0;
21154 wxEvent *arg1 = (wxEvent *) 0 ;
21155 void *argp1 = 0 ;
21156 int res1 = 0 ;
21157 PyObject *swig_obj[1] ;
21158
21159 if (!args) SWIG_fail;
21160 swig_obj[0] = args;
21161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21162 if (!SWIG_IsOK(res1)) {
21163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21164 }
21165 arg1 = reinterpret_cast< wxEvent * >(argp1);
21166 {
21167 PyThreadState* __tstate = wxPyBeginAllowThreads();
21168 delete arg1;
21169
21170 wxPyEndAllowThreads(__tstate);
21171 if (PyErr_Occurred()) SWIG_fail;
21172 }
21173 resultobj = SWIG_Py_Void();
21174 return resultobj;
21175 fail:
21176 return NULL;
21177 }
21178
21179
21180 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21181 PyObject *resultobj = 0;
21182 wxEvent *arg1 = (wxEvent *) 0 ;
21183 wxEventType arg2 ;
21184 void *argp1 = 0 ;
21185 int res1 = 0 ;
21186 int val2 ;
21187 int ecode2 = 0 ;
21188 PyObject * obj0 = 0 ;
21189 PyObject * obj1 = 0 ;
21190 char * kwnames[] = {
21191 (char *) "self",(char *) "typ", NULL
21192 };
21193
21194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21196 if (!SWIG_IsOK(res1)) {
21197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21198 }
21199 arg1 = reinterpret_cast< wxEvent * >(argp1);
21200 ecode2 = SWIG_AsVal_int(obj1, &val2);
21201 if (!SWIG_IsOK(ecode2)) {
21202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21203 }
21204 arg2 = static_cast< wxEventType >(val2);
21205 {
21206 PyThreadState* __tstate = wxPyBeginAllowThreads();
21207 (arg1)->SetEventType(arg2);
21208 wxPyEndAllowThreads(__tstate);
21209 if (PyErr_Occurred()) SWIG_fail;
21210 }
21211 resultobj = SWIG_Py_Void();
21212 return resultobj;
21213 fail:
21214 return NULL;
21215 }
21216
21217
21218 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21219 PyObject *resultobj = 0;
21220 wxEvent *arg1 = (wxEvent *) 0 ;
21221 wxEventType result;
21222 void *argp1 = 0 ;
21223 int res1 = 0 ;
21224 PyObject *swig_obj[1] ;
21225
21226 if (!args) SWIG_fail;
21227 swig_obj[0] = args;
21228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21229 if (!SWIG_IsOK(res1)) {
21230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21231 }
21232 arg1 = reinterpret_cast< wxEvent * >(argp1);
21233 {
21234 PyThreadState* __tstate = wxPyBeginAllowThreads();
21235 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21236 wxPyEndAllowThreads(__tstate);
21237 if (PyErr_Occurred()) SWIG_fail;
21238 }
21239 resultobj = SWIG_From_int(static_cast< int >(result));
21240 return resultobj;
21241 fail:
21242 return NULL;
21243 }
21244
21245
21246 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21247 PyObject *resultobj = 0;
21248 wxEvent *arg1 = (wxEvent *) 0 ;
21249 wxObject *result = 0 ;
21250 void *argp1 = 0 ;
21251 int res1 = 0 ;
21252 PyObject *swig_obj[1] ;
21253
21254 if (!args) SWIG_fail;
21255 swig_obj[0] = args;
21256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21257 if (!SWIG_IsOK(res1)) {
21258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21259 }
21260 arg1 = reinterpret_cast< wxEvent * >(argp1);
21261 {
21262 PyThreadState* __tstate = wxPyBeginAllowThreads();
21263 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21264 wxPyEndAllowThreads(__tstate);
21265 if (PyErr_Occurred()) SWIG_fail;
21266 }
21267 {
21268 resultobj = wxPyMake_wxObject(result, (bool)0);
21269 }
21270 return resultobj;
21271 fail:
21272 return NULL;
21273 }
21274
21275
21276 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21277 PyObject *resultobj = 0;
21278 wxEvent *arg1 = (wxEvent *) 0 ;
21279 wxObject *arg2 = (wxObject *) 0 ;
21280 void *argp1 = 0 ;
21281 int res1 = 0 ;
21282 void *argp2 = 0 ;
21283 int res2 = 0 ;
21284 PyObject * obj0 = 0 ;
21285 PyObject * obj1 = 0 ;
21286 char * kwnames[] = {
21287 (char *) "self",(char *) "obj", NULL
21288 };
21289
21290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21292 if (!SWIG_IsOK(res1)) {
21293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21294 }
21295 arg1 = reinterpret_cast< wxEvent * >(argp1);
21296 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21297 if (!SWIG_IsOK(res2)) {
21298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21299 }
21300 arg2 = reinterpret_cast< wxObject * >(argp2);
21301 {
21302 PyThreadState* __tstate = wxPyBeginAllowThreads();
21303 (arg1)->SetEventObject(arg2);
21304 wxPyEndAllowThreads(__tstate);
21305 if (PyErr_Occurred()) SWIG_fail;
21306 }
21307 resultobj = SWIG_Py_Void();
21308 return resultobj;
21309 fail:
21310 return NULL;
21311 }
21312
21313
21314 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21315 PyObject *resultobj = 0;
21316 wxEvent *arg1 = (wxEvent *) 0 ;
21317 long result;
21318 void *argp1 = 0 ;
21319 int res1 = 0 ;
21320 PyObject *swig_obj[1] ;
21321
21322 if (!args) SWIG_fail;
21323 swig_obj[0] = args;
21324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21325 if (!SWIG_IsOK(res1)) {
21326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21327 }
21328 arg1 = reinterpret_cast< wxEvent * >(argp1);
21329 {
21330 PyThreadState* __tstate = wxPyBeginAllowThreads();
21331 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21332 wxPyEndAllowThreads(__tstate);
21333 if (PyErr_Occurred()) SWIG_fail;
21334 }
21335 resultobj = SWIG_From_long(static_cast< long >(result));
21336 return resultobj;
21337 fail:
21338 return NULL;
21339 }
21340
21341
21342 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21343 PyObject *resultobj = 0;
21344 wxEvent *arg1 = (wxEvent *) 0 ;
21345 long arg2 = (long) 0 ;
21346 void *argp1 = 0 ;
21347 int res1 = 0 ;
21348 long val2 ;
21349 int ecode2 = 0 ;
21350 PyObject * obj0 = 0 ;
21351 PyObject * obj1 = 0 ;
21352 char * kwnames[] = {
21353 (char *) "self",(char *) "ts", NULL
21354 };
21355
21356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21358 if (!SWIG_IsOK(res1)) {
21359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21360 }
21361 arg1 = reinterpret_cast< wxEvent * >(argp1);
21362 if (obj1) {
21363 ecode2 = SWIG_AsVal_long(obj1, &val2);
21364 if (!SWIG_IsOK(ecode2)) {
21365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21366 }
21367 arg2 = static_cast< long >(val2);
21368 }
21369 {
21370 PyThreadState* __tstate = wxPyBeginAllowThreads();
21371 (arg1)->SetTimestamp(arg2);
21372 wxPyEndAllowThreads(__tstate);
21373 if (PyErr_Occurred()) SWIG_fail;
21374 }
21375 resultobj = SWIG_Py_Void();
21376 return resultobj;
21377 fail:
21378 return NULL;
21379 }
21380
21381
21382 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21383 PyObject *resultobj = 0;
21384 wxEvent *arg1 = (wxEvent *) 0 ;
21385 int result;
21386 void *argp1 = 0 ;
21387 int res1 = 0 ;
21388 PyObject *swig_obj[1] ;
21389
21390 if (!args) SWIG_fail;
21391 swig_obj[0] = args;
21392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21393 if (!SWIG_IsOK(res1)) {
21394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21395 }
21396 arg1 = reinterpret_cast< wxEvent * >(argp1);
21397 {
21398 PyThreadState* __tstate = wxPyBeginAllowThreads();
21399 result = (int)((wxEvent const *)arg1)->GetId();
21400 wxPyEndAllowThreads(__tstate);
21401 if (PyErr_Occurred()) SWIG_fail;
21402 }
21403 resultobj = SWIG_From_int(static_cast< int >(result));
21404 return resultobj;
21405 fail:
21406 return NULL;
21407 }
21408
21409
21410 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21411 PyObject *resultobj = 0;
21412 wxEvent *arg1 = (wxEvent *) 0 ;
21413 int arg2 ;
21414 void *argp1 = 0 ;
21415 int res1 = 0 ;
21416 int val2 ;
21417 int ecode2 = 0 ;
21418 PyObject * obj0 = 0 ;
21419 PyObject * obj1 = 0 ;
21420 char * kwnames[] = {
21421 (char *) "self",(char *) "Id", NULL
21422 };
21423
21424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21426 if (!SWIG_IsOK(res1)) {
21427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21428 }
21429 arg1 = reinterpret_cast< wxEvent * >(argp1);
21430 ecode2 = SWIG_AsVal_int(obj1, &val2);
21431 if (!SWIG_IsOK(ecode2)) {
21432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21433 }
21434 arg2 = static_cast< int >(val2);
21435 {
21436 PyThreadState* __tstate = wxPyBeginAllowThreads();
21437 (arg1)->SetId(arg2);
21438 wxPyEndAllowThreads(__tstate);
21439 if (PyErr_Occurred()) SWIG_fail;
21440 }
21441 resultobj = SWIG_Py_Void();
21442 return resultobj;
21443 fail:
21444 return NULL;
21445 }
21446
21447
21448 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21449 PyObject *resultobj = 0;
21450 wxEvent *arg1 = (wxEvent *) 0 ;
21451 bool result;
21452 void *argp1 = 0 ;
21453 int res1 = 0 ;
21454 PyObject *swig_obj[1] ;
21455
21456 if (!args) SWIG_fail;
21457 swig_obj[0] = args;
21458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21459 if (!SWIG_IsOK(res1)) {
21460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21461 }
21462 arg1 = reinterpret_cast< wxEvent * >(argp1);
21463 {
21464 PyThreadState* __tstate = wxPyBeginAllowThreads();
21465 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21466 wxPyEndAllowThreads(__tstate);
21467 if (PyErr_Occurred()) SWIG_fail;
21468 }
21469 {
21470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21471 }
21472 return resultobj;
21473 fail:
21474 return NULL;
21475 }
21476
21477
21478 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21479 PyObject *resultobj = 0;
21480 wxEvent *arg1 = (wxEvent *) 0 ;
21481 bool arg2 = (bool) true ;
21482 void *argp1 = 0 ;
21483 int res1 = 0 ;
21484 bool val2 ;
21485 int ecode2 = 0 ;
21486 PyObject * obj0 = 0 ;
21487 PyObject * obj1 = 0 ;
21488 char * kwnames[] = {
21489 (char *) "self",(char *) "skip", NULL
21490 };
21491
21492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21494 if (!SWIG_IsOK(res1)) {
21495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21496 }
21497 arg1 = reinterpret_cast< wxEvent * >(argp1);
21498 if (obj1) {
21499 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21500 if (!SWIG_IsOK(ecode2)) {
21501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21502 }
21503 arg2 = static_cast< bool >(val2);
21504 }
21505 {
21506 PyThreadState* __tstate = wxPyBeginAllowThreads();
21507 (arg1)->Skip(arg2);
21508 wxPyEndAllowThreads(__tstate);
21509 if (PyErr_Occurred()) SWIG_fail;
21510 }
21511 resultobj = SWIG_Py_Void();
21512 return resultobj;
21513 fail:
21514 return NULL;
21515 }
21516
21517
21518 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21519 PyObject *resultobj = 0;
21520 wxEvent *arg1 = (wxEvent *) 0 ;
21521 bool result;
21522 void *argp1 = 0 ;
21523 int res1 = 0 ;
21524 PyObject *swig_obj[1] ;
21525
21526 if (!args) SWIG_fail;
21527 swig_obj[0] = args;
21528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21529 if (!SWIG_IsOK(res1)) {
21530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21531 }
21532 arg1 = reinterpret_cast< wxEvent * >(argp1);
21533 {
21534 PyThreadState* __tstate = wxPyBeginAllowThreads();
21535 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21536 wxPyEndAllowThreads(__tstate);
21537 if (PyErr_Occurred()) SWIG_fail;
21538 }
21539 {
21540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21541 }
21542 return resultobj;
21543 fail:
21544 return NULL;
21545 }
21546
21547
21548 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21549 PyObject *resultobj = 0;
21550 wxEvent *arg1 = (wxEvent *) 0 ;
21551 bool result;
21552 void *argp1 = 0 ;
21553 int res1 = 0 ;
21554 PyObject *swig_obj[1] ;
21555
21556 if (!args) SWIG_fail;
21557 swig_obj[0] = args;
21558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21559 if (!SWIG_IsOK(res1)) {
21560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21561 }
21562 arg1 = reinterpret_cast< wxEvent * >(argp1);
21563 {
21564 PyThreadState* __tstate = wxPyBeginAllowThreads();
21565 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21566 wxPyEndAllowThreads(__tstate);
21567 if (PyErr_Occurred()) SWIG_fail;
21568 }
21569 {
21570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21571 }
21572 return resultobj;
21573 fail:
21574 return NULL;
21575 }
21576
21577
21578 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21579 PyObject *resultobj = 0;
21580 wxEvent *arg1 = (wxEvent *) 0 ;
21581 int result;
21582 void *argp1 = 0 ;
21583 int res1 = 0 ;
21584 PyObject *swig_obj[1] ;
21585
21586 if (!args) SWIG_fail;
21587 swig_obj[0] = args;
21588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21589 if (!SWIG_IsOK(res1)) {
21590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21591 }
21592 arg1 = reinterpret_cast< wxEvent * >(argp1);
21593 {
21594 PyThreadState* __tstate = wxPyBeginAllowThreads();
21595 result = (int)(arg1)->StopPropagation();
21596 wxPyEndAllowThreads(__tstate);
21597 if (PyErr_Occurred()) SWIG_fail;
21598 }
21599 resultobj = SWIG_From_int(static_cast< int >(result));
21600 return resultobj;
21601 fail:
21602 return NULL;
21603 }
21604
21605
21606 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21607 PyObject *resultobj = 0;
21608 wxEvent *arg1 = (wxEvent *) 0 ;
21609 int arg2 ;
21610 void *argp1 = 0 ;
21611 int res1 = 0 ;
21612 int val2 ;
21613 int ecode2 = 0 ;
21614 PyObject * obj0 = 0 ;
21615 PyObject * obj1 = 0 ;
21616 char * kwnames[] = {
21617 (char *) "self",(char *) "propagationLevel", NULL
21618 };
21619
21620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21622 if (!SWIG_IsOK(res1)) {
21623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21624 }
21625 arg1 = reinterpret_cast< wxEvent * >(argp1);
21626 ecode2 = SWIG_AsVal_int(obj1, &val2);
21627 if (!SWIG_IsOK(ecode2)) {
21628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21629 }
21630 arg2 = static_cast< int >(val2);
21631 {
21632 PyThreadState* __tstate = wxPyBeginAllowThreads();
21633 (arg1)->ResumePropagation(arg2);
21634 wxPyEndAllowThreads(__tstate);
21635 if (PyErr_Occurred()) SWIG_fail;
21636 }
21637 resultobj = SWIG_Py_Void();
21638 return resultobj;
21639 fail:
21640 return NULL;
21641 }
21642
21643
21644 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21645 PyObject *resultobj = 0;
21646 wxEvent *arg1 = (wxEvent *) 0 ;
21647 wxEvent *result = 0 ;
21648 void *argp1 = 0 ;
21649 int res1 = 0 ;
21650 PyObject *swig_obj[1] ;
21651
21652 if (!args) SWIG_fail;
21653 swig_obj[0] = args;
21654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21655 if (!SWIG_IsOK(res1)) {
21656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21657 }
21658 arg1 = reinterpret_cast< wxEvent * >(argp1);
21659 {
21660 PyThreadState* __tstate = wxPyBeginAllowThreads();
21661 result = (wxEvent *)(arg1)->Clone();
21662 wxPyEndAllowThreads(__tstate);
21663 if (PyErr_Occurred()) SWIG_fail;
21664 }
21665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21666 return resultobj;
21667 fail:
21668 return NULL;
21669 }
21670
21671
21672 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21673 PyObject *obj;
21674 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21675 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21676 return SWIG_Py_Void();
21677 }
21678
21679 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21680 PyObject *resultobj = 0;
21681 wxEvent *arg1 = 0 ;
21682 wxPropagationDisabler *result = 0 ;
21683 void *argp1 = 0 ;
21684 int res1 = 0 ;
21685 PyObject * obj0 = 0 ;
21686 char * kwnames[] = {
21687 (char *) "event", NULL
21688 };
21689
21690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21691 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21692 if (!SWIG_IsOK(res1)) {
21693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21694 }
21695 if (!argp1) {
21696 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21697 }
21698 arg1 = reinterpret_cast< wxEvent * >(argp1);
21699 {
21700 PyThreadState* __tstate = wxPyBeginAllowThreads();
21701 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21702 wxPyEndAllowThreads(__tstate);
21703 if (PyErr_Occurred()) SWIG_fail;
21704 }
21705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21706 return resultobj;
21707 fail:
21708 return NULL;
21709 }
21710
21711
21712 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21713 PyObject *resultobj = 0;
21714 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21715 void *argp1 = 0 ;
21716 int res1 = 0 ;
21717 PyObject *swig_obj[1] ;
21718
21719 if (!args) SWIG_fail;
21720 swig_obj[0] = args;
21721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21722 if (!SWIG_IsOK(res1)) {
21723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21724 }
21725 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21726 {
21727 PyThreadState* __tstate = wxPyBeginAllowThreads();
21728 delete arg1;
21729
21730 wxPyEndAllowThreads(__tstate);
21731 if (PyErr_Occurred()) SWIG_fail;
21732 }
21733 resultobj = SWIG_Py_Void();
21734 return resultobj;
21735 fail:
21736 return NULL;
21737 }
21738
21739
21740 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21741 PyObject *obj;
21742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21743 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21744 return SWIG_Py_Void();
21745 }
21746
21747 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21748 return SWIG_Python_InitShadowInstance(args);
21749 }
21750
21751 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21752 PyObject *resultobj = 0;
21753 wxEvent *arg1 = 0 ;
21754 wxPropagateOnce *result = 0 ;
21755 void *argp1 = 0 ;
21756 int res1 = 0 ;
21757 PyObject * obj0 = 0 ;
21758 char * kwnames[] = {
21759 (char *) "event", NULL
21760 };
21761
21762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21763 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21764 if (!SWIG_IsOK(res1)) {
21765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21766 }
21767 if (!argp1) {
21768 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21769 }
21770 arg1 = reinterpret_cast< wxEvent * >(argp1);
21771 {
21772 PyThreadState* __tstate = wxPyBeginAllowThreads();
21773 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21774 wxPyEndAllowThreads(__tstate);
21775 if (PyErr_Occurred()) SWIG_fail;
21776 }
21777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21778 return resultobj;
21779 fail:
21780 return NULL;
21781 }
21782
21783
21784 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21785 PyObject *resultobj = 0;
21786 wxPropagateOnce *arg1 = (wxPropagateOnce *) 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_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21794 if (!SWIG_IsOK(res1)) {
21795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21796 }
21797 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21798 {
21799 PyThreadState* __tstate = wxPyBeginAllowThreads();
21800 delete arg1;
21801
21802 wxPyEndAllowThreads(__tstate);
21803 if (PyErr_Occurred()) SWIG_fail;
21804 }
21805 resultobj = SWIG_Py_Void();
21806 return resultobj;
21807 fail:
21808 return NULL;
21809 }
21810
21811
21812 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21813 PyObject *obj;
21814 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21815 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21816 return SWIG_Py_Void();
21817 }
21818
21819 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21820 return SWIG_Python_InitShadowInstance(args);
21821 }
21822
21823 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21824 PyObject *resultobj = 0;
21825 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21826 int arg2 = (int) 0 ;
21827 wxCommandEvent *result = 0 ;
21828 int val1 ;
21829 int ecode1 = 0 ;
21830 int val2 ;
21831 int ecode2 = 0 ;
21832 PyObject * obj0 = 0 ;
21833 PyObject * obj1 = 0 ;
21834 char * kwnames[] = {
21835 (char *) "commandType",(char *) "winid", NULL
21836 };
21837
21838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21839 if (obj0) {
21840 ecode1 = SWIG_AsVal_int(obj0, &val1);
21841 if (!SWIG_IsOK(ecode1)) {
21842 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21843 }
21844 arg1 = static_cast< wxEventType >(val1);
21845 }
21846 if (obj1) {
21847 ecode2 = SWIG_AsVal_int(obj1, &val2);
21848 if (!SWIG_IsOK(ecode2)) {
21849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21850 }
21851 arg2 = static_cast< int >(val2);
21852 }
21853 {
21854 PyThreadState* __tstate = wxPyBeginAllowThreads();
21855 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21856 wxPyEndAllowThreads(__tstate);
21857 if (PyErr_Occurred()) SWIG_fail;
21858 }
21859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21860 return resultobj;
21861 fail:
21862 return NULL;
21863 }
21864
21865
21866 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21867 PyObject *resultobj = 0;
21868 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21869 int result;
21870 void *argp1 = 0 ;
21871 int res1 = 0 ;
21872 PyObject *swig_obj[1] ;
21873
21874 if (!args) SWIG_fail;
21875 swig_obj[0] = args;
21876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21877 if (!SWIG_IsOK(res1)) {
21878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21879 }
21880 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21881 {
21882 PyThreadState* __tstate = wxPyBeginAllowThreads();
21883 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21884 wxPyEndAllowThreads(__tstate);
21885 if (PyErr_Occurred()) SWIG_fail;
21886 }
21887 resultobj = SWIG_From_int(static_cast< int >(result));
21888 return resultobj;
21889 fail:
21890 return NULL;
21891 }
21892
21893
21894 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21895 PyObject *resultobj = 0;
21896 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21897 wxString *arg2 = 0 ;
21898 void *argp1 = 0 ;
21899 int res1 = 0 ;
21900 bool temp2 = false ;
21901 PyObject * obj0 = 0 ;
21902 PyObject * obj1 = 0 ;
21903 char * kwnames[] = {
21904 (char *) "self",(char *) "s", NULL
21905 };
21906
21907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21909 if (!SWIG_IsOK(res1)) {
21910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21911 }
21912 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21913 {
21914 arg2 = wxString_in_helper(obj1);
21915 if (arg2 == NULL) SWIG_fail;
21916 temp2 = true;
21917 }
21918 {
21919 PyThreadState* __tstate = wxPyBeginAllowThreads();
21920 (arg1)->SetString((wxString const &)*arg2);
21921 wxPyEndAllowThreads(__tstate);
21922 if (PyErr_Occurred()) SWIG_fail;
21923 }
21924 resultobj = SWIG_Py_Void();
21925 {
21926 if (temp2)
21927 delete arg2;
21928 }
21929 return resultobj;
21930 fail:
21931 {
21932 if (temp2)
21933 delete arg2;
21934 }
21935 return NULL;
21936 }
21937
21938
21939 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21940 PyObject *resultobj = 0;
21941 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21942 wxString result;
21943 void *argp1 = 0 ;
21944 int res1 = 0 ;
21945 PyObject *swig_obj[1] ;
21946
21947 if (!args) SWIG_fail;
21948 swig_obj[0] = args;
21949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21950 if (!SWIG_IsOK(res1)) {
21951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21952 }
21953 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21954 {
21955 PyThreadState* __tstate = wxPyBeginAllowThreads();
21956 result = ((wxCommandEvent const *)arg1)->GetString();
21957 wxPyEndAllowThreads(__tstate);
21958 if (PyErr_Occurred()) SWIG_fail;
21959 }
21960 {
21961 #if wxUSE_UNICODE
21962 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21963 #else
21964 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21965 #endif
21966 }
21967 return resultobj;
21968 fail:
21969 return NULL;
21970 }
21971
21972
21973 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21974 PyObject *resultobj = 0;
21975 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21976 bool result;
21977 void *argp1 = 0 ;
21978 int res1 = 0 ;
21979 PyObject *swig_obj[1] ;
21980
21981 if (!args) SWIG_fail;
21982 swig_obj[0] = args;
21983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21984 if (!SWIG_IsOK(res1)) {
21985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21986 }
21987 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21988 {
21989 PyThreadState* __tstate = wxPyBeginAllowThreads();
21990 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21991 wxPyEndAllowThreads(__tstate);
21992 if (PyErr_Occurred()) SWIG_fail;
21993 }
21994 {
21995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21996 }
21997 return resultobj;
21998 fail:
21999 return NULL;
22000 }
22001
22002
22003 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22004 PyObject *resultobj = 0;
22005 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22006 bool result;
22007 void *argp1 = 0 ;
22008 int res1 = 0 ;
22009 PyObject *swig_obj[1] ;
22010
22011 if (!args) SWIG_fail;
22012 swig_obj[0] = args;
22013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22014 if (!SWIG_IsOK(res1)) {
22015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22016 }
22017 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22018 {
22019 PyThreadState* __tstate = wxPyBeginAllowThreads();
22020 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
22021 wxPyEndAllowThreads(__tstate);
22022 if (PyErr_Occurred()) SWIG_fail;
22023 }
22024 {
22025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22026 }
22027 return resultobj;
22028 fail:
22029 return NULL;
22030 }
22031
22032
22033 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22034 PyObject *resultobj = 0;
22035 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22036 long arg2 ;
22037 void *argp1 = 0 ;
22038 int res1 = 0 ;
22039 long val2 ;
22040 int ecode2 = 0 ;
22041 PyObject * obj0 = 0 ;
22042 PyObject * obj1 = 0 ;
22043 char * kwnames[] = {
22044 (char *) "self",(char *) "extraLong", NULL
22045 };
22046
22047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
22048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22049 if (!SWIG_IsOK(res1)) {
22050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22051 }
22052 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22053 ecode2 = SWIG_AsVal_long(obj1, &val2);
22054 if (!SWIG_IsOK(ecode2)) {
22055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
22056 }
22057 arg2 = static_cast< long >(val2);
22058 {
22059 PyThreadState* __tstate = wxPyBeginAllowThreads();
22060 (arg1)->SetExtraLong(arg2);
22061 wxPyEndAllowThreads(__tstate);
22062 if (PyErr_Occurred()) SWIG_fail;
22063 }
22064 resultobj = SWIG_Py_Void();
22065 return resultobj;
22066 fail:
22067 return NULL;
22068 }
22069
22070
22071 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22072 PyObject *resultobj = 0;
22073 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22074 long result;
22075 void *argp1 = 0 ;
22076 int res1 = 0 ;
22077 PyObject *swig_obj[1] ;
22078
22079 if (!args) SWIG_fail;
22080 swig_obj[0] = args;
22081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22082 if (!SWIG_IsOK(res1)) {
22083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22084 }
22085 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22086 {
22087 PyThreadState* __tstate = wxPyBeginAllowThreads();
22088 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22089 wxPyEndAllowThreads(__tstate);
22090 if (PyErr_Occurred()) SWIG_fail;
22091 }
22092 resultobj = SWIG_From_long(static_cast< long >(result));
22093 return resultobj;
22094 fail:
22095 return NULL;
22096 }
22097
22098
22099 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22100 PyObject *resultobj = 0;
22101 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22102 int arg2 ;
22103 void *argp1 = 0 ;
22104 int res1 = 0 ;
22105 int val2 ;
22106 int ecode2 = 0 ;
22107 PyObject * obj0 = 0 ;
22108 PyObject * obj1 = 0 ;
22109 char * kwnames[] = {
22110 (char *) "self",(char *) "i", NULL
22111 };
22112
22113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22115 if (!SWIG_IsOK(res1)) {
22116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22117 }
22118 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22119 ecode2 = SWIG_AsVal_int(obj1, &val2);
22120 if (!SWIG_IsOK(ecode2)) {
22121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22122 }
22123 arg2 = static_cast< int >(val2);
22124 {
22125 PyThreadState* __tstate = wxPyBeginAllowThreads();
22126 (arg1)->SetInt(arg2);
22127 wxPyEndAllowThreads(__tstate);
22128 if (PyErr_Occurred()) SWIG_fail;
22129 }
22130 resultobj = SWIG_Py_Void();
22131 return resultobj;
22132 fail:
22133 return NULL;
22134 }
22135
22136
22137 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22138 PyObject *resultobj = 0;
22139 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22140 int result;
22141 void *argp1 = 0 ;
22142 int res1 = 0 ;
22143 PyObject *swig_obj[1] ;
22144
22145 if (!args) SWIG_fail;
22146 swig_obj[0] = args;
22147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22148 if (!SWIG_IsOK(res1)) {
22149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22150 }
22151 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22152 {
22153 PyThreadState* __tstate = wxPyBeginAllowThreads();
22154 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22155 wxPyEndAllowThreads(__tstate);
22156 if (PyErr_Occurred()) SWIG_fail;
22157 }
22158 resultobj = SWIG_From_int(static_cast< int >(result));
22159 return resultobj;
22160 fail:
22161 return NULL;
22162 }
22163
22164
22165 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22166 PyObject *resultobj = 0;
22167 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22168 PyObject *result = 0 ;
22169 void *argp1 = 0 ;
22170 int res1 = 0 ;
22171 PyObject *swig_obj[1] ;
22172
22173 if (!args) SWIG_fail;
22174 swig_obj[0] = args;
22175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22176 if (!SWIG_IsOK(res1)) {
22177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22178 }
22179 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22180 {
22181 PyThreadState* __tstate = wxPyBeginAllowThreads();
22182 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22183 wxPyEndAllowThreads(__tstate);
22184 if (PyErr_Occurred()) SWIG_fail;
22185 }
22186 resultobj = result;
22187 return resultobj;
22188 fail:
22189 return NULL;
22190 }
22191
22192
22193 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22194 PyObject *resultobj = 0;
22195 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22196 PyObject *arg2 = (PyObject *) 0 ;
22197 void *argp1 = 0 ;
22198 int res1 = 0 ;
22199 PyObject * obj0 = 0 ;
22200 PyObject * obj1 = 0 ;
22201 char * kwnames[] = {
22202 (char *) "self",(char *) "clientData", NULL
22203 };
22204
22205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22207 if (!SWIG_IsOK(res1)) {
22208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22209 }
22210 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22211 arg2 = obj1;
22212 {
22213 PyThreadState* __tstate = wxPyBeginAllowThreads();
22214 wxCommandEvent_SetClientData(arg1,arg2);
22215 wxPyEndAllowThreads(__tstate);
22216 if (PyErr_Occurred()) SWIG_fail;
22217 }
22218 resultobj = SWIG_Py_Void();
22219 return resultobj;
22220 fail:
22221 return NULL;
22222 }
22223
22224
22225 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22226 PyObject *resultobj = 0;
22227 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22228 wxEvent *result = 0 ;
22229 void *argp1 = 0 ;
22230 int res1 = 0 ;
22231 PyObject *swig_obj[1] ;
22232
22233 if (!args) SWIG_fail;
22234 swig_obj[0] = args;
22235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22236 if (!SWIG_IsOK(res1)) {
22237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22238 }
22239 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22240 {
22241 PyThreadState* __tstate = wxPyBeginAllowThreads();
22242 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22243 wxPyEndAllowThreads(__tstate);
22244 if (PyErr_Occurred()) SWIG_fail;
22245 }
22246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22247 return resultobj;
22248 fail:
22249 return NULL;
22250 }
22251
22252
22253 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22254 PyObject *obj;
22255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22256 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22257 return SWIG_Py_Void();
22258 }
22259
22260 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22261 return SWIG_Python_InitShadowInstance(args);
22262 }
22263
22264 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22265 PyObject *resultobj = 0;
22266 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22267 int arg2 = (int) 0 ;
22268 wxNotifyEvent *result = 0 ;
22269 int val1 ;
22270 int ecode1 = 0 ;
22271 int val2 ;
22272 int ecode2 = 0 ;
22273 PyObject * obj0 = 0 ;
22274 PyObject * obj1 = 0 ;
22275 char * kwnames[] = {
22276 (char *) "commandType",(char *) "winid", NULL
22277 };
22278
22279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22280 if (obj0) {
22281 ecode1 = SWIG_AsVal_int(obj0, &val1);
22282 if (!SWIG_IsOK(ecode1)) {
22283 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22284 }
22285 arg1 = static_cast< wxEventType >(val1);
22286 }
22287 if (obj1) {
22288 ecode2 = SWIG_AsVal_int(obj1, &val2);
22289 if (!SWIG_IsOK(ecode2)) {
22290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22291 }
22292 arg2 = static_cast< int >(val2);
22293 }
22294 {
22295 PyThreadState* __tstate = wxPyBeginAllowThreads();
22296 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22297 wxPyEndAllowThreads(__tstate);
22298 if (PyErr_Occurred()) SWIG_fail;
22299 }
22300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22301 return resultobj;
22302 fail:
22303 return NULL;
22304 }
22305
22306
22307 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22308 PyObject *resultobj = 0;
22309 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22310 void *argp1 = 0 ;
22311 int res1 = 0 ;
22312 PyObject *swig_obj[1] ;
22313
22314 if (!args) SWIG_fail;
22315 swig_obj[0] = args;
22316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22317 if (!SWIG_IsOK(res1)) {
22318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22319 }
22320 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22321 {
22322 PyThreadState* __tstate = wxPyBeginAllowThreads();
22323 (arg1)->Veto();
22324 wxPyEndAllowThreads(__tstate);
22325 if (PyErr_Occurred()) SWIG_fail;
22326 }
22327 resultobj = SWIG_Py_Void();
22328 return resultobj;
22329 fail:
22330 return NULL;
22331 }
22332
22333
22334 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22335 PyObject *resultobj = 0;
22336 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22337 void *argp1 = 0 ;
22338 int res1 = 0 ;
22339 PyObject *swig_obj[1] ;
22340
22341 if (!args) SWIG_fail;
22342 swig_obj[0] = args;
22343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22344 if (!SWIG_IsOK(res1)) {
22345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22346 }
22347 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22348 {
22349 PyThreadState* __tstate = wxPyBeginAllowThreads();
22350 (arg1)->Allow();
22351 wxPyEndAllowThreads(__tstate);
22352 if (PyErr_Occurred()) SWIG_fail;
22353 }
22354 resultobj = SWIG_Py_Void();
22355 return resultobj;
22356 fail:
22357 return NULL;
22358 }
22359
22360
22361 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22362 PyObject *resultobj = 0;
22363 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22364 bool result;
22365 void *argp1 = 0 ;
22366 int res1 = 0 ;
22367 PyObject *swig_obj[1] ;
22368
22369 if (!args) SWIG_fail;
22370 swig_obj[0] = args;
22371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22372 if (!SWIG_IsOK(res1)) {
22373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22374 }
22375 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22376 {
22377 PyThreadState* __tstate = wxPyBeginAllowThreads();
22378 result = (bool)(arg1)->IsAllowed();
22379 wxPyEndAllowThreads(__tstate);
22380 if (PyErr_Occurred()) SWIG_fail;
22381 }
22382 {
22383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22384 }
22385 return resultobj;
22386 fail:
22387 return NULL;
22388 }
22389
22390
22391 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22392 PyObject *obj;
22393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22394 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22395 return SWIG_Py_Void();
22396 }
22397
22398 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22399 return SWIG_Python_InitShadowInstance(args);
22400 }
22401
22402 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22403 PyObject *resultobj = 0;
22404 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22405 int arg2 = (int) 0 ;
22406 int arg3 = (int) 0 ;
22407 int arg4 = (int) 0 ;
22408 wxScrollEvent *result = 0 ;
22409 int val1 ;
22410 int ecode1 = 0 ;
22411 int val2 ;
22412 int ecode2 = 0 ;
22413 int val3 ;
22414 int ecode3 = 0 ;
22415 int val4 ;
22416 int ecode4 = 0 ;
22417 PyObject * obj0 = 0 ;
22418 PyObject * obj1 = 0 ;
22419 PyObject * obj2 = 0 ;
22420 PyObject * obj3 = 0 ;
22421 char * kwnames[] = {
22422 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22423 };
22424
22425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22426 if (obj0) {
22427 ecode1 = SWIG_AsVal_int(obj0, &val1);
22428 if (!SWIG_IsOK(ecode1)) {
22429 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22430 }
22431 arg1 = static_cast< wxEventType >(val1);
22432 }
22433 if (obj1) {
22434 ecode2 = SWIG_AsVal_int(obj1, &val2);
22435 if (!SWIG_IsOK(ecode2)) {
22436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22437 }
22438 arg2 = static_cast< int >(val2);
22439 }
22440 if (obj2) {
22441 ecode3 = SWIG_AsVal_int(obj2, &val3);
22442 if (!SWIG_IsOK(ecode3)) {
22443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22444 }
22445 arg3 = static_cast< int >(val3);
22446 }
22447 if (obj3) {
22448 ecode4 = SWIG_AsVal_int(obj3, &val4);
22449 if (!SWIG_IsOK(ecode4)) {
22450 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22451 }
22452 arg4 = static_cast< int >(val4);
22453 }
22454 {
22455 PyThreadState* __tstate = wxPyBeginAllowThreads();
22456 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22457 wxPyEndAllowThreads(__tstate);
22458 if (PyErr_Occurred()) SWIG_fail;
22459 }
22460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22461 return resultobj;
22462 fail:
22463 return NULL;
22464 }
22465
22466
22467 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22468 PyObject *resultobj = 0;
22469 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22470 int result;
22471 void *argp1 = 0 ;
22472 int res1 = 0 ;
22473 PyObject *swig_obj[1] ;
22474
22475 if (!args) SWIG_fail;
22476 swig_obj[0] = args;
22477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22478 if (!SWIG_IsOK(res1)) {
22479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22480 }
22481 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22482 {
22483 PyThreadState* __tstate = wxPyBeginAllowThreads();
22484 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22485 wxPyEndAllowThreads(__tstate);
22486 if (PyErr_Occurred()) SWIG_fail;
22487 }
22488 resultobj = SWIG_From_int(static_cast< int >(result));
22489 return resultobj;
22490 fail:
22491 return NULL;
22492 }
22493
22494
22495 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22496 PyObject *resultobj = 0;
22497 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22498 int result;
22499 void *argp1 = 0 ;
22500 int res1 = 0 ;
22501 PyObject *swig_obj[1] ;
22502
22503 if (!args) SWIG_fail;
22504 swig_obj[0] = args;
22505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22506 if (!SWIG_IsOK(res1)) {
22507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22508 }
22509 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22510 {
22511 PyThreadState* __tstate = wxPyBeginAllowThreads();
22512 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22513 wxPyEndAllowThreads(__tstate);
22514 if (PyErr_Occurred()) SWIG_fail;
22515 }
22516 resultobj = SWIG_From_int(static_cast< int >(result));
22517 return resultobj;
22518 fail:
22519 return NULL;
22520 }
22521
22522
22523 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22524 PyObject *resultobj = 0;
22525 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22526 int arg2 ;
22527 void *argp1 = 0 ;
22528 int res1 = 0 ;
22529 int val2 ;
22530 int ecode2 = 0 ;
22531 PyObject * obj0 = 0 ;
22532 PyObject * obj1 = 0 ;
22533 char * kwnames[] = {
22534 (char *) "self",(char *) "orient", NULL
22535 };
22536
22537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22539 if (!SWIG_IsOK(res1)) {
22540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22541 }
22542 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22543 ecode2 = SWIG_AsVal_int(obj1, &val2);
22544 if (!SWIG_IsOK(ecode2)) {
22545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22546 }
22547 arg2 = static_cast< int >(val2);
22548 {
22549 PyThreadState* __tstate = wxPyBeginAllowThreads();
22550 (arg1)->SetOrientation(arg2);
22551 wxPyEndAllowThreads(__tstate);
22552 if (PyErr_Occurred()) SWIG_fail;
22553 }
22554 resultobj = SWIG_Py_Void();
22555 return resultobj;
22556 fail:
22557 return NULL;
22558 }
22559
22560
22561 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22562 PyObject *resultobj = 0;
22563 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22564 int arg2 ;
22565 void *argp1 = 0 ;
22566 int res1 = 0 ;
22567 int val2 ;
22568 int ecode2 = 0 ;
22569 PyObject * obj0 = 0 ;
22570 PyObject * obj1 = 0 ;
22571 char * kwnames[] = {
22572 (char *) "self",(char *) "pos", NULL
22573 };
22574
22575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22577 if (!SWIG_IsOK(res1)) {
22578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22579 }
22580 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22581 ecode2 = SWIG_AsVal_int(obj1, &val2);
22582 if (!SWIG_IsOK(ecode2)) {
22583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22584 }
22585 arg2 = static_cast< int >(val2);
22586 {
22587 PyThreadState* __tstate = wxPyBeginAllowThreads();
22588 (arg1)->SetPosition(arg2);
22589 wxPyEndAllowThreads(__tstate);
22590 if (PyErr_Occurred()) SWIG_fail;
22591 }
22592 resultobj = SWIG_Py_Void();
22593 return resultobj;
22594 fail:
22595 return NULL;
22596 }
22597
22598
22599 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22600 PyObject *obj;
22601 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22602 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22603 return SWIG_Py_Void();
22604 }
22605
22606 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22607 return SWIG_Python_InitShadowInstance(args);
22608 }
22609
22610 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22611 PyObject *resultobj = 0;
22612 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22613 int arg2 = (int) 0 ;
22614 int arg3 = (int) 0 ;
22615 wxScrollWinEvent *result = 0 ;
22616 int val1 ;
22617 int ecode1 = 0 ;
22618 int val2 ;
22619 int ecode2 = 0 ;
22620 int val3 ;
22621 int ecode3 = 0 ;
22622 PyObject * obj0 = 0 ;
22623 PyObject * obj1 = 0 ;
22624 PyObject * obj2 = 0 ;
22625 char * kwnames[] = {
22626 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22627 };
22628
22629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22630 if (obj0) {
22631 ecode1 = SWIG_AsVal_int(obj0, &val1);
22632 if (!SWIG_IsOK(ecode1)) {
22633 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22634 }
22635 arg1 = static_cast< wxEventType >(val1);
22636 }
22637 if (obj1) {
22638 ecode2 = SWIG_AsVal_int(obj1, &val2);
22639 if (!SWIG_IsOK(ecode2)) {
22640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22641 }
22642 arg2 = static_cast< int >(val2);
22643 }
22644 if (obj2) {
22645 ecode3 = SWIG_AsVal_int(obj2, &val3);
22646 if (!SWIG_IsOK(ecode3)) {
22647 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22648 }
22649 arg3 = static_cast< int >(val3);
22650 }
22651 {
22652 PyThreadState* __tstate = wxPyBeginAllowThreads();
22653 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22654 wxPyEndAllowThreads(__tstate);
22655 if (PyErr_Occurred()) SWIG_fail;
22656 }
22657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22658 return resultobj;
22659 fail:
22660 return NULL;
22661 }
22662
22663
22664 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22665 PyObject *resultobj = 0;
22666 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22667 int result;
22668 void *argp1 = 0 ;
22669 int res1 = 0 ;
22670 PyObject *swig_obj[1] ;
22671
22672 if (!args) SWIG_fail;
22673 swig_obj[0] = args;
22674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22675 if (!SWIG_IsOK(res1)) {
22676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22677 }
22678 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22679 {
22680 PyThreadState* __tstate = wxPyBeginAllowThreads();
22681 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22682 wxPyEndAllowThreads(__tstate);
22683 if (PyErr_Occurred()) SWIG_fail;
22684 }
22685 resultobj = SWIG_From_int(static_cast< int >(result));
22686 return resultobj;
22687 fail:
22688 return NULL;
22689 }
22690
22691
22692 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22693 PyObject *resultobj = 0;
22694 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22695 int result;
22696 void *argp1 = 0 ;
22697 int res1 = 0 ;
22698 PyObject *swig_obj[1] ;
22699
22700 if (!args) SWIG_fail;
22701 swig_obj[0] = args;
22702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22703 if (!SWIG_IsOK(res1)) {
22704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22705 }
22706 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22707 {
22708 PyThreadState* __tstate = wxPyBeginAllowThreads();
22709 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22710 wxPyEndAllowThreads(__tstate);
22711 if (PyErr_Occurred()) SWIG_fail;
22712 }
22713 resultobj = SWIG_From_int(static_cast< int >(result));
22714 return resultobj;
22715 fail:
22716 return NULL;
22717 }
22718
22719
22720 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22721 PyObject *resultobj = 0;
22722 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22723 int arg2 ;
22724 void *argp1 = 0 ;
22725 int res1 = 0 ;
22726 int val2 ;
22727 int ecode2 = 0 ;
22728 PyObject * obj0 = 0 ;
22729 PyObject * obj1 = 0 ;
22730 char * kwnames[] = {
22731 (char *) "self",(char *) "orient", NULL
22732 };
22733
22734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22736 if (!SWIG_IsOK(res1)) {
22737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22738 }
22739 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22740 ecode2 = SWIG_AsVal_int(obj1, &val2);
22741 if (!SWIG_IsOK(ecode2)) {
22742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22743 }
22744 arg2 = static_cast< int >(val2);
22745 {
22746 PyThreadState* __tstate = wxPyBeginAllowThreads();
22747 (arg1)->SetOrientation(arg2);
22748 wxPyEndAllowThreads(__tstate);
22749 if (PyErr_Occurred()) SWIG_fail;
22750 }
22751 resultobj = SWIG_Py_Void();
22752 return resultobj;
22753 fail:
22754 return NULL;
22755 }
22756
22757
22758 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22759 PyObject *resultobj = 0;
22760 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22761 int arg2 ;
22762 void *argp1 = 0 ;
22763 int res1 = 0 ;
22764 int val2 ;
22765 int ecode2 = 0 ;
22766 PyObject * obj0 = 0 ;
22767 PyObject * obj1 = 0 ;
22768 char * kwnames[] = {
22769 (char *) "self",(char *) "pos", NULL
22770 };
22771
22772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22774 if (!SWIG_IsOK(res1)) {
22775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22776 }
22777 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22778 ecode2 = SWIG_AsVal_int(obj1, &val2);
22779 if (!SWIG_IsOK(ecode2)) {
22780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22781 }
22782 arg2 = static_cast< int >(val2);
22783 {
22784 PyThreadState* __tstate = wxPyBeginAllowThreads();
22785 (arg1)->SetPosition(arg2);
22786 wxPyEndAllowThreads(__tstate);
22787 if (PyErr_Occurred()) SWIG_fail;
22788 }
22789 resultobj = SWIG_Py_Void();
22790 return resultobj;
22791 fail:
22792 return NULL;
22793 }
22794
22795
22796 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22797 PyObject *obj;
22798 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22799 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22800 return SWIG_Py_Void();
22801 }
22802
22803 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22804 return SWIG_Python_InitShadowInstance(args);
22805 }
22806
22807 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22808 PyObject *resultobj = 0;
22809 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22810 wxMouseEvent *result = 0 ;
22811 int val1 ;
22812 int ecode1 = 0 ;
22813 PyObject * obj0 = 0 ;
22814 char * kwnames[] = {
22815 (char *) "mouseType", NULL
22816 };
22817
22818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22819 if (obj0) {
22820 ecode1 = SWIG_AsVal_int(obj0, &val1);
22821 if (!SWIG_IsOK(ecode1)) {
22822 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22823 }
22824 arg1 = static_cast< wxEventType >(val1);
22825 }
22826 {
22827 PyThreadState* __tstate = wxPyBeginAllowThreads();
22828 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22829 wxPyEndAllowThreads(__tstate);
22830 if (PyErr_Occurred()) SWIG_fail;
22831 }
22832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22833 return resultobj;
22834 fail:
22835 return NULL;
22836 }
22837
22838
22839 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22840 PyObject *resultobj = 0;
22841 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22842 bool result;
22843 void *argp1 = 0 ;
22844 int res1 = 0 ;
22845 PyObject *swig_obj[1] ;
22846
22847 if (!args) SWIG_fail;
22848 swig_obj[0] = args;
22849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22850 if (!SWIG_IsOK(res1)) {
22851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22852 }
22853 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22854 {
22855 PyThreadState* __tstate = wxPyBeginAllowThreads();
22856 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22857 wxPyEndAllowThreads(__tstate);
22858 if (PyErr_Occurred()) SWIG_fail;
22859 }
22860 {
22861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22862 }
22863 return resultobj;
22864 fail:
22865 return NULL;
22866 }
22867
22868
22869 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22870 PyObject *resultobj = 0;
22871 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22872 int arg2 = (int) wxMOUSE_BTN_ANY ;
22873 bool result;
22874 void *argp1 = 0 ;
22875 int res1 = 0 ;
22876 int val2 ;
22877 int ecode2 = 0 ;
22878 PyObject * obj0 = 0 ;
22879 PyObject * obj1 = 0 ;
22880 char * kwnames[] = {
22881 (char *) "self",(char *) "but", NULL
22882 };
22883
22884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22886 if (!SWIG_IsOK(res1)) {
22887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22888 }
22889 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22890 if (obj1) {
22891 ecode2 = SWIG_AsVal_int(obj1, &val2);
22892 if (!SWIG_IsOK(ecode2)) {
22893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22894 }
22895 arg2 = static_cast< int >(val2);
22896 }
22897 {
22898 PyThreadState* __tstate = wxPyBeginAllowThreads();
22899 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22900 wxPyEndAllowThreads(__tstate);
22901 if (PyErr_Occurred()) SWIG_fail;
22902 }
22903 {
22904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22905 }
22906 return resultobj;
22907 fail:
22908 return NULL;
22909 }
22910
22911
22912 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22913 PyObject *resultobj = 0;
22914 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22915 int arg2 = (int) wxMOUSE_BTN_ANY ;
22916 bool result;
22917 void *argp1 = 0 ;
22918 int res1 = 0 ;
22919 int val2 ;
22920 int ecode2 = 0 ;
22921 PyObject * obj0 = 0 ;
22922 PyObject * obj1 = 0 ;
22923 char * kwnames[] = {
22924 (char *) "self",(char *) "but", NULL
22925 };
22926
22927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22929 if (!SWIG_IsOK(res1)) {
22930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22931 }
22932 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22933 if (obj1) {
22934 ecode2 = SWIG_AsVal_int(obj1, &val2);
22935 if (!SWIG_IsOK(ecode2)) {
22936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22937 }
22938 arg2 = static_cast< int >(val2);
22939 }
22940 {
22941 PyThreadState* __tstate = wxPyBeginAllowThreads();
22942 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22943 wxPyEndAllowThreads(__tstate);
22944 if (PyErr_Occurred()) SWIG_fail;
22945 }
22946 {
22947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22948 }
22949 return resultobj;
22950 fail:
22951 return NULL;
22952 }
22953
22954
22955 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22956 PyObject *resultobj = 0;
22957 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22958 int arg2 = (int) wxMOUSE_BTN_ANY ;
22959 bool result;
22960 void *argp1 = 0 ;
22961 int res1 = 0 ;
22962 int val2 ;
22963 int ecode2 = 0 ;
22964 PyObject * obj0 = 0 ;
22965 PyObject * obj1 = 0 ;
22966 char * kwnames[] = {
22967 (char *) "self",(char *) "but", NULL
22968 };
22969
22970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22972 if (!SWIG_IsOK(res1)) {
22973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22974 }
22975 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22976 if (obj1) {
22977 ecode2 = SWIG_AsVal_int(obj1, &val2);
22978 if (!SWIG_IsOK(ecode2)) {
22979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22980 }
22981 arg2 = static_cast< int >(val2);
22982 }
22983 {
22984 PyThreadState* __tstate = wxPyBeginAllowThreads();
22985 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22986 wxPyEndAllowThreads(__tstate);
22987 if (PyErr_Occurred()) SWIG_fail;
22988 }
22989 {
22990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22991 }
22992 return resultobj;
22993 fail:
22994 return NULL;
22995 }
22996
22997
22998 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22999 PyObject *resultobj = 0;
23000 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23001 int arg2 ;
23002 bool result;
23003 void *argp1 = 0 ;
23004 int res1 = 0 ;
23005 int val2 ;
23006 int ecode2 = 0 ;
23007 PyObject * obj0 = 0 ;
23008 PyObject * obj1 = 0 ;
23009 char * kwnames[] = {
23010 (char *) "self",(char *) "button", NULL
23011 };
23012
23013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
23014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23015 if (!SWIG_IsOK(res1)) {
23016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23017 }
23018 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23019 ecode2 = SWIG_AsVal_int(obj1, &val2);
23020 if (!SWIG_IsOK(ecode2)) {
23021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
23022 }
23023 arg2 = static_cast< int >(val2);
23024 {
23025 PyThreadState* __tstate = wxPyBeginAllowThreads();
23026 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
23027 wxPyEndAllowThreads(__tstate);
23028 if (PyErr_Occurred()) SWIG_fail;
23029 }
23030 {
23031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23032 }
23033 return resultobj;
23034 fail:
23035 return NULL;
23036 }
23037
23038
23039 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23040 PyObject *resultobj = 0;
23041 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23042 int arg2 ;
23043 bool result;
23044 void *argp1 = 0 ;
23045 int res1 = 0 ;
23046 int val2 ;
23047 int ecode2 = 0 ;
23048 PyObject * obj0 = 0 ;
23049 PyObject * obj1 = 0 ;
23050 char * kwnames[] = {
23051 (char *) "self",(char *) "but", NULL
23052 };
23053
23054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
23055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23056 if (!SWIG_IsOK(res1)) {
23057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23058 }
23059 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23060 ecode2 = SWIG_AsVal_int(obj1, &val2);
23061 if (!SWIG_IsOK(ecode2)) {
23062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
23063 }
23064 arg2 = static_cast< int >(val2);
23065 {
23066 PyThreadState* __tstate = wxPyBeginAllowThreads();
23067 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23068 wxPyEndAllowThreads(__tstate);
23069 if (PyErr_Occurred()) SWIG_fail;
23070 }
23071 {
23072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23073 }
23074 return resultobj;
23075 fail:
23076 return NULL;
23077 }
23078
23079
23080 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23081 PyObject *resultobj = 0;
23082 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23083 int result;
23084 void *argp1 = 0 ;
23085 int res1 = 0 ;
23086 PyObject *swig_obj[1] ;
23087
23088 if (!args) SWIG_fail;
23089 swig_obj[0] = args;
23090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23091 if (!SWIG_IsOK(res1)) {
23092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23093 }
23094 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23095 {
23096 PyThreadState* __tstate = wxPyBeginAllowThreads();
23097 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23098 wxPyEndAllowThreads(__tstate);
23099 if (PyErr_Occurred()) SWIG_fail;
23100 }
23101 resultobj = SWIG_From_int(static_cast< int >(result));
23102 return resultobj;
23103 fail:
23104 return NULL;
23105 }
23106
23107
23108 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23109 PyObject *resultobj = 0;
23110 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23111 bool result;
23112 void *argp1 = 0 ;
23113 int res1 = 0 ;
23114 PyObject *swig_obj[1] ;
23115
23116 if (!args) SWIG_fail;
23117 swig_obj[0] = args;
23118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23119 if (!SWIG_IsOK(res1)) {
23120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23121 }
23122 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23123 {
23124 PyThreadState* __tstate = wxPyBeginAllowThreads();
23125 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23126 wxPyEndAllowThreads(__tstate);
23127 if (PyErr_Occurred()) SWIG_fail;
23128 }
23129 {
23130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23131 }
23132 return resultobj;
23133 fail:
23134 return NULL;
23135 }
23136
23137
23138 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23139 PyObject *resultobj = 0;
23140 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23141 bool result;
23142 void *argp1 = 0 ;
23143 int res1 = 0 ;
23144 PyObject *swig_obj[1] ;
23145
23146 if (!args) SWIG_fail;
23147 swig_obj[0] = args;
23148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23149 if (!SWIG_IsOK(res1)) {
23150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23151 }
23152 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23153 {
23154 PyThreadState* __tstate = wxPyBeginAllowThreads();
23155 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23156 wxPyEndAllowThreads(__tstate);
23157 if (PyErr_Occurred()) SWIG_fail;
23158 }
23159 {
23160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23161 }
23162 return resultobj;
23163 fail:
23164 return NULL;
23165 }
23166
23167
23168 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23169 PyObject *resultobj = 0;
23170 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23171 bool result;
23172 void *argp1 = 0 ;
23173 int res1 = 0 ;
23174 PyObject *swig_obj[1] ;
23175
23176 if (!args) SWIG_fail;
23177 swig_obj[0] = args;
23178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23179 if (!SWIG_IsOK(res1)) {
23180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23181 }
23182 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23183 {
23184 PyThreadState* __tstate = wxPyBeginAllowThreads();
23185 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23186 wxPyEndAllowThreads(__tstate);
23187 if (PyErr_Occurred()) SWIG_fail;
23188 }
23189 {
23190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23191 }
23192 return resultobj;
23193 fail:
23194 return NULL;
23195 }
23196
23197
23198 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23199 PyObject *resultobj = 0;
23200 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23201 bool result;
23202 void *argp1 = 0 ;
23203 int res1 = 0 ;
23204 PyObject *swig_obj[1] ;
23205
23206 if (!args) SWIG_fail;
23207 swig_obj[0] = args;
23208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23209 if (!SWIG_IsOK(res1)) {
23210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23211 }
23212 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23213 {
23214 PyThreadState* __tstate = wxPyBeginAllowThreads();
23215 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23216 wxPyEndAllowThreads(__tstate);
23217 if (PyErr_Occurred()) SWIG_fail;
23218 }
23219 {
23220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23221 }
23222 return resultobj;
23223 fail:
23224 return NULL;
23225 }
23226
23227
23228 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23229 PyObject *resultobj = 0;
23230 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23231 bool result;
23232 void *argp1 = 0 ;
23233 int res1 = 0 ;
23234 PyObject *swig_obj[1] ;
23235
23236 if (!args) SWIG_fail;
23237 swig_obj[0] = args;
23238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23239 if (!SWIG_IsOK(res1)) {
23240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23241 }
23242 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23243 {
23244 PyThreadState* __tstate = wxPyBeginAllowThreads();
23245 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23246 wxPyEndAllowThreads(__tstate);
23247 if (PyErr_Occurred()) SWIG_fail;
23248 }
23249 {
23250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23251 }
23252 return resultobj;
23253 fail:
23254 return NULL;
23255 }
23256
23257
23258 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23259 PyObject *resultobj = 0;
23260 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23261 bool result;
23262 void *argp1 = 0 ;
23263 int res1 = 0 ;
23264 PyObject *swig_obj[1] ;
23265
23266 if (!args) SWIG_fail;
23267 swig_obj[0] = args;
23268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23269 if (!SWIG_IsOK(res1)) {
23270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23271 }
23272 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23273 {
23274 PyThreadState* __tstate = wxPyBeginAllowThreads();
23275 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23276 wxPyEndAllowThreads(__tstate);
23277 if (PyErr_Occurred()) SWIG_fail;
23278 }
23279 {
23280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23281 }
23282 return resultobj;
23283 fail:
23284 return NULL;
23285 }
23286
23287
23288 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23289 PyObject *resultobj = 0;
23290 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23291 bool result;
23292 void *argp1 = 0 ;
23293 int res1 = 0 ;
23294 PyObject *swig_obj[1] ;
23295
23296 if (!args) SWIG_fail;
23297 swig_obj[0] = args;
23298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23299 if (!SWIG_IsOK(res1)) {
23300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23301 }
23302 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23303 {
23304 PyThreadState* __tstate = wxPyBeginAllowThreads();
23305 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23306 wxPyEndAllowThreads(__tstate);
23307 if (PyErr_Occurred()) SWIG_fail;
23308 }
23309 {
23310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23311 }
23312 return resultobj;
23313 fail:
23314 return NULL;
23315 }
23316
23317
23318 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23319 PyObject *resultobj = 0;
23320 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23321 bool result;
23322 void *argp1 = 0 ;
23323 int res1 = 0 ;
23324 PyObject *swig_obj[1] ;
23325
23326 if (!args) SWIG_fail;
23327 swig_obj[0] = args;
23328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23329 if (!SWIG_IsOK(res1)) {
23330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23331 }
23332 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23333 {
23334 PyThreadState* __tstate = wxPyBeginAllowThreads();
23335 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23336 wxPyEndAllowThreads(__tstate);
23337 if (PyErr_Occurred()) SWIG_fail;
23338 }
23339 {
23340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23341 }
23342 return resultobj;
23343 fail:
23344 return NULL;
23345 }
23346
23347
23348 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23349 PyObject *resultobj = 0;
23350 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23351 bool result;
23352 void *argp1 = 0 ;
23353 int res1 = 0 ;
23354 PyObject *swig_obj[1] ;
23355
23356 if (!args) SWIG_fail;
23357 swig_obj[0] = args;
23358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23359 if (!SWIG_IsOK(res1)) {
23360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23361 }
23362 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23363 {
23364 PyThreadState* __tstate = wxPyBeginAllowThreads();
23365 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23366 wxPyEndAllowThreads(__tstate);
23367 if (PyErr_Occurred()) SWIG_fail;
23368 }
23369 {
23370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23371 }
23372 return resultobj;
23373 fail:
23374 return NULL;
23375 }
23376
23377
23378 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23379 PyObject *resultobj = 0;
23380 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23381 bool result;
23382 void *argp1 = 0 ;
23383 int res1 = 0 ;
23384 PyObject *swig_obj[1] ;
23385
23386 if (!args) SWIG_fail;
23387 swig_obj[0] = args;
23388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23389 if (!SWIG_IsOK(res1)) {
23390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23391 }
23392 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23393 {
23394 PyThreadState* __tstate = wxPyBeginAllowThreads();
23395 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23396 wxPyEndAllowThreads(__tstate);
23397 if (PyErr_Occurred()) SWIG_fail;
23398 }
23399 {
23400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23401 }
23402 return resultobj;
23403 fail:
23404 return NULL;
23405 }
23406
23407
23408 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23409 PyObject *resultobj = 0;
23410 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23411 bool result;
23412 void *argp1 = 0 ;
23413 int res1 = 0 ;
23414 PyObject *swig_obj[1] ;
23415
23416 if (!args) SWIG_fail;
23417 swig_obj[0] = args;
23418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23419 if (!SWIG_IsOK(res1)) {
23420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23421 }
23422 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23423 {
23424 PyThreadState* __tstate = wxPyBeginAllowThreads();
23425 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23426 wxPyEndAllowThreads(__tstate);
23427 if (PyErr_Occurred()) SWIG_fail;
23428 }
23429 {
23430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23431 }
23432 return resultobj;
23433 fail:
23434 return NULL;
23435 }
23436
23437
23438 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23439 PyObject *resultobj = 0;
23440 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23441 bool result;
23442 void *argp1 = 0 ;
23443 int res1 = 0 ;
23444 PyObject *swig_obj[1] ;
23445
23446 if (!args) SWIG_fail;
23447 swig_obj[0] = args;
23448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23449 if (!SWIG_IsOK(res1)) {
23450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23451 }
23452 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23453 {
23454 PyThreadState* __tstate = wxPyBeginAllowThreads();
23455 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23456 wxPyEndAllowThreads(__tstate);
23457 if (PyErr_Occurred()) SWIG_fail;
23458 }
23459 {
23460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23461 }
23462 return resultobj;
23463 fail:
23464 return NULL;
23465 }
23466
23467
23468 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23469 PyObject *resultobj = 0;
23470 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23471 bool result;
23472 void *argp1 = 0 ;
23473 int res1 = 0 ;
23474 PyObject *swig_obj[1] ;
23475
23476 if (!args) SWIG_fail;
23477 swig_obj[0] = args;
23478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23479 if (!SWIG_IsOK(res1)) {
23480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23481 }
23482 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23483 {
23484 PyThreadState* __tstate = wxPyBeginAllowThreads();
23485 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23486 wxPyEndAllowThreads(__tstate);
23487 if (PyErr_Occurred()) SWIG_fail;
23488 }
23489 {
23490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23491 }
23492 return resultobj;
23493 fail:
23494 return NULL;
23495 }
23496
23497
23498 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23499 PyObject *resultobj = 0;
23500 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23501 bool result;
23502 void *argp1 = 0 ;
23503 int res1 = 0 ;
23504 PyObject *swig_obj[1] ;
23505
23506 if (!args) SWIG_fail;
23507 swig_obj[0] = args;
23508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23509 if (!SWIG_IsOK(res1)) {
23510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23511 }
23512 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23513 {
23514 PyThreadState* __tstate = wxPyBeginAllowThreads();
23515 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23516 wxPyEndAllowThreads(__tstate);
23517 if (PyErr_Occurred()) SWIG_fail;
23518 }
23519 {
23520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23521 }
23522 return resultobj;
23523 fail:
23524 return NULL;
23525 }
23526
23527
23528 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23529 PyObject *resultobj = 0;
23530 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23531 bool result;
23532 void *argp1 = 0 ;
23533 int res1 = 0 ;
23534 PyObject *swig_obj[1] ;
23535
23536 if (!args) SWIG_fail;
23537 swig_obj[0] = args;
23538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23539 if (!SWIG_IsOK(res1)) {
23540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23541 }
23542 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23543 {
23544 PyThreadState* __tstate = wxPyBeginAllowThreads();
23545 result = (bool)(arg1)->LeftIsDown();
23546 wxPyEndAllowThreads(__tstate);
23547 if (PyErr_Occurred()) SWIG_fail;
23548 }
23549 {
23550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23551 }
23552 return resultobj;
23553 fail:
23554 return NULL;
23555 }
23556
23557
23558 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23559 PyObject *resultobj = 0;
23560 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23561 bool result;
23562 void *argp1 = 0 ;
23563 int res1 = 0 ;
23564 PyObject *swig_obj[1] ;
23565
23566 if (!args) SWIG_fail;
23567 swig_obj[0] = args;
23568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23569 if (!SWIG_IsOK(res1)) {
23570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23571 }
23572 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23573 {
23574 PyThreadState* __tstate = wxPyBeginAllowThreads();
23575 result = (bool)(arg1)->MiddleIsDown();
23576 wxPyEndAllowThreads(__tstate);
23577 if (PyErr_Occurred()) SWIG_fail;
23578 }
23579 {
23580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23581 }
23582 return resultobj;
23583 fail:
23584 return NULL;
23585 }
23586
23587
23588 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23589 PyObject *resultobj = 0;
23590 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23591 bool result;
23592 void *argp1 = 0 ;
23593 int res1 = 0 ;
23594 PyObject *swig_obj[1] ;
23595
23596 if (!args) SWIG_fail;
23597 swig_obj[0] = args;
23598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23599 if (!SWIG_IsOK(res1)) {
23600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23601 }
23602 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23603 {
23604 PyThreadState* __tstate = wxPyBeginAllowThreads();
23605 result = (bool)(arg1)->RightIsDown();
23606 wxPyEndAllowThreads(__tstate);
23607 if (PyErr_Occurred()) SWIG_fail;
23608 }
23609 {
23610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23611 }
23612 return resultobj;
23613 fail:
23614 return NULL;
23615 }
23616
23617
23618 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23619 PyObject *resultobj = 0;
23620 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23621 bool result;
23622 void *argp1 = 0 ;
23623 int res1 = 0 ;
23624 PyObject *swig_obj[1] ;
23625
23626 if (!args) SWIG_fail;
23627 swig_obj[0] = args;
23628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23629 if (!SWIG_IsOK(res1)) {
23630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23631 }
23632 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23633 {
23634 PyThreadState* __tstate = wxPyBeginAllowThreads();
23635 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23636 wxPyEndAllowThreads(__tstate);
23637 if (PyErr_Occurred()) SWIG_fail;
23638 }
23639 {
23640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23641 }
23642 return resultobj;
23643 fail:
23644 return NULL;
23645 }
23646
23647
23648 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23649 PyObject *resultobj = 0;
23650 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23651 bool result;
23652 void *argp1 = 0 ;
23653 int res1 = 0 ;
23654 PyObject *swig_obj[1] ;
23655
23656 if (!args) SWIG_fail;
23657 swig_obj[0] = args;
23658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23659 if (!SWIG_IsOK(res1)) {
23660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23661 }
23662 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23663 {
23664 PyThreadState* __tstate = wxPyBeginAllowThreads();
23665 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23666 wxPyEndAllowThreads(__tstate);
23667 if (PyErr_Occurred()) SWIG_fail;
23668 }
23669 {
23670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23671 }
23672 return resultobj;
23673 fail:
23674 return NULL;
23675 }
23676
23677
23678 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23679 PyObject *resultobj = 0;
23680 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23681 bool result;
23682 void *argp1 = 0 ;
23683 int res1 = 0 ;
23684 PyObject *swig_obj[1] ;
23685
23686 if (!args) SWIG_fail;
23687 swig_obj[0] = args;
23688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23689 if (!SWIG_IsOK(res1)) {
23690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23691 }
23692 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23693 {
23694 PyThreadState* __tstate = wxPyBeginAllowThreads();
23695 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23696 wxPyEndAllowThreads(__tstate);
23697 if (PyErr_Occurred()) SWIG_fail;
23698 }
23699 {
23700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23701 }
23702 return resultobj;
23703 fail:
23704 return NULL;
23705 }
23706
23707
23708 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23709 PyObject *resultobj = 0;
23710 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23711 bool result;
23712 void *argp1 = 0 ;
23713 int res1 = 0 ;
23714 PyObject *swig_obj[1] ;
23715
23716 if (!args) SWIG_fail;
23717 swig_obj[0] = args;
23718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23719 if (!SWIG_IsOK(res1)) {
23720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23721 }
23722 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23723 {
23724 PyThreadState* __tstate = wxPyBeginAllowThreads();
23725 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23726 wxPyEndAllowThreads(__tstate);
23727 if (PyErr_Occurred()) SWIG_fail;
23728 }
23729 {
23730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23731 }
23732 return resultobj;
23733 fail:
23734 return NULL;
23735 }
23736
23737
23738 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23739 PyObject *resultobj = 0;
23740 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23741 wxPoint result;
23742 void *argp1 = 0 ;
23743 int res1 = 0 ;
23744 PyObject *swig_obj[1] ;
23745
23746 if (!args) SWIG_fail;
23747 swig_obj[0] = args;
23748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23749 if (!SWIG_IsOK(res1)) {
23750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23751 }
23752 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23753 {
23754 PyThreadState* __tstate = wxPyBeginAllowThreads();
23755 result = (arg1)->GetPosition();
23756 wxPyEndAllowThreads(__tstate);
23757 if (PyErr_Occurred()) SWIG_fail;
23758 }
23759 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23760 return resultobj;
23761 fail:
23762 return NULL;
23763 }
23764
23765
23766 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23767 PyObject *resultobj = 0;
23768 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23769 long *arg2 = (long *) 0 ;
23770 long *arg3 = (long *) 0 ;
23771 void *argp1 = 0 ;
23772 int res1 = 0 ;
23773 long temp2 ;
23774 int res2 = SWIG_TMPOBJ ;
23775 long temp3 ;
23776 int res3 = SWIG_TMPOBJ ;
23777 PyObject *swig_obj[1] ;
23778
23779 arg2 = &temp2;
23780 arg3 = &temp3;
23781 if (!args) SWIG_fail;
23782 swig_obj[0] = args;
23783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23784 if (!SWIG_IsOK(res1)) {
23785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23786 }
23787 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23788 {
23789 PyThreadState* __tstate = wxPyBeginAllowThreads();
23790 (arg1)->GetPosition(arg2,arg3);
23791 wxPyEndAllowThreads(__tstate);
23792 if (PyErr_Occurred()) SWIG_fail;
23793 }
23794 resultobj = SWIG_Py_Void();
23795 if (SWIG_IsTmpObj(res2)) {
23796 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23797 } else {
23798 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23799 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23800 }
23801 if (SWIG_IsTmpObj(res3)) {
23802 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23803 } else {
23804 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23806 }
23807 return resultobj;
23808 fail:
23809 return NULL;
23810 }
23811
23812
23813 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23814 PyObject *resultobj = 0;
23815 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23816 wxDC *arg2 = 0 ;
23817 wxPoint result;
23818 void *argp1 = 0 ;
23819 int res1 = 0 ;
23820 void *argp2 = 0 ;
23821 int res2 = 0 ;
23822 PyObject * obj0 = 0 ;
23823 PyObject * obj1 = 0 ;
23824 char * kwnames[] = {
23825 (char *) "self",(char *) "dc", NULL
23826 };
23827
23828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23830 if (!SWIG_IsOK(res1)) {
23831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23832 }
23833 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23834 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23835 if (!SWIG_IsOK(res2)) {
23836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23837 }
23838 if (!argp2) {
23839 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23840 }
23841 arg2 = reinterpret_cast< wxDC * >(argp2);
23842 {
23843 PyThreadState* __tstate = wxPyBeginAllowThreads();
23844 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23845 wxPyEndAllowThreads(__tstate);
23846 if (PyErr_Occurred()) SWIG_fail;
23847 }
23848 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23849 return resultobj;
23850 fail:
23851 return NULL;
23852 }
23853
23854
23855 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23856 PyObject *resultobj = 0;
23857 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23858 int 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_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23868 }
23869 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23870 {
23871 PyThreadState* __tstate = wxPyBeginAllowThreads();
23872 result = (int)((wxMouseEvent const *)arg1)->GetX();
23873 wxPyEndAllowThreads(__tstate);
23874 if (PyErr_Occurred()) SWIG_fail;
23875 }
23876 resultobj = SWIG_From_int(static_cast< int >(result));
23877 return resultobj;
23878 fail:
23879 return NULL;
23880 }
23881
23882
23883 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23884 PyObject *resultobj = 0;
23885 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23886 int result;
23887 void *argp1 = 0 ;
23888 int res1 = 0 ;
23889 PyObject *swig_obj[1] ;
23890
23891 if (!args) SWIG_fail;
23892 swig_obj[0] = args;
23893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23894 if (!SWIG_IsOK(res1)) {
23895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23896 }
23897 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23898 {
23899 PyThreadState* __tstate = wxPyBeginAllowThreads();
23900 result = (int)((wxMouseEvent const *)arg1)->GetY();
23901 wxPyEndAllowThreads(__tstate);
23902 if (PyErr_Occurred()) SWIG_fail;
23903 }
23904 resultobj = SWIG_From_int(static_cast< int >(result));
23905 return resultobj;
23906 fail:
23907 return NULL;
23908 }
23909
23910
23911 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23912 PyObject *resultobj = 0;
23913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23914 int result;
23915 void *argp1 = 0 ;
23916 int res1 = 0 ;
23917 PyObject *swig_obj[1] ;
23918
23919 if (!args) SWIG_fail;
23920 swig_obj[0] = args;
23921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23922 if (!SWIG_IsOK(res1)) {
23923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23924 }
23925 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23926 {
23927 PyThreadState* __tstate = wxPyBeginAllowThreads();
23928 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23929 wxPyEndAllowThreads(__tstate);
23930 if (PyErr_Occurred()) SWIG_fail;
23931 }
23932 resultobj = SWIG_From_int(static_cast< int >(result));
23933 return resultobj;
23934 fail:
23935 return NULL;
23936 }
23937
23938
23939 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23940 PyObject *resultobj = 0;
23941 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23942 int result;
23943 void *argp1 = 0 ;
23944 int res1 = 0 ;
23945 PyObject *swig_obj[1] ;
23946
23947 if (!args) SWIG_fail;
23948 swig_obj[0] = args;
23949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23950 if (!SWIG_IsOK(res1)) {
23951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23952 }
23953 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23954 {
23955 PyThreadState* __tstate = wxPyBeginAllowThreads();
23956 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23957 wxPyEndAllowThreads(__tstate);
23958 if (PyErr_Occurred()) SWIG_fail;
23959 }
23960 resultobj = SWIG_From_int(static_cast< int >(result));
23961 return resultobj;
23962 fail:
23963 return NULL;
23964 }
23965
23966
23967 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelAxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23968 PyObject *resultobj = 0;
23969 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23970 int result;
23971 void *argp1 = 0 ;
23972 int res1 = 0 ;
23973 PyObject *swig_obj[1] ;
23974
23975 if (!args) SWIG_fail;
23976 swig_obj[0] = args;
23977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23978 if (!SWIG_IsOK(res1)) {
23979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelAxis" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23980 }
23981 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23982 {
23983 PyThreadState* __tstate = wxPyBeginAllowThreads();
23984 result = (int)((wxMouseEvent const *)arg1)->GetWheelAxis();
23985 wxPyEndAllowThreads(__tstate);
23986 if (PyErr_Occurred()) SWIG_fail;
23987 }
23988 resultobj = SWIG_From_int(static_cast< int >(result));
23989 return resultobj;
23990 fail:
23991 return NULL;
23992 }
23993
23994
23995 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23996 PyObject *resultobj = 0;
23997 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23998 int result;
23999 void *argp1 = 0 ;
24000 int res1 = 0 ;
24001 PyObject *swig_obj[1] ;
24002
24003 if (!args) SWIG_fail;
24004 swig_obj[0] = args;
24005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24006 if (!SWIG_IsOK(res1)) {
24007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24008 }
24009 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24010 {
24011 PyThreadState* __tstate = wxPyBeginAllowThreads();
24012 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
24013 wxPyEndAllowThreads(__tstate);
24014 if (PyErr_Occurred()) SWIG_fail;
24015 }
24016 resultobj = SWIG_From_int(static_cast< int >(result));
24017 return resultobj;
24018 fail:
24019 return NULL;
24020 }
24021
24022
24023 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24024 PyObject *resultobj = 0;
24025 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24026 bool result;
24027 void *argp1 = 0 ;
24028 int res1 = 0 ;
24029 PyObject *swig_obj[1] ;
24030
24031 if (!args) SWIG_fail;
24032 swig_obj[0] = args;
24033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24034 if (!SWIG_IsOK(res1)) {
24035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24036 }
24037 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24038 {
24039 PyThreadState* __tstate = wxPyBeginAllowThreads();
24040 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
24041 wxPyEndAllowThreads(__tstate);
24042 if (PyErr_Occurred()) SWIG_fail;
24043 }
24044 {
24045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24046 }
24047 return resultobj;
24048 fail:
24049 return NULL;
24050 }
24051
24052
24053 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24054 PyObject *resultobj = 0;
24055 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24056 int arg2 ;
24057 void *argp1 = 0 ;
24058 int res1 = 0 ;
24059 int val2 ;
24060 int ecode2 = 0 ;
24061 PyObject *swig_obj[2] ;
24062
24063 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
24064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24065 if (!SWIG_IsOK(res1)) {
24066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24067 }
24068 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24069 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24070 if (!SWIG_IsOK(ecode2)) {
24071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
24072 }
24073 arg2 = static_cast< int >(val2);
24074 if (arg1) (arg1)->m_x = arg2;
24075
24076 resultobj = SWIG_Py_Void();
24077 return resultobj;
24078 fail:
24079 return NULL;
24080 }
24081
24082
24083 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24084 PyObject *resultobj = 0;
24085 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24086 int result;
24087 void *argp1 = 0 ;
24088 int res1 = 0 ;
24089 PyObject *swig_obj[1] ;
24090
24091 if (!args) SWIG_fail;
24092 swig_obj[0] = args;
24093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24094 if (!SWIG_IsOK(res1)) {
24095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24096 }
24097 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24098 result = (int) ((arg1)->m_x);
24099 resultobj = SWIG_From_int(static_cast< int >(result));
24100 return resultobj;
24101 fail:
24102 return NULL;
24103 }
24104
24105
24106 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24107 PyObject *resultobj = 0;
24108 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24109 int arg2 ;
24110 void *argp1 = 0 ;
24111 int res1 = 0 ;
24112 int val2 ;
24113 int ecode2 = 0 ;
24114 PyObject *swig_obj[2] ;
24115
24116 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24118 if (!SWIG_IsOK(res1)) {
24119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24120 }
24121 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24122 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24123 if (!SWIG_IsOK(ecode2)) {
24124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24125 }
24126 arg2 = static_cast< int >(val2);
24127 if (arg1) (arg1)->m_y = arg2;
24128
24129 resultobj = SWIG_Py_Void();
24130 return resultobj;
24131 fail:
24132 return NULL;
24133 }
24134
24135
24136 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24137 PyObject *resultobj = 0;
24138 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24139 int result;
24140 void *argp1 = 0 ;
24141 int res1 = 0 ;
24142 PyObject *swig_obj[1] ;
24143
24144 if (!args) SWIG_fail;
24145 swig_obj[0] = args;
24146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24147 if (!SWIG_IsOK(res1)) {
24148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24149 }
24150 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24151 result = (int) ((arg1)->m_y);
24152 resultobj = SWIG_From_int(static_cast< int >(result));
24153 return resultobj;
24154 fail:
24155 return NULL;
24156 }
24157
24158
24159 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24160 PyObject *resultobj = 0;
24161 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24162 bool arg2 ;
24163 void *argp1 = 0 ;
24164 int res1 = 0 ;
24165 bool val2 ;
24166 int ecode2 = 0 ;
24167 PyObject *swig_obj[2] ;
24168
24169 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24171 if (!SWIG_IsOK(res1)) {
24172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24173 }
24174 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24175 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24176 if (!SWIG_IsOK(ecode2)) {
24177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24178 }
24179 arg2 = static_cast< bool >(val2);
24180 if (arg1) (arg1)->m_leftDown = arg2;
24181
24182 resultobj = SWIG_Py_Void();
24183 return resultobj;
24184 fail:
24185 return NULL;
24186 }
24187
24188
24189 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24190 PyObject *resultobj = 0;
24191 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24192 bool result;
24193 void *argp1 = 0 ;
24194 int res1 = 0 ;
24195 PyObject *swig_obj[1] ;
24196
24197 if (!args) SWIG_fail;
24198 swig_obj[0] = args;
24199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24200 if (!SWIG_IsOK(res1)) {
24201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24202 }
24203 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24204 result = (bool) ((arg1)->m_leftDown);
24205 {
24206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24207 }
24208 return resultobj;
24209 fail:
24210 return NULL;
24211 }
24212
24213
24214 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24215 PyObject *resultobj = 0;
24216 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24217 bool arg2 ;
24218 void *argp1 = 0 ;
24219 int res1 = 0 ;
24220 bool val2 ;
24221 int ecode2 = 0 ;
24222 PyObject *swig_obj[2] ;
24223
24224 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
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_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24228 }
24229 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24230 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24231 if (!SWIG_IsOK(ecode2)) {
24232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24233 }
24234 arg2 = static_cast< bool >(val2);
24235 if (arg1) (arg1)->m_middleDown = arg2;
24236
24237 resultobj = SWIG_Py_Void();
24238 return resultobj;
24239 fail:
24240 return NULL;
24241 }
24242
24243
24244 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24245 PyObject *resultobj = 0;
24246 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24247 bool result;
24248 void *argp1 = 0 ;
24249 int res1 = 0 ;
24250 PyObject *swig_obj[1] ;
24251
24252 if (!args) SWIG_fail;
24253 swig_obj[0] = args;
24254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24255 if (!SWIG_IsOK(res1)) {
24256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24257 }
24258 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24259 result = (bool) ((arg1)->m_middleDown);
24260 {
24261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24262 }
24263 return resultobj;
24264 fail:
24265 return NULL;
24266 }
24267
24268
24269 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24270 PyObject *resultobj = 0;
24271 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24272 bool arg2 ;
24273 void *argp1 = 0 ;
24274 int res1 = 0 ;
24275 bool val2 ;
24276 int ecode2 = 0 ;
24277 PyObject *swig_obj[2] ;
24278
24279 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24281 if (!SWIG_IsOK(res1)) {
24282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24283 }
24284 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24285 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24286 if (!SWIG_IsOK(ecode2)) {
24287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24288 }
24289 arg2 = static_cast< bool >(val2);
24290 if (arg1) (arg1)->m_rightDown = arg2;
24291
24292 resultobj = SWIG_Py_Void();
24293 return resultobj;
24294 fail:
24295 return NULL;
24296 }
24297
24298
24299 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24300 PyObject *resultobj = 0;
24301 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24302 bool result;
24303 void *argp1 = 0 ;
24304 int res1 = 0 ;
24305 PyObject *swig_obj[1] ;
24306
24307 if (!args) SWIG_fail;
24308 swig_obj[0] = args;
24309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24310 if (!SWIG_IsOK(res1)) {
24311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24312 }
24313 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24314 result = (bool) ((arg1)->m_rightDown);
24315 {
24316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24317 }
24318 return resultobj;
24319 fail:
24320 return NULL;
24321 }
24322
24323
24324 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24325 PyObject *resultobj = 0;
24326 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24327 bool arg2 ;
24328 void *argp1 = 0 ;
24329 int res1 = 0 ;
24330 bool val2 ;
24331 int ecode2 = 0 ;
24332 PyObject *swig_obj[2] ;
24333
24334 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24336 if (!SWIG_IsOK(res1)) {
24337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24338 }
24339 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24340 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24341 if (!SWIG_IsOK(ecode2)) {
24342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24343 }
24344 arg2 = static_cast< bool >(val2);
24345 if (arg1) (arg1)->m_controlDown = arg2;
24346
24347 resultobj = SWIG_Py_Void();
24348 return resultobj;
24349 fail:
24350 return NULL;
24351 }
24352
24353
24354 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24355 PyObject *resultobj = 0;
24356 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24357 bool result;
24358 void *argp1 = 0 ;
24359 int res1 = 0 ;
24360 PyObject *swig_obj[1] ;
24361
24362 if (!args) SWIG_fail;
24363 swig_obj[0] = args;
24364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24365 if (!SWIG_IsOK(res1)) {
24366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24367 }
24368 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24369 result = (bool) ((arg1)->m_controlDown);
24370 {
24371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24372 }
24373 return resultobj;
24374 fail:
24375 return NULL;
24376 }
24377
24378
24379 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24380 PyObject *resultobj = 0;
24381 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24382 bool arg2 ;
24383 void *argp1 = 0 ;
24384 int res1 = 0 ;
24385 bool val2 ;
24386 int ecode2 = 0 ;
24387 PyObject *swig_obj[2] ;
24388
24389 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24391 if (!SWIG_IsOK(res1)) {
24392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24393 }
24394 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24395 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24396 if (!SWIG_IsOK(ecode2)) {
24397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24398 }
24399 arg2 = static_cast< bool >(val2);
24400 if (arg1) (arg1)->m_shiftDown = arg2;
24401
24402 resultobj = SWIG_Py_Void();
24403 return resultobj;
24404 fail:
24405 return NULL;
24406 }
24407
24408
24409 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24410 PyObject *resultobj = 0;
24411 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24412 bool result;
24413 void *argp1 = 0 ;
24414 int res1 = 0 ;
24415 PyObject *swig_obj[1] ;
24416
24417 if (!args) SWIG_fail;
24418 swig_obj[0] = args;
24419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24420 if (!SWIG_IsOK(res1)) {
24421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24422 }
24423 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24424 result = (bool) ((arg1)->m_shiftDown);
24425 {
24426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24427 }
24428 return resultobj;
24429 fail:
24430 return NULL;
24431 }
24432
24433
24434 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24435 PyObject *resultobj = 0;
24436 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24437 bool arg2 ;
24438 void *argp1 = 0 ;
24439 int res1 = 0 ;
24440 bool val2 ;
24441 int ecode2 = 0 ;
24442 PyObject *swig_obj[2] ;
24443
24444 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24446 if (!SWIG_IsOK(res1)) {
24447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24448 }
24449 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24450 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24451 if (!SWIG_IsOK(ecode2)) {
24452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24453 }
24454 arg2 = static_cast< bool >(val2);
24455 if (arg1) (arg1)->m_altDown = arg2;
24456
24457 resultobj = SWIG_Py_Void();
24458 return resultobj;
24459 fail:
24460 return NULL;
24461 }
24462
24463
24464 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24465 PyObject *resultobj = 0;
24466 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24467 bool result;
24468 void *argp1 = 0 ;
24469 int res1 = 0 ;
24470 PyObject *swig_obj[1] ;
24471
24472 if (!args) SWIG_fail;
24473 swig_obj[0] = args;
24474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24475 if (!SWIG_IsOK(res1)) {
24476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24477 }
24478 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24479 result = (bool) ((arg1)->m_altDown);
24480 {
24481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24482 }
24483 return resultobj;
24484 fail:
24485 return NULL;
24486 }
24487
24488
24489 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24490 PyObject *resultobj = 0;
24491 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24492 bool arg2 ;
24493 void *argp1 = 0 ;
24494 int res1 = 0 ;
24495 bool val2 ;
24496 int ecode2 = 0 ;
24497 PyObject *swig_obj[2] ;
24498
24499 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24501 if (!SWIG_IsOK(res1)) {
24502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24503 }
24504 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24505 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24506 if (!SWIG_IsOK(ecode2)) {
24507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24508 }
24509 arg2 = static_cast< bool >(val2);
24510 if (arg1) (arg1)->m_metaDown = arg2;
24511
24512 resultobj = SWIG_Py_Void();
24513 return resultobj;
24514 fail:
24515 return NULL;
24516 }
24517
24518
24519 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24520 PyObject *resultobj = 0;
24521 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24522 bool result;
24523 void *argp1 = 0 ;
24524 int res1 = 0 ;
24525 PyObject *swig_obj[1] ;
24526
24527 if (!args) SWIG_fail;
24528 swig_obj[0] = args;
24529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24530 if (!SWIG_IsOK(res1)) {
24531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24532 }
24533 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24534 result = (bool) ((arg1)->m_metaDown);
24535 {
24536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24537 }
24538 return resultobj;
24539 fail:
24540 return NULL;
24541 }
24542
24543
24544 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24545 PyObject *resultobj = 0;
24546 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24547 int arg2 ;
24548 void *argp1 = 0 ;
24549 int res1 = 0 ;
24550 int val2 ;
24551 int ecode2 = 0 ;
24552 PyObject *swig_obj[2] ;
24553
24554 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24556 if (!SWIG_IsOK(res1)) {
24557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24558 }
24559 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24560 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24561 if (!SWIG_IsOK(ecode2)) {
24562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24563 }
24564 arg2 = static_cast< int >(val2);
24565 if (arg1) (arg1)->m_wheelRotation = arg2;
24566
24567 resultobj = SWIG_Py_Void();
24568 return resultobj;
24569 fail:
24570 return NULL;
24571 }
24572
24573
24574 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24575 PyObject *resultobj = 0;
24576 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24577 int result;
24578 void *argp1 = 0 ;
24579 int res1 = 0 ;
24580 PyObject *swig_obj[1] ;
24581
24582 if (!args) SWIG_fail;
24583 swig_obj[0] = args;
24584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24585 if (!SWIG_IsOK(res1)) {
24586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24587 }
24588 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24589 result = (int) ((arg1)->m_wheelRotation);
24590 resultobj = SWIG_From_int(static_cast< int >(result));
24591 return resultobj;
24592 fail:
24593 return NULL;
24594 }
24595
24596
24597 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24598 PyObject *resultobj = 0;
24599 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24600 int arg2 ;
24601 void *argp1 = 0 ;
24602 int res1 = 0 ;
24603 int val2 ;
24604 int ecode2 = 0 ;
24605 PyObject *swig_obj[2] ;
24606
24607 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24609 if (!SWIG_IsOK(res1)) {
24610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24611 }
24612 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24613 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24614 if (!SWIG_IsOK(ecode2)) {
24615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24616 }
24617 arg2 = static_cast< int >(val2);
24618 if (arg1) (arg1)->m_wheelDelta = arg2;
24619
24620 resultobj = SWIG_Py_Void();
24621 return resultobj;
24622 fail:
24623 return NULL;
24624 }
24625
24626
24627 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24628 PyObject *resultobj = 0;
24629 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24630 int result;
24631 void *argp1 = 0 ;
24632 int res1 = 0 ;
24633 PyObject *swig_obj[1] ;
24634
24635 if (!args) SWIG_fail;
24636 swig_obj[0] = args;
24637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24638 if (!SWIG_IsOK(res1)) {
24639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24640 }
24641 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24642 result = (int) ((arg1)->m_wheelDelta);
24643 resultobj = SWIG_From_int(static_cast< int >(result));
24644 return resultobj;
24645 fail:
24646 return NULL;
24647 }
24648
24649
24650 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24651 PyObject *resultobj = 0;
24652 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24653 int arg2 ;
24654 void *argp1 = 0 ;
24655 int res1 = 0 ;
24656 int val2 ;
24657 int ecode2 = 0 ;
24658 PyObject *swig_obj[2] ;
24659
24660 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24662 if (!SWIG_IsOK(res1)) {
24663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24664 }
24665 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24666 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24667 if (!SWIG_IsOK(ecode2)) {
24668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24669 }
24670 arg2 = static_cast< int >(val2);
24671 if (arg1) (arg1)->m_linesPerAction = arg2;
24672
24673 resultobj = SWIG_Py_Void();
24674 return resultobj;
24675 fail:
24676 return NULL;
24677 }
24678
24679
24680 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24681 PyObject *resultobj = 0;
24682 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24683 int result;
24684 void *argp1 = 0 ;
24685 int res1 = 0 ;
24686 PyObject *swig_obj[1] ;
24687
24688 if (!args) SWIG_fail;
24689 swig_obj[0] = args;
24690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24691 if (!SWIG_IsOK(res1)) {
24692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24693 }
24694 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24695 result = (int) ((arg1)->m_linesPerAction);
24696 resultobj = SWIG_From_int(static_cast< int >(result));
24697 return resultobj;
24698 fail:
24699 return NULL;
24700 }
24701
24702
24703 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24704 PyObject *obj;
24705 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24706 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24707 return SWIG_Py_Void();
24708 }
24709
24710 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24711 return SWIG_Python_InitShadowInstance(args);
24712 }
24713
24714 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24715 PyObject *resultobj = 0;
24716 int arg1 = (int) 0 ;
24717 int arg2 = (int) 0 ;
24718 wxSetCursorEvent *result = 0 ;
24719 int val1 ;
24720 int ecode1 = 0 ;
24721 int val2 ;
24722 int ecode2 = 0 ;
24723 PyObject * obj0 = 0 ;
24724 PyObject * obj1 = 0 ;
24725 char * kwnames[] = {
24726 (char *) "x",(char *) "y", NULL
24727 };
24728
24729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24730 if (obj0) {
24731 ecode1 = SWIG_AsVal_int(obj0, &val1);
24732 if (!SWIG_IsOK(ecode1)) {
24733 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24734 }
24735 arg1 = static_cast< int >(val1);
24736 }
24737 if (obj1) {
24738 ecode2 = SWIG_AsVal_int(obj1, &val2);
24739 if (!SWIG_IsOK(ecode2)) {
24740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24741 }
24742 arg2 = static_cast< int >(val2);
24743 }
24744 {
24745 PyThreadState* __tstate = wxPyBeginAllowThreads();
24746 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24747 wxPyEndAllowThreads(__tstate);
24748 if (PyErr_Occurred()) SWIG_fail;
24749 }
24750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24751 return resultobj;
24752 fail:
24753 return NULL;
24754 }
24755
24756
24757 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24758 PyObject *resultobj = 0;
24759 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24760 int result;
24761 void *argp1 = 0 ;
24762 int res1 = 0 ;
24763 PyObject *swig_obj[1] ;
24764
24765 if (!args) SWIG_fail;
24766 swig_obj[0] = args;
24767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24768 if (!SWIG_IsOK(res1)) {
24769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24770 }
24771 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24772 {
24773 PyThreadState* __tstate = wxPyBeginAllowThreads();
24774 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24775 wxPyEndAllowThreads(__tstate);
24776 if (PyErr_Occurred()) SWIG_fail;
24777 }
24778 resultobj = SWIG_From_int(static_cast< int >(result));
24779 return resultobj;
24780 fail:
24781 return NULL;
24782 }
24783
24784
24785 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24786 PyObject *resultobj = 0;
24787 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24788 int result;
24789 void *argp1 = 0 ;
24790 int res1 = 0 ;
24791 PyObject *swig_obj[1] ;
24792
24793 if (!args) SWIG_fail;
24794 swig_obj[0] = args;
24795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24796 if (!SWIG_IsOK(res1)) {
24797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24798 }
24799 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24800 {
24801 PyThreadState* __tstate = wxPyBeginAllowThreads();
24802 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24803 wxPyEndAllowThreads(__tstate);
24804 if (PyErr_Occurred()) SWIG_fail;
24805 }
24806 resultobj = SWIG_From_int(static_cast< int >(result));
24807 return resultobj;
24808 fail:
24809 return NULL;
24810 }
24811
24812
24813 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24814 PyObject *resultobj = 0;
24815 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24816 wxCursor *arg2 = 0 ;
24817 void *argp1 = 0 ;
24818 int res1 = 0 ;
24819 void *argp2 = 0 ;
24820 int res2 = 0 ;
24821 PyObject * obj0 = 0 ;
24822 PyObject * obj1 = 0 ;
24823 char * kwnames[] = {
24824 (char *) "self",(char *) "cursor", NULL
24825 };
24826
24827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24829 if (!SWIG_IsOK(res1)) {
24830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24831 }
24832 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24833 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24834 if (!SWIG_IsOK(res2)) {
24835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24836 }
24837 if (!argp2) {
24838 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24839 }
24840 arg2 = reinterpret_cast< wxCursor * >(argp2);
24841 {
24842 PyThreadState* __tstate = wxPyBeginAllowThreads();
24843 (arg1)->SetCursor((wxCursor const &)*arg2);
24844 wxPyEndAllowThreads(__tstate);
24845 if (PyErr_Occurred()) SWIG_fail;
24846 }
24847 resultobj = SWIG_Py_Void();
24848 return resultobj;
24849 fail:
24850 return NULL;
24851 }
24852
24853
24854 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24855 PyObject *resultobj = 0;
24856 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24857 wxCursor *result = 0 ;
24858 void *argp1 = 0 ;
24859 int res1 = 0 ;
24860 PyObject *swig_obj[1] ;
24861
24862 if (!args) SWIG_fail;
24863 swig_obj[0] = args;
24864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24865 if (!SWIG_IsOK(res1)) {
24866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24867 }
24868 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24869 {
24870 PyThreadState* __tstate = wxPyBeginAllowThreads();
24871 {
24872 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24873 result = (wxCursor *) &_result_ref;
24874 }
24875 wxPyEndAllowThreads(__tstate);
24876 if (PyErr_Occurred()) SWIG_fail;
24877 }
24878 {
24879 wxCursor* resultptr = new wxCursor(*result);
24880 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24881 }
24882 return resultobj;
24883 fail:
24884 return NULL;
24885 }
24886
24887
24888 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24889 PyObject *resultobj = 0;
24890 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24891 bool result;
24892 void *argp1 = 0 ;
24893 int res1 = 0 ;
24894 PyObject *swig_obj[1] ;
24895
24896 if (!args) SWIG_fail;
24897 swig_obj[0] = args;
24898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24899 if (!SWIG_IsOK(res1)) {
24900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24901 }
24902 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24903 {
24904 PyThreadState* __tstate = wxPyBeginAllowThreads();
24905 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24906 wxPyEndAllowThreads(__tstate);
24907 if (PyErr_Occurred()) SWIG_fail;
24908 }
24909 {
24910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24911 }
24912 return resultobj;
24913 fail:
24914 return NULL;
24915 }
24916
24917
24918 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24919 PyObject *obj;
24920 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24921 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24922 return SWIG_Py_Void();
24923 }
24924
24925 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24926 return SWIG_Python_InitShadowInstance(args);
24927 }
24928
24929 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24930 PyObject *resultobj = 0;
24931 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24932 wxKeyEvent *result = 0 ;
24933 int val1 ;
24934 int ecode1 = 0 ;
24935 PyObject * obj0 = 0 ;
24936 char * kwnames[] = {
24937 (char *) "eventType", NULL
24938 };
24939
24940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24941 if (obj0) {
24942 ecode1 = SWIG_AsVal_int(obj0, &val1);
24943 if (!SWIG_IsOK(ecode1)) {
24944 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24945 }
24946 arg1 = static_cast< wxEventType >(val1);
24947 }
24948 {
24949 PyThreadState* __tstate = wxPyBeginAllowThreads();
24950 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24951 wxPyEndAllowThreads(__tstate);
24952 if (PyErr_Occurred()) SWIG_fail;
24953 }
24954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24955 return resultobj;
24956 fail:
24957 return NULL;
24958 }
24959
24960
24961 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24962 PyObject *resultobj = 0;
24963 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24964 int result;
24965 void *argp1 = 0 ;
24966 int res1 = 0 ;
24967 PyObject *swig_obj[1] ;
24968
24969 if (!args) SWIG_fail;
24970 swig_obj[0] = args;
24971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24972 if (!SWIG_IsOK(res1)) {
24973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24974 }
24975 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24976 {
24977 PyThreadState* __tstate = wxPyBeginAllowThreads();
24978 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24979 wxPyEndAllowThreads(__tstate);
24980 if (PyErr_Occurred()) SWIG_fail;
24981 }
24982 resultobj = SWIG_From_int(static_cast< int >(result));
24983 return resultobj;
24984 fail:
24985 return NULL;
24986 }
24987
24988
24989 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24990 PyObject *resultobj = 0;
24991 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24992 bool result;
24993 void *argp1 = 0 ;
24994 int res1 = 0 ;
24995 PyObject *swig_obj[1] ;
24996
24997 if (!args) SWIG_fail;
24998 swig_obj[0] = args;
24999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25000 if (!SWIG_IsOK(res1)) {
25001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25002 }
25003 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25004 {
25005 PyThreadState* __tstate = wxPyBeginAllowThreads();
25006 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
25007 wxPyEndAllowThreads(__tstate);
25008 if (PyErr_Occurred()) SWIG_fail;
25009 }
25010 {
25011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25012 }
25013 return resultobj;
25014 fail:
25015 return NULL;
25016 }
25017
25018
25019 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25020 PyObject *resultobj = 0;
25021 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25022 bool result;
25023 void *argp1 = 0 ;
25024 int res1 = 0 ;
25025 PyObject *swig_obj[1] ;
25026
25027 if (!args) SWIG_fail;
25028 swig_obj[0] = args;
25029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25030 if (!SWIG_IsOK(res1)) {
25031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25032 }
25033 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25034 {
25035 PyThreadState* __tstate = wxPyBeginAllowThreads();
25036 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
25037 wxPyEndAllowThreads(__tstate);
25038 if (PyErr_Occurred()) SWIG_fail;
25039 }
25040 {
25041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25042 }
25043 return resultobj;
25044 fail:
25045 return NULL;
25046 }
25047
25048
25049 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25050 PyObject *resultobj = 0;
25051 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25052 bool result;
25053 void *argp1 = 0 ;
25054 int res1 = 0 ;
25055 PyObject *swig_obj[1] ;
25056
25057 if (!args) SWIG_fail;
25058 swig_obj[0] = args;
25059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25060 if (!SWIG_IsOK(res1)) {
25061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25062 }
25063 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25064 {
25065 PyThreadState* __tstate = wxPyBeginAllowThreads();
25066 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
25067 wxPyEndAllowThreads(__tstate);
25068 if (PyErr_Occurred()) SWIG_fail;
25069 }
25070 {
25071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25072 }
25073 return resultobj;
25074 fail:
25075 return NULL;
25076 }
25077
25078
25079 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25080 PyObject *resultobj = 0;
25081 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25082 bool result;
25083 void *argp1 = 0 ;
25084 int res1 = 0 ;
25085 PyObject *swig_obj[1] ;
25086
25087 if (!args) SWIG_fail;
25088 swig_obj[0] = args;
25089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25090 if (!SWIG_IsOK(res1)) {
25091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25092 }
25093 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25094 {
25095 PyThreadState* __tstate = wxPyBeginAllowThreads();
25096 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25097 wxPyEndAllowThreads(__tstate);
25098 if (PyErr_Occurred()) SWIG_fail;
25099 }
25100 {
25101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25102 }
25103 return resultobj;
25104 fail:
25105 return NULL;
25106 }
25107
25108
25109 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25110 PyObject *resultobj = 0;
25111 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25112 bool result;
25113 void *argp1 = 0 ;
25114 int res1 = 0 ;
25115 PyObject *swig_obj[1] ;
25116
25117 if (!args) SWIG_fail;
25118 swig_obj[0] = args;
25119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25120 if (!SWIG_IsOK(res1)) {
25121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25122 }
25123 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25124 {
25125 PyThreadState* __tstate = wxPyBeginAllowThreads();
25126 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25127 wxPyEndAllowThreads(__tstate);
25128 if (PyErr_Occurred()) SWIG_fail;
25129 }
25130 {
25131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25132 }
25133 return resultobj;
25134 fail:
25135 return NULL;
25136 }
25137
25138
25139 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25140 PyObject *resultobj = 0;
25141 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25142 bool result;
25143 void *argp1 = 0 ;
25144 int res1 = 0 ;
25145 PyObject *swig_obj[1] ;
25146
25147 if (!args) SWIG_fail;
25148 swig_obj[0] = args;
25149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25150 if (!SWIG_IsOK(res1)) {
25151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25152 }
25153 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25154 {
25155 PyThreadState* __tstate = wxPyBeginAllowThreads();
25156 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25157 wxPyEndAllowThreads(__tstate);
25158 if (PyErr_Occurred()) SWIG_fail;
25159 }
25160 {
25161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25162 }
25163 return resultobj;
25164 fail:
25165 return NULL;
25166 }
25167
25168
25169 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25170 PyObject *resultobj = 0;
25171 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25172 int result;
25173 void *argp1 = 0 ;
25174 int res1 = 0 ;
25175 PyObject *swig_obj[1] ;
25176
25177 if (!args) SWIG_fail;
25178 swig_obj[0] = args;
25179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25180 if (!SWIG_IsOK(res1)) {
25181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25182 }
25183 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25184 {
25185 PyThreadState* __tstate = wxPyBeginAllowThreads();
25186 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25187 wxPyEndAllowThreads(__tstate);
25188 if (PyErr_Occurred()) SWIG_fail;
25189 }
25190 resultobj = SWIG_From_int(static_cast< int >(result));
25191 return resultobj;
25192 fail:
25193 return NULL;
25194 }
25195
25196
25197 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25198 PyObject *resultobj = 0;
25199 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25200 int result;
25201 void *argp1 = 0 ;
25202 int res1 = 0 ;
25203 PyObject *swig_obj[1] ;
25204
25205 if (!args) SWIG_fail;
25206 swig_obj[0] = args;
25207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25208 if (!SWIG_IsOK(res1)) {
25209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25210 }
25211 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25212 {
25213 PyThreadState* __tstate = wxPyBeginAllowThreads();
25214 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25215 wxPyEndAllowThreads(__tstate);
25216 if (PyErr_Occurred()) SWIG_fail;
25217 }
25218 resultobj = SWIG_From_int(static_cast< int >(result));
25219 return resultobj;
25220 fail:
25221 return NULL;
25222 }
25223
25224
25225 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25226 PyObject *resultobj = 0;
25227 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25228 int arg2 ;
25229 void *argp1 = 0 ;
25230 int res1 = 0 ;
25231 int val2 ;
25232 int ecode2 = 0 ;
25233 PyObject * obj0 = 0 ;
25234 PyObject * obj1 = 0 ;
25235 char * kwnames[] = {
25236 (char *) "self",(char *) "uniChar", NULL
25237 };
25238
25239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25241 if (!SWIG_IsOK(res1)) {
25242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25243 }
25244 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25245 ecode2 = SWIG_AsVal_int(obj1, &val2);
25246 if (!SWIG_IsOK(ecode2)) {
25247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25248 }
25249 arg2 = static_cast< int >(val2);
25250 {
25251 PyThreadState* __tstate = wxPyBeginAllowThreads();
25252 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25253 wxPyEndAllowThreads(__tstate);
25254 if (PyErr_Occurred()) SWIG_fail;
25255 }
25256 resultobj = SWIG_Py_Void();
25257 return resultobj;
25258 fail:
25259 return NULL;
25260 }
25261
25262
25263 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25264 PyObject *resultobj = 0;
25265 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25266 unsigned int result;
25267 void *argp1 = 0 ;
25268 int res1 = 0 ;
25269 PyObject *swig_obj[1] ;
25270
25271 if (!args) SWIG_fail;
25272 swig_obj[0] = args;
25273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25274 if (!SWIG_IsOK(res1)) {
25275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25276 }
25277 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25278 {
25279 PyThreadState* __tstate = wxPyBeginAllowThreads();
25280 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25281 wxPyEndAllowThreads(__tstate);
25282 if (PyErr_Occurred()) SWIG_fail;
25283 }
25284 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25285 return resultobj;
25286 fail:
25287 return NULL;
25288 }
25289
25290
25291 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25292 PyObject *resultobj = 0;
25293 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25294 unsigned int result;
25295 void *argp1 = 0 ;
25296 int res1 = 0 ;
25297 PyObject *swig_obj[1] ;
25298
25299 if (!args) SWIG_fail;
25300 swig_obj[0] = args;
25301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25302 if (!SWIG_IsOK(res1)) {
25303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25304 }
25305 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25306 {
25307 PyThreadState* __tstate = wxPyBeginAllowThreads();
25308 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25309 wxPyEndAllowThreads(__tstate);
25310 if (PyErr_Occurred()) SWIG_fail;
25311 }
25312 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25313 return resultobj;
25314 fail:
25315 return NULL;
25316 }
25317
25318
25319 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25320 PyObject *resultobj = 0;
25321 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25322 wxPoint result;
25323 void *argp1 = 0 ;
25324 int res1 = 0 ;
25325 PyObject *swig_obj[1] ;
25326
25327 if (!args) SWIG_fail;
25328 swig_obj[0] = args;
25329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25330 if (!SWIG_IsOK(res1)) {
25331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25332 }
25333 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25334 {
25335 PyThreadState* __tstate = wxPyBeginAllowThreads();
25336 result = (arg1)->GetPosition();
25337 wxPyEndAllowThreads(__tstate);
25338 if (PyErr_Occurred()) SWIG_fail;
25339 }
25340 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25341 return resultobj;
25342 fail:
25343 return NULL;
25344 }
25345
25346
25347 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25348 PyObject *resultobj = 0;
25349 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25350 long *arg2 = (long *) 0 ;
25351 long *arg3 = (long *) 0 ;
25352 void *argp1 = 0 ;
25353 int res1 = 0 ;
25354 long temp2 ;
25355 int res2 = SWIG_TMPOBJ ;
25356 long temp3 ;
25357 int res3 = SWIG_TMPOBJ ;
25358 PyObject *swig_obj[1] ;
25359
25360 arg2 = &temp2;
25361 arg3 = &temp3;
25362 if (!args) SWIG_fail;
25363 swig_obj[0] = args;
25364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25365 if (!SWIG_IsOK(res1)) {
25366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25367 }
25368 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25369 {
25370 PyThreadState* __tstate = wxPyBeginAllowThreads();
25371 (arg1)->GetPosition(arg2,arg3);
25372 wxPyEndAllowThreads(__tstate);
25373 if (PyErr_Occurred()) SWIG_fail;
25374 }
25375 resultobj = SWIG_Py_Void();
25376 if (SWIG_IsTmpObj(res2)) {
25377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25378 } else {
25379 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25381 }
25382 if (SWIG_IsTmpObj(res3)) {
25383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25384 } else {
25385 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25387 }
25388 return resultobj;
25389 fail:
25390 return NULL;
25391 }
25392
25393
25394 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25395 PyObject *resultobj = 0;
25396 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25397 int result;
25398 void *argp1 = 0 ;
25399 int res1 = 0 ;
25400 PyObject *swig_obj[1] ;
25401
25402 if (!args) SWIG_fail;
25403 swig_obj[0] = args;
25404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25405 if (!SWIG_IsOK(res1)) {
25406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25407 }
25408 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25409 {
25410 PyThreadState* __tstate = wxPyBeginAllowThreads();
25411 result = (int)((wxKeyEvent const *)arg1)->GetX();
25412 wxPyEndAllowThreads(__tstate);
25413 if (PyErr_Occurred()) SWIG_fail;
25414 }
25415 resultobj = SWIG_From_int(static_cast< int >(result));
25416 return resultobj;
25417 fail:
25418 return NULL;
25419 }
25420
25421
25422 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25423 PyObject *resultobj = 0;
25424 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25425 int result;
25426 void *argp1 = 0 ;
25427 int res1 = 0 ;
25428 PyObject *swig_obj[1] ;
25429
25430 if (!args) SWIG_fail;
25431 swig_obj[0] = args;
25432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25433 if (!SWIG_IsOK(res1)) {
25434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25435 }
25436 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25437 {
25438 PyThreadState* __tstate = wxPyBeginAllowThreads();
25439 result = (int)((wxKeyEvent const *)arg1)->GetY();
25440 wxPyEndAllowThreads(__tstate);
25441 if (PyErr_Occurred()) SWIG_fail;
25442 }
25443 resultobj = SWIG_From_int(static_cast< int >(result));
25444 return resultobj;
25445 fail:
25446 return NULL;
25447 }
25448
25449
25450 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25451 PyObject *resultobj = 0;
25452 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25453 int arg2 ;
25454 void *argp1 = 0 ;
25455 int res1 = 0 ;
25456 int val2 ;
25457 int ecode2 = 0 ;
25458 PyObject *swig_obj[2] ;
25459
25460 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25462 if (!SWIG_IsOK(res1)) {
25463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25464 }
25465 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25466 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25467 if (!SWIG_IsOK(ecode2)) {
25468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25469 }
25470 arg2 = static_cast< int >(val2);
25471 if (arg1) (arg1)->m_x = arg2;
25472
25473 resultobj = SWIG_Py_Void();
25474 return resultobj;
25475 fail:
25476 return NULL;
25477 }
25478
25479
25480 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25481 PyObject *resultobj = 0;
25482 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25483 int result;
25484 void *argp1 = 0 ;
25485 int res1 = 0 ;
25486 PyObject *swig_obj[1] ;
25487
25488 if (!args) SWIG_fail;
25489 swig_obj[0] = args;
25490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25491 if (!SWIG_IsOK(res1)) {
25492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25493 }
25494 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25495 result = (int) ((arg1)->m_x);
25496 resultobj = SWIG_From_int(static_cast< int >(result));
25497 return resultobj;
25498 fail:
25499 return NULL;
25500 }
25501
25502
25503 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25504 PyObject *resultobj = 0;
25505 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25506 int arg2 ;
25507 void *argp1 = 0 ;
25508 int res1 = 0 ;
25509 int val2 ;
25510 int ecode2 = 0 ;
25511 PyObject *swig_obj[2] ;
25512
25513 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25515 if (!SWIG_IsOK(res1)) {
25516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25517 }
25518 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25519 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25520 if (!SWIG_IsOK(ecode2)) {
25521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25522 }
25523 arg2 = static_cast< int >(val2);
25524 if (arg1) (arg1)->m_y = arg2;
25525
25526 resultobj = SWIG_Py_Void();
25527 return resultobj;
25528 fail:
25529 return NULL;
25530 }
25531
25532
25533 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25534 PyObject *resultobj = 0;
25535 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25536 int result;
25537 void *argp1 = 0 ;
25538 int res1 = 0 ;
25539 PyObject *swig_obj[1] ;
25540
25541 if (!args) SWIG_fail;
25542 swig_obj[0] = args;
25543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25544 if (!SWIG_IsOK(res1)) {
25545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25546 }
25547 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25548 result = (int) ((arg1)->m_y);
25549 resultobj = SWIG_From_int(static_cast< int >(result));
25550 return resultobj;
25551 fail:
25552 return NULL;
25553 }
25554
25555
25556 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25557 PyObject *resultobj = 0;
25558 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25559 long arg2 ;
25560 void *argp1 = 0 ;
25561 int res1 = 0 ;
25562 long val2 ;
25563 int ecode2 = 0 ;
25564 PyObject *swig_obj[2] ;
25565
25566 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25568 if (!SWIG_IsOK(res1)) {
25569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25570 }
25571 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25572 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25573 if (!SWIG_IsOK(ecode2)) {
25574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25575 }
25576 arg2 = static_cast< long >(val2);
25577 if (arg1) (arg1)->m_keyCode = arg2;
25578
25579 resultobj = SWIG_Py_Void();
25580 return resultobj;
25581 fail:
25582 return NULL;
25583 }
25584
25585
25586 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25587 PyObject *resultobj = 0;
25588 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25589 long 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_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25599 }
25600 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25601 result = (long) ((arg1)->m_keyCode);
25602 resultobj = SWIG_From_long(static_cast< long >(result));
25603 return resultobj;
25604 fail:
25605 return NULL;
25606 }
25607
25608
25609 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25610 PyObject *resultobj = 0;
25611 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25612 bool arg2 ;
25613 void *argp1 = 0 ;
25614 int res1 = 0 ;
25615 bool val2 ;
25616 int ecode2 = 0 ;
25617 PyObject *swig_obj[2] ;
25618
25619 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25621 if (!SWIG_IsOK(res1)) {
25622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25623 }
25624 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25625 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25626 if (!SWIG_IsOK(ecode2)) {
25627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25628 }
25629 arg2 = static_cast< bool >(val2);
25630 if (arg1) (arg1)->m_controlDown = arg2;
25631
25632 resultobj = SWIG_Py_Void();
25633 return resultobj;
25634 fail:
25635 return NULL;
25636 }
25637
25638
25639 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25640 PyObject *resultobj = 0;
25641 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25642 bool result;
25643 void *argp1 = 0 ;
25644 int res1 = 0 ;
25645 PyObject *swig_obj[1] ;
25646
25647 if (!args) SWIG_fail;
25648 swig_obj[0] = args;
25649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25650 if (!SWIG_IsOK(res1)) {
25651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25652 }
25653 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25654 result = (bool) ((arg1)->m_controlDown);
25655 {
25656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25657 }
25658 return resultobj;
25659 fail:
25660 return NULL;
25661 }
25662
25663
25664 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25665 PyObject *resultobj = 0;
25666 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25667 bool arg2 ;
25668 void *argp1 = 0 ;
25669 int res1 = 0 ;
25670 bool val2 ;
25671 int ecode2 = 0 ;
25672 PyObject *swig_obj[2] ;
25673
25674 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25676 if (!SWIG_IsOK(res1)) {
25677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25678 }
25679 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25680 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25681 if (!SWIG_IsOK(ecode2)) {
25682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25683 }
25684 arg2 = static_cast< bool >(val2);
25685 if (arg1) (arg1)->m_shiftDown = arg2;
25686
25687 resultobj = SWIG_Py_Void();
25688 return resultobj;
25689 fail:
25690 return NULL;
25691 }
25692
25693
25694 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25695 PyObject *resultobj = 0;
25696 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25697 bool result;
25698 void *argp1 = 0 ;
25699 int res1 = 0 ;
25700 PyObject *swig_obj[1] ;
25701
25702 if (!args) SWIG_fail;
25703 swig_obj[0] = args;
25704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25705 if (!SWIG_IsOK(res1)) {
25706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25707 }
25708 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25709 result = (bool) ((arg1)->m_shiftDown);
25710 {
25711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25712 }
25713 return resultobj;
25714 fail:
25715 return NULL;
25716 }
25717
25718
25719 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25720 PyObject *resultobj = 0;
25721 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25722 bool arg2 ;
25723 void *argp1 = 0 ;
25724 int res1 = 0 ;
25725 bool val2 ;
25726 int ecode2 = 0 ;
25727 PyObject *swig_obj[2] ;
25728
25729 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25731 if (!SWIG_IsOK(res1)) {
25732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25733 }
25734 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25735 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25736 if (!SWIG_IsOK(ecode2)) {
25737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25738 }
25739 arg2 = static_cast< bool >(val2);
25740 if (arg1) (arg1)->m_altDown = arg2;
25741
25742 resultobj = SWIG_Py_Void();
25743 return resultobj;
25744 fail:
25745 return NULL;
25746 }
25747
25748
25749 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25750 PyObject *resultobj = 0;
25751 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25752 bool result;
25753 void *argp1 = 0 ;
25754 int res1 = 0 ;
25755 PyObject *swig_obj[1] ;
25756
25757 if (!args) SWIG_fail;
25758 swig_obj[0] = args;
25759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25760 if (!SWIG_IsOK(res1)) {
25761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25762 }
25763 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25764 result = (bool) ((arg1)->m_altDown);
25765 {
25766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25767 }
25768 return resultobj;
25769 fail:
25770 return NULL;
25771 }
25772
25773
25774 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25775 PyObject *resultobj = 0;
25776 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25777 bool arg2 ;
25778 void *argp1 = 0 ;
25779 int res1 = 0 ;
25780 bool val2 ;
25781 int ecode2 = 0 ;
25782 PyObject *swig_obj[2] ;
25783
25784 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25786 if (!SWIG_IsOK(res1)) {
25787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25788 }
25789 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25790 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25791 if (!SWIG_IsOK(ecode2)) {
25792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25793 }
25794 arg2 = static_cast< bool >(val2);
25795 if (arg1) (arg1)->m_metaDown = arg2;
25796
25797 resultobj = SWIG_Py_Void();
25798 return resultobj;
25799 fail:
25800 return NULL;
25801 }
25802
25803
25804 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25805 PyObject *resultobj = 0;
25806 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25807 bool result;
25808 void *argp1 = 0 ;
25809 int res1 = 0 ;
25810 PyObject *swig_obj[1] ;
25811
25812 if (!args) SWIG_fail;
25813 swig_obj[0] = args;
25814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25815 if (!SWIG_IsOK(res1)) {
25816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25817 }
25818 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25819 result = (bool) ((arg1)->m_metaDown);
25820 {
25821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25822 }
25823 return resultobj;
25824 fail:
25825 return NULL;
25826 }
25827
25828
25829 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25830 PyObject *resultobj = 0;
25831 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25832 bool arg2 ;
25833 void *argp1 = 0 ;
25834 int res1 = 0 ;
25835 bool val2 ;
25836 int ecode2 = 0 ;
25837 PyObject *swig_obj[2] ;
25838
25839 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25841 if (!SWIG_IsOK(res1)) {
25842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25843 }
25844 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25845 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25846 if (!SWIG_IsOK(ecode2)) {
25847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25848 }
25849 arg2 = static_cast< bool >(val2);
25850 if (arg1) (arg1)->m_scanCode = arg2;
25851
25852 resultobj = SWIG_Py_Void();
25853 return resultobj;
25854 fail:
25855 return NULL;
25856 }
25857
25858
25859 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25860 PyObject *resultobj = 0;
25861 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25862 bool result;
25863 void *argp1 = 0 ;
25864 int res1 = 0 ;
25865 PyObject *swig_obj[1] ;
25866
25867 if (!args) SWIG_fail;
25868 swig_obj[0] = args;
25869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25870 if (!SWIG_IsOK(res1)) {
25871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25872 }
25873 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25874 result = (bool) ((arg1)->m_scanCode);
25875 {
25876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25877 }
25878 return resultobj;
25879 fail:
25880 return NULL;
25881 }
25882
25883
25884 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25885 PyObject *resultobj = 0;
25886 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25887 unsigned int arg2 ;
25888 void *argp1 = 0 ;
25889 int res1 = 0 ;
25890 unsigned int val2 ;
25891 int ecode2 = 0 ;
25892 PyObject *swig_obj[2] ;
25893
25894 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25896 if (!SWIG_IsOK(res1)) {
25897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25898 }
25899 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25900 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25901 if (!SWIG_IsOK(ecode2)) {
25902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25903 }
25904 arg2 = static_cast< unsigned int >(val2);
25905 if (arg1) (arg1)->m_rawCode = arg2;
25906
25907 resultobj = SWIG_Py_Void();
25908 return resultobj;
25909 fail:
25910 return NULL;
25911 }
25912
25913
25914 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25915 PyObject *resultobj = 0;
25916 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25917 unsigned int result;
25918 void *argp1 = 0 ;
25919 int res1 = 0 ;
25920 PyObject *swig_obj[1] ;
25921
25922 if (!args) SWIG_fail;
25923 swig_obj[0] = args;
25924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25925 if (!SWIG_IsOK(res1)) {
25926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25927 }
25928 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25929 result = (unsigned int) ((arg1)->m_rawCode);
25930 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25931 return resultobj;
25932 fail:
25933 return NULL;
25934 }
25935
25936
25937 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25938 PyObject *resultobj = 0;
25939 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25940 unsigned int arg2 ;
25941 void *argp1 = 0 ;
25942 int res1 = 0 ;
25943 unsigned int val2 ;
25944 int ecode2 = 0 ;
25945 PyObject *swig_obj[2] ;
25946
25947 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25949 if (!SWIG_IsOK(res1)) {
25950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25951 }
25952 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25953 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25954 if (!SWIG_IsOK(ecode2)) {
25955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25956 }
25957 arg2 = static_cast< unsigned int >(val2);
25958 if (arg1) (arg1)->m_rawFlags = arg2;
25959
25960 resultobj = SWIG_Py_Void();
25961 return resultobj;
25962 fail:
25963 return NULL;
25964 }
25965
25966
25967 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25968 PyObject *resultobj = 0;
25969 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25970 unsigned int result;
25971 void *argp1 = 0 ;
25972 int res1 = 0 ;
25973 PyObject *swig_obj[1] ;
25974
25975 if (!args) SWIG_fail;
25976 swig_obj[0] = args;
25977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25978 if (!SWIG_IsOK(res1)) {
25979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25980 }
25981 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25982 result = (unsigned int) ((arg1)->m_rawFlags);
25983 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25984 return resultobj;
25985 fail:
25986 return NULL;
25987 }
25988
25989
25990 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25991 PyObject *obj;
25992 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25993 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25994 return SWIG_Py_Void();
25995 }
25996
25997 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25998 return SWIG_Python_InitShadowInstance(args);
25999 }
26000
26001 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26002 PyObject *resultobj = 0;
26003 wxSize const &arg1_defvalue = wxDefaultSize ;
26004 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
26005 int arg2 = (int) 0 ;
26006 wxSizeEvent *result = 0 ;
26007 wxSize temp1 ;
26008 int val2 ;
26009 int ecode2 = 0 ;
26010 PyObject * obj0 = 0 ;
26011 PyObject * obj1 = 0 ;
26012 char * kwnames[] = {
26013 (char *) "sz",(char *) "winid", NULL
26014 };
26015
26016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26017 if (obj0) {
26018 {
26019 arg1 = &temp1;
26020 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
26021 }
26022 }
26023 if (obj1) {
26024 ecode2 = SWIG_AsVal_int(obj1, &val2);
26025 if (!SWIG_IsOK(ecode2)) {
26026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
26027 }
26028 arg2 = static_cast< int >(val2);
26029 }
26030 {
26031 PyThreadState* __tstate = wxPyBeginAllowThreads();
26032 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
26033 wxPyEndAllowThreads(__tstate);
26034 if (PyErr_Occurred()) SWIG_fail;
26035 }
26036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
26037 return resultobj;
26038 fail:
26039 return NULL;
26040 }
26041
26042
26043 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26044 PyObject *resultobj = 0;
26045 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26046 wxSize result;
26047 void *argp1 = 0 ;
26048 int res1 = 0 ;
26049 PyObject *swig_obj[1] ;
26050
26051 if (!args) SWIG_fail;
26052 swig_obj[0] = args;
26053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26054 if (!SWIG_IsOK(res1)) {
26055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26056 }
26057 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26058 {
26059 PyThreadState* __tstate = wxPyBeginAllowThreads();
26060 result = ((wxSizeEvent const *)arg1)->GetSize();
26061 wxPyEndAllowThreads(__tstate);
26062 if (PyErr_Occurred()) SWIG_fail;
26063 }
26064 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
26065 return resultobj;
26066 fail:
26067 return NULL;
26068 }
26069
26070
26071 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26072 PyObject *resultobj = 0;
26073 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26074 wxRect result;
26075 void *argp1 = 0 ;
26076 int res1 = 0 ;
26077 PyObject *swig_obj[1] ;
26078
26079 if (!args) SWIG_fail;
26080 swig_obj[0] = args;
26081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26082 if (!SWIG_IsOK(res1)) {
26083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26084 }
26085 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26086 {
26087 PyThreadState* __tstate = wxPyBeginAllowThreads();
26088 result = ((wxSizeEvent const *)arg1)->GetRect();
26089 wxPyEndAllowThreads(__tstate);
26090 if (PyErr_Occurred()) SWIG_fail;
26091 }
26092 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26093 return resultobj;
26094 fail:
26095 return NULL;
26096 }
26097
26098
26099 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26100 PyObject *resultobj = 0;
26101 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26102 wxRect arg2 ;
26103 void *argp1 = 0 ;
26104 int res1 = 0 ;
26105 void *argp2 ;
26106 int res2 = 0 ;
26107 PyObject * obj0 = 0 ;
26108 PyObject * obj1 = 0 ;
26109 char * kwnames[] = {
26110 (char *) "self",(char *) "rect", NULL
26111 };
26112
26113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26115 if (!SWIG_IsOK(res1)) {
26116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26117 }
26118 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26119 {
26120 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26121 if (!SWIG_IsOK(res2)) {
26122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26123 }
26124 if (!argp2) {
26125 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26126 } else {
26127 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26128 arg2 = *temp;
26129 if (SWIG_IsNewObj(res2)) delete temp;
26130 }
26131 }
26132 {
26133 PyThreadState* __tstate = wxPyBeginAllowThreads();
26134 (arg1)->SetRect(arg2);
26135 wxPyEndAllowThreads(__tstate);
26136 if (PyErr_Occurred()) SWIG_fail;
26137 }
26138 resultobj = SWIG_Py_Void();
26139 return resultobj;
26140 fail:
26141 return NULL;
26142 }
26143
26144
26145 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26146 PyObject *resultobj = 0;
26147 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26148 wxSize arg2 ;
26149 void *argp1 = 0 ;
26150 int res1 = 0 ;
26151 void *argp2 ;
26152 int res2 = 0 ;
26153 PyObject * obj0 = 0 ;
26154 PyObject * obj1 = 0 ;
26155 char * kwnames[] = {
26156 (char *) "self",(char *) "size", NULL
26157 };
26158
26159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26161 if (!SWIG_IsOK(res1)) {
26162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26163 }
26164 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26165 {
26166 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26167 if (!SWIG_IsOK(res2)) {
26168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26169 }
26170 if (!argp2) {
26171 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26172 } else {
26173 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26174 arg2 = *temp;
26175 if (SWIG_IsNewObj(res2)) delete temp;
26176 }
26177 }
26178 {
26179 PyThreadState* __tstate = wxPyBeginAllowThreads();
26180 wxSizeEvent_SetSize(arg1,arg2);
26181 wxPyEndAllowThreads(__tstate);
26182 if (PyErr_Occurred()) SWIG_fail;
26183 }
26184 resultobj = SWIG_Py_Void();
26185 return resultobj;
26186 fail:
26187 return NULL;
26188 }
26189
26190
26191 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26192 PyObject *resultobj = 0;
26193 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26194 wxSize *arg2 = (wxSize *) 0 ;
26195 void *argp1 = 0 ;
26196 int res1 = 0 ;
26197 void *argp2 = 0 ;
26198 int res2 = 0 ;
26199 PyObject *swig_obj[2] ;
26200
26201 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26203 if (!SWIG_IsOK(res1)) {
26204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26205 }
26206 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26207 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26208 if (!SWIG_IsOK(res2)) {
26209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26210 }
26211 arg2 = reinterpret_cast< wxSize * >(argp2);
26212 if (arg1) (arg1)->m_size = *arg2;
26213
26214 resultobj = SWIG_Py_Void();
26215 return resultobj;
26216 fail:
26217 return NULL;
26218 }
26219
26220
26221 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26222 PyObject *resultobj = 0;
26223 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26224 wxSize *result = 0 ;
26225 void *argp1 = 0 ;
26226 int res1 = 0 ;
26227 PyObject *swig_obj[1] ;
26228
26229 if (!args) SWIG_fail;
26230 swig_obj[0] = args;
26231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26232 if (!SWIG_IsOK(res1)) {
26233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26234 }
26235 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26236 result = (wxSize *)& ((arg1)->m_size);
26237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26238 return resultobj;
26239 fail:
26240 return NULL;
26241 }
26242
26243
26244 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26245 PyObject *resultobj = 0;
26246 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26247 wxRect *arg2 = (wxRect *) 0 ;
26248 void *argp1 = 0 ;
26249 int res1 = 0 ;
26250 void *argp2 = 0 ;
26251 int res2 = 0 ;
26252 PyObject *swig_obj[2] ;
26253
26254 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26256 if (!SWIG_IsOK(res1)) {
26257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26258 }
26259 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26260 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26261 if (!SWIG_IsOK(res2)) {
26262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26263 }
26264 arg2 = reinterpret_cast< wxRect * >(argp2);
26265 if (arg1) (arg1)->m_rect = *arg2;
26266
26267 resultobj = SWIG_Py_Void();
26268 return resultobj;
26269 fail:
26270 return NULL;
26271 }
26272
26273
26274 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26275 PyObject *resultobj = 0;
26276 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26277 wxRect *result = 0 ;
26278 void *argp1 = 0 ;
26279 int res1 = 0 ;
26280 PyObject *swig_obj[1] ;
26281
26282 if (!args) SWIG_fail;
26283 swig_obj[0] = args;
26284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26285 if (!SWIG_IsOK(res1)) {
26286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26287 }
26288 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26289 result = (wxRect *)& ((arg1)->m_rect);
26290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26291 return resultobj;
26292 fail:
26293 return NULL;
26294 }
26295
26296
26297 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26298 PyObject *obj;
26299 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26300 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26301 return SWIG_Py_Void();
26302 }
26303
26304 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26305 return SWIG_Python_InitShadowInstance(args);
26306 }
26307
26308 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26309 PyObject *resultobj = 0;
26310 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26311 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26312 int arg2 = (int) 0 ;
26313 wxMoveEvent *result = 0 ;
26314 wxPoint temp1 ;
26315 int val2 ;
26316 int ecode2 = 0 ;
26317 PyObject * obj0 = 0 ;
26318 PyObject * obj1 = 0 ;
26319 char * kwnames[] = {
26320 (char *) "pos",(char *) "winid", NULL
26321 };
26322
26323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26324 if (obj0) {
26325 {
26326 arg1 = &temp1;
26327 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26328 }
26329 }
26330 if (obj1) {
26331 ecode2 = SWIG_AsVal_int(obj1, &val2);
26332 if (!SWIG_IsOK(ecode2)) {
26333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26334 }
26335 arg2 = static_cast< int >(val2);
26336 }
26337 {
26338 PyThreadState* __tstate = wxPyBeginAllowThreads();
26339 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26340 wxPyEndAllowThreads(__tstate);
26341 if (PyErr_Occurred()) SWIG_fail;
26342 }
26343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26344 return resultobj;
26345 fail:
26346 return NULL;
26347 }
26348
26349
26350 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26351 PyObject *resultobj = 0;
26352 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26353 wxPoint result;
26354 void *argp1 = 0 ;
26355 int res1 = 0 ;
26356 PyObject *swig_obj[1] ;
26357
26358 if (!args) SWIG_fail;
26359 swig_obj[0] = args;
26360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26361 if (!SWIG_IsOK(res1)) {
26362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26363 }
26364 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26365 {
26366 PyThreadState* __tstate = wxPyBeginAllowThreads();
26367 result = ((wxMoveEvent const *)arg1)->GetPosition();
26368 wxPyEndAllowThreads(__tstate);
26369 if (PyErr_Occurred()) SWIG_fail;
26370 }
26371 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26372 return resultobj;
26373 fail:
26374 return NULL;
26375 }
26376
26377
26378 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26379 PyObject *resultobj = 0;
26380 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26381 wxRect result;
26382 void *argp1 = 0 ;
26383 int res1 = 0 ;
26384 PyObject *swig_obj[1] ;
26385
26386 if (!args) SWIG_fail;
26387 swig_obj[0] = args;
26388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26389 if (!SWIG_IsOK(res1)) {
26390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26391 }
26392 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26393 {
26394 PyThreadState* __tstate = wxPyBeginAllowThreads();
26395 result = ((wxMoveEvent const *)arg1)->GetRect();
26396 wxPyEndAllowThreads(__tstate);
26397 if (PyErr_Occurred()) SWIG_fail;
26398 }
26399 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26400 return resultobj;
26401 fail:
26402 return NULL;
26403 }
26404
26405
26406 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26407 PyObject *resultobj = 0;
26408 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26409 wxRect *arg2 = 0 ;
26410 void *argp1 = 0 ;
26411 int res1 = 0 ;
26412 wxRect temp2 ;
26413 PyObject * obj0 = 0 ;
26414 PyObject * obj1 = 0 ;
26415 char * kwnames[] = {
26416 (char *) "self",(char *) "rect", NULL
26417 };
26418
26419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26421 if (!SWIG_IsOK(res1)) {
26422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26423 }
26424 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26425 {
26426 arg2 = &temp2;
26427 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26428 }
26429 {
26430 PyThreadState* __tstate = wxPyBeginAllowThreads();
26431 (arg1)->SetRect((wxRect const &)*arg2);
26432 wxPyEndAllowThreads(__tstate);
26433 if (PyErr_Occurred()) SWIG_fail;
26434 }
26435 resultobj = SWIG_Py_Void();
26436 return resultobj;
26437 fail:
26438 return NULL;
26439 }
26440
26441
26442 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26443 PyObject *resultobj = 0;
26444 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26445 wxPoint *arg2 = 0 ;
26446 void *argp1 = 0 ;
26447 int res1 = 0 ;
26448 wxPoint temp2 ;
26449 PyObject * obj0 = 0 ;
26450 PyObject * obj1 = 0 ;
26451 char * kwnames[] = {
26452 (char *) "self",(char *) "pos", NULL
26453 };
26454
26455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26457 if (!SWIG_IsOK(res1)) {
26458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26459 }
26460 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26461 {
26462 arg2 = &temp2;
26463 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26464 }
26465 {
26466 PyThreadState* __tstate = wxPyBeginAllowThreads();
26467 (arg1)->SetPosition((wxPoint const &)*arg2);
26468 wxPyEndAllowThreads(__tstate);
26469 if (PyErr_Occurred()) SWIG_fail;
26470 }
26471 resultobj = SWIG_Py_Void();
26472 return resultobj;
26473 fail:
26474 return NULL;
26475 }
26476
26477
26478 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26479 PyObject *obj;
26480 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26481 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26482 return SWIG_Py_Void();
26483 }
26484
26485 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26486 return SWIG_Python_InitShadowInstance(args);
26487 }
26488
26489 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26490 PyObject *resultobj = 0;
26491 int arg1 = (int) 0 ;
26492 wxPaintEvent *result = 0 ;
26493 int val1 ;
26494 int ecode1 = 0 ;
26495 PyObject * obj0 = 0 ;
26496 char * kwnames[] = {
26497 (char *) "Id", NULL
26498 };
26499
26500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26501 if (obj0) {
26502 ecode1 = SWIG_AsVal_int(obj0, &val1);
26503 if (!SWIG_IsOK(ecode1)) {
26504 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26505 }
26506 arg1 = static_cast< int >(val1);
26507 }
26508 {
26509 PyThreadState* __tstate = wxPyBeginAllowThreads();
26510 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26511 wxPyEndAllowThreads(__tstate);
26512 if (PyErr_Occurred()) SWIG_fail;
26513 }
26514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26515 return resultobj;
26516 fail:
26517 return NULL;
26518 }
26519
26520
26521 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26522 PyObject *obj;
26523 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26524 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26525 return SWIG_Py_Void();
26526 }
26527
26528 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26529 return SWIG_Python_InitShadowInstance(args);
26530 }
26531
26532 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26533 PyObject *resultobj = 0;
26534 int arg1 = (int) 0 ;
26535 wxNcPaintEvent *result = 0 ;
26536 int val1 ;
26537 int ecode1 = 0 ;
26538 PyObject * obj0 = 0 ;
26539 char * kwnames[] = {
26540 (char *) "winid", NULL
26541 };
26542
26543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26544 if (obj0) {
26545 ecode1 = SWIG_AsVal_int(obj0, &val1);
26546 if (!SWIG_IsOK(ecode1)) {
26547 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26548 }
26549 arg1 = static_cast< int >(val1);
26550 }
26551 {
26552 PyThreadState* __tstate = wxPyBeginAllowThreads();
26553 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26554 wxPyEndAllowThreads(__tstate);
26555 if (PyErr_Occurred()) SWIG_fail;
26556 }
26557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26558 return resultobj;
26559 fail:
26560 return NULL;
26561 }
26562
26563
26564 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26565 PyObject *obj;
26566 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26567 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26568 return SWIG_Py_Void();
26569 }
26570
26571 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26572 return SWIG_Python_InitShadowInstance(args);
26573 }
26574
26575 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26576 PyObject *resultobj = 0;
26577 int arg1 = (int) 0 ;
26578 wxDC *arg2 = (wxDC *) NULL ;
26579 wxEraseEvent *result = 0 ;
26580 int val1 ;
26581 int ecode1 = 0 ;
26582 void *argp2 = 0 ;
26583 int res2 = 0 ;
26584 PyObject * obj0 = 0 ;
26585 PyObject * obj1 = 0 ;
26586 char * kwnames[] = {
26587 (char *) "Id",(char *) "dc", NULL
26588 };
26589
26590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26591 if (obj0) {
26592 ecode1 = SWIG_AsVal_int(obj0, &val1);
26593 if (!SWIG_IsOK(ecode1)) {
26594 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26595 }
26596 arg1 = static_cast< int >(val1);
26597 }
26598 if (obj1) {
26599 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26600 if (!SWIG_IsOK(res2)) {
26601 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26602 }
26603 arg2 = reinterpret_cast< wxDC * >(argp2);
26604 }
26605 {
26606 PyThreadState* __tstate = wxPyBeginAllowThreads();
26607 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26608 wxPyEndAllowThreads(__tstate);
26609 if (PyErr_Occurred()) SWIG_fail;
26610 }
26611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26612 return resultobj;
26613 fail:
26614 return NULL;
26615 }
26616
26617
26618 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26619 PyObject *resultobj = 0;
26620 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26621 wxDC *result = 0 ;
26622 void *argp1 = 0 ;
26623 int res1 = 0 ;
26624 PyObject *swig_obj[1] ;
26625
26626 if (!args) SWIG_fail;
26627 swig_obj[0] = args;
26628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26629 if (!SWIG_IsOK(res1)) {
26630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26631 }
26632 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26633 {
26634 PyThreadState* __tstate = wxPyBeginAllowThreads();
26635 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26636 wxPyEndAllowThreads(__tstate);
26637 if (PyErr_Occurred()) SWIG_fail;
26638 }
26639 {
26640 resultobj = wxPyMake_wxObject(result, (bool)0);
26641 }
26642 return resultobj;
26643 fail:
26644 return NULL;
26645 }
26646
26647
26648 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26649 PyObject *obj;
26650 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26651 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26652 return SWIG_Py_Void();
26653 }
26654
26655 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26656 return SWIG_Python_InitShadowInstance(args);
26657 }
26658
26659 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26660 PyObject *resultobj = 0;
26661 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26662 int arg2 = (int) 0 ;
26663 wxFocusEvent *result = 0 ;
26664 int val1 ;
26665 int ecode1 = 0 ;
26666 int val2 ;
26667 int ecode2 = 0 ;
26668 PyObject * obj0 = 0 ;
26669 PyObject * obj1 = 0 ;
26670 char * kwnames[] = {
26671 (char *) "type",(char *) "winid", NULL
26672 };
26673
26674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26675 if (obj0) {
26676 ecode1 = SWIG_AsVal_int(obj0, &val1);
26677 if (!SWIG_IsOK(ecode1)) {
26678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26679 }
26680 arg1 = static_cast< wxEventType >(val1);
26681 }
26682 if (obj1) {
26683 ecode2 = SWIG_AsVal_int(obj1, &val2);
26684 if (!SWIG_IsOK(ecode2)) {
26685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26686 }
26687 arg2 = static_cast< int >(val2);
26688 }
26689 {
26690 PyThreadState* __tstate = wxPyBeginAllowThreads();
26691 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26692 wxPyEndAllowThreads(__tstate);
26693 if (PyErr_Occurred()) SWIG_fail;
26694 }
26695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26696 return resultobj;
26697 fail:
26698 return NULL;
26699 }
26700
26701
26702 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26703 PyObject *resultobj = 0;
26704 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26705 wxWindow *result = 0 ;
26706 void *argp1 = 0 ;
26707 int res1 = 0 ;
26708 PyObject *swig_obj[1] ;
26709
26710 if (!args) SWIG_fail;
26711 swig_obj[0] = args;
26712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26713 if (!SWIG_IsOK(res1)) {
26714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26715 }
26716 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26717 {
26718 PyThreadState* __tstate = wxPyBeginAllowThreads();
26719 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26720 wxPyEndAllowThreads(__tstate);
26721 if (PyErr_Occurred()) SWIG_fail;
26722 }
26723 {
26724 resultobj = wxPyMake_wxObject(result, (bool)0);
26725 }
26726 return resultobj;
26727 fail:
26728 return NULL;
26729 }
26730
26731
26732 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26733 PyObject *resultobj = 0;
26734 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26735 wxWindow *arg2 = (wxWindow *) 0 ;
26736 void *argp1 = 0 ;
26737 int res1 = 0 ;
26738 void *argp2 = 0 ;
26739 int res2 = 0 ;
26740 PyObject * obj0 = 0 ;
26741 PyObject * obj1 = 0 ;
26742 char * kwnames[] = {
26743 (char *) "self",(char *) "win", NULL
26744 };
26745
26746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26748 if (!SWIG_IsOK(res1)) {
26749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26750 }
26751 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26752 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26753 if (!SWIG_IsOK(res2)) {
26754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26755 }
26756 arg2 = reinterpret_cast< wxWindow * >(argp2);
26757 {
26758 PyThreadState* __tstate = wxPyBeginAllowThreads();
26759 (arg1)->SetWindow(arg2);
26760 wxPyEndAllowThreads(__tstate);
26761 if (PyErr_Occurred()) SWIG_fail;
26762 }
26763 resultobj = SWIG_Py_Void();
26764 return resultobj;
26765 fail:
26766 return NULL;
26767 }
26768
26769
26770 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26771 PyObject *obj;
26772 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26773 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26774 return SWIG_Py_Void();
26775 }
26776
26777 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26778 return SWIG_Python_InitShadowInstance(args);
26779 }
26780
26781 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26782 PyObject *resultobj = 0;
26783 wxWindow *arg1 = (wxWindow *) NULL ;
26784 wxChildFocusEvent *result = 0 ;
26785 void *argp1 = 0 ;
26786 int res1 = 0 ;
26787 PyObject * obj0 = 0 ;
26788 char * kwnames[] = {
26789 (char *) "win", NULL
26790 };
26791
26792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26793 if (obj0) {
26794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26795 if (!SWIG_IsOK(res1)) {
26796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26797 }
26798 arg1 = reinterpret_cast< wxWindow * >(argp1);
26799 }
26800 {
26801 PyThreadState* __tstate = wxPyBeginAllowThreads();
26802 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26803 wxPyEndAllowThreads(__tstate);
26804 if (PyErr_Occurred()) SWIG_fail;
26805 }
26806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26807 return resultobj;
26808 fail:
26809 return NULL;
26810 }
26811
26812
26813 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26814 PyObject *resultobj = 0;
26815 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26816 wxWindow *result = 0 ;
26817 void *argp1 = 0 ;
26818 int res1 = 0 ;
26819 PyObject *swig_obj[1] ;
26820
26821 if (!args) SWIG_fail;
26822 swig_obj[0] = args;
26823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26824 if (!SWIG_IsOK(res1)) {
26825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26826 }
26827 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26828 {
26829 PyThreadState* __tstate = wxPyBeginAllowThreads();
26830 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26831 wxPyEndAllowThreads(__tstate);
26832 if (PyErr_Occurred()) SWIG_fail;
26833 }
26834 {
26835 resultobj = wxPyMake_wxObject(result, (bool)0);
26836 }
26837 return resultobj;
26838 fail:
26839 return NULL;
26840 }
26841
26842
26843 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26844 PyObject *obj;
26845 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26846 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26847 return SWIG_Py_Void();
26848 }
26849
26850 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26851 return SWIG_Python_InitShadowInstance(args);
26852 }
26853
26854 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26855 PyObject *resultobj = 0;
26856 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26857 bool arg2 = (bool) true ;
26858 int arg3 = (int) 0 ;
26859 wxActivateEvent *result = 0 ;
26860 int val1 ;
26861 int ecode1 = 0 ;
26862 bool val2 ;
26863 int ecode2 = 0 ;
26864 int val3 ;
26865 int ecode3 = 0 ;
26866 PyObject * obj0 = 0 ;
26867 PyObject * obj1 = 0 ;
26868 PyObject * obj2 = 0 ;
26869 char * kwnames[] = {
26870 (char *) "type",(char *) "active",(char *) "Id", NULL
26871 };
26872
26873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26874 if (obj0) {
26875 ecode1 = SWIG_AsVal_int(obj0, &val1);
26876 if (!SWIG_IsOK(ecode1)) {
26877 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26878 }
26879 arg1 = static_cast< wxEventType >(val1);
26880 }
26881 if (obj1) {
26882 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26883 if (!SWIG_IsOK(ecode2)) {
26884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26885 }
26886 arg2 = static_cast< bool >(val2);
26887 }
26888 if (obj2) {
26889 ecode3 = SWIG_AsVal_int(obj2, &val3);
26890 if (!SWIG_IsOK(ecode3)) {
26891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26892 }
26893 arg3 = static_cast< int >(val3);
26894 }
26895 {
26896 PyThreadState* __tstate = wxPyBeginAllowThreads();
26897 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26898 wxPyEndAllowThreads(__tstate);
26899 if (PyErr_Occurred()) SWIG_fail;
26900 }
26901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26902 return resultobj;
26903 fail:
26904 return NULL;
26905 }
26906
26907
26908 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26909 PyObject *resultobj = 0;
26910 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26911 bool result;
26912 void *argp1 = 0 ;
26913 int res1 = 0 ;
26914 PyObject *swig_obj[1] ;
26915
26916 if (!args) SWIG_fail;
26917 swig_obj[0] = args;
26918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26919 if (!SWIG_IsOK(res1)) {
26920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26921 }
26922 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26923 {
26924 PyThreadState* __tstate = wxPyBeginAllowThreads();
26925 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26926 wxPyEndAllowThreads(__tstate);
26927 if (PyErr_Occurred()) SWIG_fail;
26928 }
26929 {
26930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26931 }
26932 return resultobj;
26933 fail:
26934 return NULL;
26935 }
26936
26937
26938 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26939 PyObject *obj;
26940 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26941 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26942 return SWIG_Py_Void();
26943 }
26944
26945 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26946 return SWIG_Python_InitShadowInstance(args);
26947 }
26948
26949 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26950 PyObject *resultobj = 0;
26951 int arg1 = (int) 0 ;
26952 wxInitDialogEvent *result = 0 ;
26953 int val1 ;
26954 int ecode1 = 0 ;
26955 PyObject * obj0 = 0 ;
26956 char * kwnames[] = {
26957 (char *) "Id", NULL
26958 };
26959
26960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26961 if (obj0) {
26962 ecode1 = SWIG_AsVal_int(obj0, &val1);
26963 if (!SWIG_IsOK(ecode1)) {
26964 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26965 }
26966 arg1 = static_cast< int >(val1);
26967 }
26968 {
26969 PyThreadState* __tstate = wxPyBeginAllowThreads();
26970 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26971 wxPyEndAllowThreads(__tstate);
26972 if (PyErr_Occurred()) SWIG_fail;
26973 }
26974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26975 return resultobj;
26976 fail:
26977 return NULL;
26978 }
26979
26980
26981 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26982 PyObject *obj;
26983 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26984 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26985 return SWIG_Py_Void();
26986 }
26987
26988 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26989 return SWIG_Python_InitShadowInstance(args);
26990 }
26991
26992 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26993 PyObject *resultobj = 0;
26994 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26995 int arg2 = (int) 0 ;
26996 wxMenu *arg3 = (wxMenu *) NULL ;
26997 wxMenuEvent *result = 0 ;
26998 int val1 ;
26999 int ecode1 = 0 ;
27000 int val2 ;
27001 int ecode2 = 0 ;
27002 void *argp3 = 0 ;
27003 int res3 = 0 ;
27004 PyObject * obj0 = 0 ;
27005 PyObject * obj1 = 0 ;
27006 PyObject * obj2 = 0 ;
27007 char * kwnames[] = {
27008 (char *) "type",(char *) "winid",(char *) "menu", NULL
27009 };
27010
27011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27012 if (obj0) {
27013 ecode1 = SWIG_AsVal_int(obj0, &val1);
27014 if (!SWIG_IsOK(ecode1)) {
27015 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27016 }
27017 arg1 = static_cast< wxEventType >(val1);
27018 }
27019 if (obj1) {
27020 ecode2 = SWIG_AsVal_int(obj1, &val2);
27021 if (!SWIG_IsOK(ecode2)) {
27022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
27023 }
27024 arg2 = static_cast< int >(val2);
27025 }
27026 if (obj2) {
27027 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
27028 if (!SWIG_IsOK(res3)) {
27029 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
27030 }
27031 arg3 = reinterpret_cast< wxMenu * >(argp3);
27032 }
27033 {
27034 PyThreadState* __tstate = wxPyBeginAllowThreads();
27035 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
27036 wxPyEndAllowThreads(__tstate);
27037 if (PyErr_Occurred()) SWIG_fail;
27038 }
27039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
27040 return resultobj;
27041 fail:
27042 return NULL;
27043 }
27044
27045
27046 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27047 PyObject *resultobj = 0;
27048 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27049 int result;
27050 void *argp1 = 0 ;
27051 int res1 = 0 ;
27052 PyObject *swig_obj[1] ;
27053
27054 if (!args) SWIG_fail;
27055 swig_obj[0] = args;
27056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27057 if (!SWIG_IsOK(res1)) {
27058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27059 }
27060 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27061 {
27062 PyThreadState* __tstate = wxPyBeginAllowThreads();
27063 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
27064 wxPyEndAllowThreads(__tstate);
27065 if (PyErr_Occurred()) SWIG_fail;
27066 }
27067 resultobj = SWIG_From_int(static_cast< int >(result));
27068 return resultobj;
27069 fail:
27070 return NULL;
27071 }
27072
27073
27074 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27075 PyObject *resultobj = 0;
27076 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27077 bool result;
27078 void *argp1 = 0 ;
27079 int res1 = 0 ;
27080 PyObject *swig_obj[1] ;
27081
27082 if (!args) SWIG_fail;
27083 swig_obj[0] = args;
27084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27085 if (!SWIG_IsOK(res1)) {
27086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27087 }
27088 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27089 {
27090 PyThreadState* __tstate = wxPyBeginAllowThreads();
27091 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27092 wxPyEndAllowThreads(__tstate);
27093 if (PyErr_Occurred()) SWIG_fail;
27094 }
27095 {
27096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27097 }
27098 return resultobj;
27099 fail:
27100 return NULL;
27101 }
27102
27103
27104 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27105 PyObject *resultobj = 0;
27106 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27107 wxMenu *result = 0 ;
27108 void *argp1 = 0 ;
27109 int res1 = 0 ;
27110 PyObject *swig_obj[1] ;
27111
27112 if (!args) SWIG_fail;
27113 swig_obj[0] = args;
27114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27115 if (!SWIG_IsOK(res1)) {
27116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27117 }
27118 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27119 {
27120 PyThreadState* __tstate = wxPyBeginAllowThreads();
27121 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27122 wxPyEndAllowThreads(__tstate);
27123 if (PyErr_Occurred()) SWIG_fail;
27124 }
27125 {
27126 resultobj = wxPyMake_wxObject(result, (bool)0);
27127 }
27128 return resultobj;
27129 fail:
27130 return NULL;
27131 }
27132
27133
27134 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27135 PyObject *obj;
27136 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27137 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27138 return SWIG_Py_Void();
27139 }
27140
27141 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27142 return SWIG_Python_InitShadowInstance(args);
27143 }
27144
27145 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27146 PyObject *resultobj = 0;
27147 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27148 int arg2 = (int) 0 ;
27149 wxCloseEvent *result = 0 ;
27150 int val1 ;
27151 int ecode1 = 0 ;
27152 int val2 ;
27153 int ecode2 = 0 ;
27154 PyObject * obj0 = 0 ;
27155 PyObject * obj1 = 0 ;
27156 char * kwnames[] = {
27157 (char *) "type",(char *) "winid", NULL
27158 };
27159
27160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27161 if (obj0) {
27162 ecode1 = SWIG_AsVal_int(obj0, &val1);
27163 if (!SWIG_IsOK(ecode1)) {
27164 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27165 }
27166 arg1 = static_cast< wxEventType >(val1);
27167 }
27168 if (obj1) {
27169 ecode2 = SWIG_AsVal_int(obj1, &val2);
27170 if (!SWIG_IsOK(ecode2)) {
27171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27172 }
27173 arg2 = static_cast< int >(val2);
27174 }
27175 {
27176 PyThreadState* __tstate = wxPyBeginAllowThreads();
27177 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27178 wxPyEndAllowThreads(__tstate);
27179 if (PyErr_Occurred()) SWIG_fail;
27180 }
27181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27182 return resultobj;
27183 fail:
27184 return NULL;
27185 }
27186
27187
27188 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27189 PyObject *resultobj = 0;
27190 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27191 bool arg2 ;
27192 void *argp1 = 0 ;
27193 int res1 = 0 ;
27194 bool val2 ;
27195 int ecode2 = 0 ;
27196 PyObject * obj0 = 0 ;
27197 PyObject * obj1 = 0 ;
27198 char * kwnames[] = {
27199 (char *) "self",(char *) "logOff", NULL
27200 };
27201
27202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27204 if (!SWIG_IsOK(res1)) {
27205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27206 }
27207 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27208 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27209 if (!SWIG_IsOK(ecode2)) {
27210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27211 }
27212 arg2 = static_cast< bool >(val2);
27213 {
27214 PyThreadState* __tstate = wxPyBeginAllowThreads();
27215 (arg1)->SetLoggingOff(arg2);
27216 wxPyEndAllowThreads(__tstate);
27217 if (PyErr_Occurred()) SWIG_fail;
27218 }
27219 resultobj = SWIG_Py_Void();
27220 return resultobj;
27221 fail:
27222 return NULL;
27223 }
27224
27225
27226 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27227 PyObject *resultobj = 0;
27228 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27229 bool result;
27230 void *argp1 = 0 ;
27231 int res1 = 0 ;
27232 PyObject *swig_obj[1] ;
27233
27234 if (!args) SWIG_fail;
27235 swig_obj[0] = args;
27236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27237 if (!SWIG_IsOK(res1)) {
27238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27239 }
27240 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27241 {
27242 PyThreadState* __tstate = wxPyBeginAllowThreads();
27243 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27244 wxPyEndAllowThreads(__tstate);
27245 if (PyErr_Occurred()) SWIG_fail;
27246 }
27247 {
27248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27249 }
27250 return resultobj;
27251 fail:
27252 return NULL;
27253 }
27254
27255
27256 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27257 PyObject *resultobj = 0;
27258 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27259 bool arg2 = (bool) true ;
27260 void *argp1 = 0 ;
27261 int res1 = 0 ;
27262 bool val2 ;
27263 int ecode2 = 0 ;
27264 PyObject * obj0 = 0 ;
27265 PyObject * obj1 = 0 ;
27266 char * kwnames[] = {
27267 (char *) "self",(char *) "veto", NULL
27268 };
27269
27270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27272 if (!SWIG_IsOK(res1)) {
27273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27274 }
27275 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27276 if (obj1) {
27277 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27278 if (!SWIG_IsOK(ecode2)) {
27279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27280 }
27281 arg2 = static_cast< bool >(val2);
27282 }
27283 {
27284 PyThreadState* __tstate = wxPyBeginAllowThreads();
27285 (arg1)->Veto(arg2);
27286 wxPyEndAllowThreads(__tstate);
27287 if (PyErr_Occurred()) SWIG_fail;
27288 }
27289 resultobj = SWIG_Py_Void();
27290 return resultobj;
27291 fail:
27292 return NULL;
27293 }
27294
27295
27296 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27297 PyObject *resultobj = 0;
27298 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27299 bool result;
27300 void *argp1 = 0 ;
27301 int res1 = 0 ;
27302 PyObject *swig_obj[1] ;
27303
27304 if (!args) SWIG_fail;
27305 swig_obj[0] = args;
27306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27307 if (!SWIG_IsOK(res1)) {
27308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27309 }
27310 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27311 {
27312 PyThreadState* __tstate = wxPyBeginAllowThreads();
27313 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27314 wxPyEndAllowThreads(__tstate);
27315 if (PyErr_Occurred()) SWIG_fail;
27316 }
27317 {
27318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27319 }
27320 return resultobj;
27321 fail:
27322 return NULL;
27323 }
27324
27325
27326 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27327 PyObject *resultobj = 0;
27328 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27329 bool arg2 ;
27330 void *argp1 = 0 ;
27331 int res1 = 0 ;
27332 bool val2 ;
27333 int ecode2 = 0 ;
27334 PyObject * obj0 = 0 ;
27335 PyObject * obj1 = 0 ;
27336 char * kwnames[] = {
27337 (char *) "self",(char *) "canVeto", NULL
27338 };
27339
27340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27342 if (!SWIG_IsOK(res1)) {
27343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27344 }
27345 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27346 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27347 if (!SWIG_IsOK(ecode2)) {
27348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27349 }
27350 arg2 = static_cast< bool >(val2);
27351 {
27352 PyThreadState* __tstate = wxPyBeginAllowThreads();
27353 (arg1)->SetCanVeto(arg2);
27354 wxPyEndAllowThreads(__tstate);
27355 if (PyErr_Occurred()) SWIG_fail;
27356 }
27357 resultobj = SWIG_Py_Void();
27358 return resultobj;
27359 fail:
27360 return NULL;
27361 }
27362
27363
27364 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27365 PyObject *resultobj = 0;
27366 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27367 bool result;
27368 void *argp1 = 0 ;
27369 int res1 = 0 ;
27370 PyObject *swig_obj[1] ;
27371
27372 if (!args) SWIG_fail;
27373 swig_obj[0] = args;
27374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27375 if (!SWIG_IsOK(res1)) {
27376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27377 }
27378 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27379 {
27380 PyThreadState* __tstate = wxPyBeginAllowThreads();
27381 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27382 wxPyEndAllowThreads(__tstate);
27383 if (PyErr_Occurred()) SWIG_fail;
27384 }
27385 {
27386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27387 }
27388 return resultobj;
27389 fail:
27390 return NULL;
27391 }
27392
27393
27394 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27395 PyObject *obj;
27396 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27397 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27398 return SWIG_Py_Void();
27399 }
27400
27401 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27402 return SWIG_Python_InitShadowInstance(args);
27403 }
27404
27405 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27406 PyObject *resultobj = 0;
27407 int arg1 = (int) 0 ;
27408 bool arg2 = (bool) false ;
27409 wxShowEvent *result = 0 ;
27410 int val1 ;
27411 int ecode1 = 0 ;
27412 bool val2 ;
27413 int ecode2 = 0 ;
27414 PyObject * obj0 = 0 ;
27415 PyObject * obj1 = 0 ;
27416 char * kwnames[] = {
27417 (char *) "winid",(char *) "show", NULL
27418 };
27419
27420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27421 if (obj0) {
27422 ecode1 = SWIG_AsVal_int(obj0, &val1);
27423 if (!SWIG_IsOK(ecode1)) {
27424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27425 }
27426 arg1 = static_cast< int >(val1);
27427 }
27428 if (obj1) {
27429 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27430 if (!SWIG_IsOK(ecode2)) {
27431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27432 }
27433 arg2 = static_cast< bool >(val2);
27434 }
27435 {
27436 PyThreadState* __tstate = wxPyBeginAllowThreads();
27437 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27438 wxPyEndAllowThreads(__tstate);
27439 if (PyErr_Occurred()) SWIG_fail;
27440 }
27441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27442 return resultobj;
27443 fail:
27444 return NULL;
27445 }
27446
27447
27448 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27449 PyObject *resultobj = 0;
27450 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27451 bool arg2 ;
27452 void *argp1 = 0 ;
27453 int res1 = 0 ;
27454 bool val2 ;
27455 int ecode2 = 0 ;
27456 PyObject * obj0 = 0 ;
27457 PyObject * obj1 = 0 ;
27458 char * kwnames[] = {
27459 (char *) "self",(char *) "show", NULL
27460 };
27461
27462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27464 if (!SWIG_IsOK(res1)) {
27465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27466 }
27467 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27468 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27469 if (!SWIG_IsOK(ecode2)) {
27470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27471 }
27472 arg2 = static_cast< bool >(val2);
27473 {
27474 PyThreadState* __tstate = wxPyBeginAllowThreads();
27475 (arg1)->SetShow(arg2);
27476 wxPyEndAllowThreads(__tstate);
27477 if (PyErr_Occurred()) SWIG_fail;
27478 }
27479 resultobj = SWIG_Py_Void();
27480 return resultobj;
27481 fail:
27482 return NULL;
27483 }
27484
27485
27486 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27487 PyObject *resultobj = 0;
27488 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27489 bool result;
27490 void *argp1 = 0 ;
27491 int res1 = 0 ;
27492 PyObject *swig_obj[1] ;
27493
27494 if (!args) SWIG_fail;
27495 swig_obj[0] = args;
27496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27497 if (!SWIG_IsOK(res1)) {
27498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27499 }
27500 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27501 {
27502 PyThreadState* __tstate = wxPyBeginAllowThreads();
27503 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27504 wxPyEndAllowThreads(__tstate);
27505 if (PyErr_Occurred()) SWIG_fail;
27506 }
27507 {
27508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27509 }
27510 return resultobj;
27511 fail:
27512 return NULL;
27513 }
27514
27515
27516 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27517 PyObject *obj;
27518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27519 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27520 return SWIG_Py_Void();
27521 }
27522
27523 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27524 return SWIG_Python_InitShadowInstance(args);
27525 }
27526
27527 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27528 PyObject *resultobj = 0;
27529 int arg1 = (int) 0 ;
27530 bool arg2 = (bool) true ;
27531 wxIconizeEvent *result = 0 ;
27532 int val1 ;
27533 int ecode1 = 0 ;
27534 bool val2 ;
27535 int ecode2 = 0 ;
27536 PyObject * obj0 = 0 ;
27537 PyObject * obj1 = 0 ;
27538 char * kwnames[] = {
27539 (char *) "id",(char *) "iconized", NULL
27540 };
27541
27542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27543 if (obj0) {
27544 ecode1 = SWIG_AsVal_int(obj0, &val1);
27545 if (!SWIG_IsOK(ecode1)) {
27546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27547 }
27548 arg1 = static_cast< int >(val1);
27549 }
27550 if (obj1) {
27551 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27552 if (!SWIG_IsOK(ecode2)) {
27553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27554 }
27555 arg2 = static_cast< bool >(val2);
27556 }
27557 {
27558 PyThreadState* __tstate = wxPyBeginAllowThreads();
27559 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27560 wxPyEndAllowThreads(__tstate);
27561 if (PyErr_Occurred()) SWIG_fail;
27562 }
27563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27564 return resultobj;
27565 fail:
27566 return NULL;
27567 }
27568
27569
27570 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27571 PyObject *resultobj = 0;
27572 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27573 bool result;
27574 void *argp1 = 0 ;
27575 int res1 = 0 ;
27576 PyObject *swig_obj[1] ;
27577
27578 if (!args) SWIG_fail;
27579 swig_obj[0] = args;
27580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27581 if (!SWIG_IsOK(res1)) {
27582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27583 }
27584 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27585 {
27586 PyThreadState* __tstate = wxPyBeginAllowThreads();
27587 result = (bool)(arg1)->Iconized();
27588 wxPyEndAllowThreads(__tstate);
27589 if (PyErr_Occurred()) SWIG_fail;
27590 }
27591 {
27592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27593 }
27594 return resultobj;
27595 fail:
27596 return NULL;
27597 }
27598
27599
27600 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27601 PyObject *obj;
27602 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27603 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27604 return SWIG_Py_Void();
27605 }
27606
27607 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27608 return SWIG_Python_InitShadowInstance(args);
27609 }
27610
27611 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27612 PyObject *resultobj = 0;
27613 int arg1 = (int) 0 ;
27614 wxMaximizeEvent *result = 0 ;
27615 int val1 ;
27616 int ecode1 = 0 ;
27617 PyObject * obj0 = 0 ;
27618 char * kwnames[] = {
27619 (char *) "id", NULL
27620 };
27621
27622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27623 if (obj0) {
27624 ecode1 = SWIG_AsVal_int(obj0, &val1);
27625 if (!SWIG_IsOK(ecode1)) {
27626 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27627 }
27628 arg1 = static_cast< int >(val1);
27629 }
27630 {
27631 PyThreadState* __tstate = wxPyBeginAllowThreads();
27632 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27633 wxPyEndAllowThreads(__tstate);
27634 if (PyErr_Occurred()) SWIG_fail;
27635 }
27636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27637 return resultobj;
27638 fail:
27639 return NULL;
27640 }
27641
27642
27643 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27644 PyObject *obj;
27645 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27646 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27647 return SWIG_Py_Void();
27648 }
27649
27650 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27651 return SWIG_Python_InitShadowInstance(args);
27652 }
27653
27654 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27655 PyObject *resultobj = 0;
27656 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27657 wxPoint result;
27658 void *argp1 = 0 ;
27659 int res1 = 0 ;
27660 PyObject *swig_obj[1] ;
27661
27662 if (!args) SWIG_fail;
27663 swig_obj[0] = args;
27664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27665 if (!SWIG_IsOK(res1)) {
27666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27667 }
27668 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27669 {
27670 PyThreadState* __tstate = wxPyBeginAllowThreads();
27671 result = (arg1)->GetPosition();
27672 wxPyEndAllowThreads(__tstate);
27673 if (PyErr_Occurred()) SWIG_fail;
27674 }
27675 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27676 return resultobj;
27677 fail:
27678 return NULL;
27679 }
27680
27681
27682 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27683 PyObject *resultobj = 0;
27684 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27685 int result;
27686 void *argp1 = 0 ;
27687 int res1 = 0 ;
27688 PyObject *swig_obj[1] ;
27689
27690 if (!args) SWIG_fail;
27691 swig_obj[0] = args;
27692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27693 if (!SWIG_IsOK(res1)) {
27694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27695 }
27696 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27697 {
27698 PyThreadState* __tstate = wxPyBeginAllowThreads();
27699 result = (int)(arg1)->GetNumberOfFiles();
27700 wxPyEndAllowThreads(__tstate);
27701 if (PyErr_Occurred()) SWIG_fail;
27702 }
27703 resultobj = SWIG_From_int(static_cast< int >(result));
27704 return resultobj;
27705 fail:
27706 return NULL;
27707 }
27708
27709
27710 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27711 PyObject *resultobj = 0;
27712 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27713 PyObject *result = 0 ;
27714 void *argp1 = 0 ;
27715 int res1 = 0 ;
27716 PyObject *swig_obj[1] ;
27717
27718 if (!args) SWIG_fail;
27719 swig_obj[0] = args;
27720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27721 if (!SWIG_IsOK(res1)) {
27722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27723 }
27724 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27725 {
27726 PyThreadState* __tstate = wxPyBeginAllowThreads();
27727 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27728 wxPyEndAllowThreads(__tstate);
27729 if (PyErr_Occurred()) SWIG_fail;
27730 }
27731 resultobj = result;
27732 return resultobj;
27733 fail:
27734 return NULL;
27735 }
27736
27737
27738 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27739 PyObject *obj;
27740 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27741 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27742 return SWIG_Py_Void();
27743 }
27744
27745 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27746 PyObject *resultobj = 0;
27747 int arg1 = (int) 0 ;
27748 wxUpdateUIEvent *result = 0 ;
27749 int val1 ;
27750 int ecode1 = 0 ;
27751 PyObject * obj0 = 0 ;
27752 char * kwnames[] = {
27753 (char *) "commandId", NULL
27754 };
27755
27756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27757 if (obj0) {
27758 ecode1 = SWIG_AsVal_int(obj0, &val1);
27759 if (!SWIG_IsOK(ecode1)) {
27760 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27761 }
27762 arg1 = static_cast< int >(val1);
27763 }
27764 {
27765 PyThreadState* __tstate = wxPyBeginAllowThreads();
27766 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27767 wxPyEndAllowThreads(__tstate);
27768 if (PyErr_Occurred()) SWIG_fail;
27769 }
27770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27771 return resultobj;
27772 fail:
27773 return NULL;
27774 }
27775
27776
27777 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27778 PyObject *resultobj = 0;
27779 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27780 bool result;
27781 void *argp1 = 0 ;
27782 int res1 = 0 ;
27783 PyObject *swig_obj[1] ;
27784
27785 if (!args) SWIG_fail;
27786 swig_obj[0] = args;
27787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27788 if (!SWIG_IsOK(res1)) {
27789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27790 }
27791 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27792 {
27793 PyThreadState* __tstate = wxPyBeginAllowThreads();
27794 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27795 wxPyEndAllowThreads(__tstate);
27796 if (PyErr_Occurred()) SWIG_fail;
27797 }
27798 {
27799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27800 }
27801 return resultobj;
27802 fail:
27803 return NULL;
27804 }
27805
27806
27807 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27808 PyObject *resultobj = 0;
27809 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27810 bool result;
27811 void *argp1 = 0 ;
27812 int res1 = 0 ;
27813 PyObject *swig_obj[1] ;
27814
27815 if (!args) SWIG_fail;
27816 swig_obj[0] = args;
27817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27818 if (!SWIG_IsOK(res1)) {
27819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27820 }
27821 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27822 {
27823 PyThreadState* __tstate = wxPyBeginAllowThreads();
27824 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27825 wxPyEndAllowThreads(__tstate);
27826 if (PyErr_Occurred()) SWIG_fail;
27827 }
27828 {
27829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27830 }
27831 return resultobj;
27832 fail:
27833 return NULL;
27834 }
27835
27836
27837 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27838 PyObject *resultobj = 0;
27839 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27840 bool result;
27841 void *argp1 = 0 ;
27842 int res1 = 0 ;
27843 PyObject *swig_obj[1] ;
27844
27845 if (!args) SWIG_fail;
27846 swig_obj[0] = args;
27847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27848 if (!SWIG_IsOK(res1)) {
27849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27850 }
27851 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27852 {
27853 PyThreadState* __tstate = wxPyBeginAllowThreads();
27854 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27855 wxPyEndAllowThreads(__tstate);
27856 if (PyErr_Occurred()) SWIG_fail;
27857 }
27858 {
27859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27860 }
27861 return resultobj;
27862 fail:
27863 return NULL;
27864 }
27865
27866
27867 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27868 PyObject *resultobj = 0;
27869 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27870 wxString result;
27871 void *argp1 = 0 ;
27872 int res1 = 0 ;
27873 PyObject *swig_obj[1] ;
27874
27875 if (!args) SWIG_fail;
27876 swig_obj[0] = args;
27877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27878 if (!SWIG_IsOK(res1)) {
27879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27880 }
27881 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27882 {
27883 PyThreadState* __tstate = wxPyBeginAllowThreads();
27884 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27885 wxPyEndAllowThreads(__tstate);
27886 if (PyErr_Occurred()) SWIG_fail;
27887 }
27888 {
27889 #if wxUSE_UNICODE
27890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27891 #else
27892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27893 #endif
27894 }
27895 return resultobj;
27896 fail:
27897 return NULL;
27898 }
27899
27900
27901 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27902 PyObject *resultobj = 0;
27903 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 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_wxUpdateUIEvent, 0 | 0 );
27912 if (!SWIG_IsOK(res1)) {
27913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27914 }
27915 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27916 {
27917 PyThreadState* __tstate = wxPyBeginAllowThreads();
27918 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
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 *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27932 PyObject *resultobj = 0;
27933 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27934 bool result;
27935 void *argp1 = 0 ;
27936 int res1 = 0 ;
27937 PyObject *swig_obj[1] ;
27938
27939 if (!args) SWIG_fail;
27940 swig_obj[0] = args;
27941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27942 if (!SWIG_IsOK(res1)) {
27943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27944 }
27945 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27946 {
27947 PyThreadState* __tstate = wxPyBeginAllowThreads();
27948 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 {
27953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27954 }
27955 return resultobj;
27956 fail:
27957 return NULL;
27958 }
27959
27960
27961 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27962 PyObject *resultobj = 0;
27963 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27964 bool result;
27965 void *argp1 = 0 ;
27966 int res1 = 0 ;
27967 PyObject *swig_obj[1] ;
27968
27969 if (!args) SWIG_fail;
27970 swig_obj[0] = args;
27971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27972 if (!SWIG_IsOK(res1)) {
27973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27974 }
27975 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27976 {
27977 PyThreadState* __tstate = wxPyBeginAllowThreads();
27978 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27979 wxPyEndAllowThreads(__tstate);
27980 if (PyErr_Occurred()) SWIG_fail;
27981 }
27982 {
27983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27984 }
27985 return resultobj;
27986 fail:
27987 return NULL;
27988 }
27989
27990
27991 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27992 PyObject *resultobj = 0;
27993 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27994 bool result;
27995 void *argp1 = 0 ;
27996 int res1 = 0 ;
27997 PyObject *swig_obj[1] ;
27998
27999 if (!args) SWIG_fail;
28000 swig_obj[0] = args;
28001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28002 if (!SWIG_IsOK(res1)) {
28003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28004 }
28005 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28006 {
28007 PyThreadState* __tstate = wxPyBeginAllowThreads();
28008 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
28009 wxPyEndAllowThreads(__tstate);
28010 if (PyErr_Occurred()) SWIG_fail;
28011 }
28012 {
28013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28014 }
28015 return resultobj;
28016 fail:
28017 return NULL;
28018 }
28019
28020
28021 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28022 PyObject *resultobj = 0;
28023 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28024 bool arg2 ;
28025 void *argp1 = 0 ;
28026 int res1 = 0 ;
28027 bool val2 ;
28028 int ecode2 = 0 ;
28029 PyObject * obj0 = 0 ;
28030 PyObject * obj1 = 0 ;
28031 char * kwnames[] = {
28032 (char *) "self",(char *) "check", NULL
28033 };
28034
28035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
28036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28037 if (!SWIG_IsOK(res1)) {
28038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28039 }
28040 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28041 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28042 if (!SWIG_IsOK(ecode2)) {
28043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
28044 }
28045 arg2 = static_cast< bool >(val2);
28046 {
28047 PyThreadState* __tstate = wxPyBeginAllowThreads();
28048 (arg1)->Check(arg2);
28049 wxPyEndAllowThreads(__tstate);
28050 if (PyErr_Occurred()) SWIG_fail;
28051 }
28052 resultobj = SWIG_Py_Void();
28053 return resultobj;
28054 fail:
28055 return NULL;
28056 }
28057
28058
28059 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28060 PyObject *resultobj = 0;
28061 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28062 bool arg2 ;
28063 void *argp1 = 0 ;
28064 int res1 = 0 ;
28065 bool val2 ;
28066 int ecode2 = 0 ;
28067 PyObject * obj0 = 0 ;
28068 PyObject * obj1 = 0 ;
28069 char * kwnames[] = {
28070 (char *) "self",(char *) "enable", NULL
28071 };
28072
28073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28075 if (!SWIG_IsOK(res1)) {
28076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28077 }
28078 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28079 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28080 if (!SWIG_IsOK(ecode2)) {
28081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28082 }
28083 arg2 = static_cast< bool >(val2);
28084 {
28085 PyThreadState* __tstate = wxPyBeginAllowThreads();
28086 (arg1)->Enable(arg2);
28087 wxPyEndAllowThreads(__tstate);
28088 if (PyErr_Occurred()) SWIG_fail;
28089 }
28090 resultobj = SWIG_Py_Void();
28091 return resultobj;
28092 fail:
28093 return NULL;
28094 }
28095
28096
28097 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28098 PyObject *resultobj = 0;
28099 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28100 bool arg2 ;
28101 void *argp1 = 0 ;
28102 int res1 = 0 ;
28103 bool val2 ;
28104 int ecode2 = 0 ;
28105 PyObject * obj0 = 0 ;
28106 PyObject * obj1 = 0 ;
28107 char * kwnames[] = {
28108 (char *) "self",(char *) "show", NULL
28109 };
28110
28111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28113 if (!SWIG_IsOK(res1)) {
28114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28115 }
28116 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28117 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28118 if (!SWIG_IsOK(ecode2)) {
28119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28120 }
28121 arg2 = static_cast< bool >(val2);
28122 {
28123 PyThreadState* __tstate = wxPyBeginAllowThreads();
28124 (arg1)->Show(arg2);
28125 wxPyEndAllowThreads(__tstate);
28126 if (PyErr_Occurred()) SWIG_fail;
28127 }
28128 resultobj = SWIG_Py_Void();
28129 return resultobj;
28130 fail:
28131 return NULL;
28132 }
28133
28134
28135 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28136 PyObject *resultobj = 0;
28137 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28138 wxString *arg2 = 0 ;
28139 void *argp1 = 0 ;
28140 int res1 = 0 ;
28141 bool temp2 = false ;
28142 PyObject * obj0 = 0 ;
28143 PyObject * obj1 = 0 ;
28144 char * kwnames[] = {
28145 (char *) "self",(char *) "text", NULL
28146 };
28147
28148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28150 if (!SWIG_IsOK(res1)) {
28151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28152 }
28153 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28154 {
28155 arg2 = wxString_in_helper(obj1);
28156 if (arg2 == NULL) SWIG_fail;
28157 temp2 = true;
28158 }
28159 {
28160 PyThreadState* __tstate = wxPyBeginAllowThreads();
28161 (arg1)->SetText((wxString const &)*arg2);
28162 wxPyEndAllowThreads(__tstate);
28163 if (PyErr_Occurred()) SWIG_fail;
28164 }
28165 resultobj = SWIG_Py_Void();
28166 {
28167 if (temp2)
28168 delete arg2;
28169 }
28170 return resultobj;
28171 fail:
28172 {
28173 if (temp2)
28174 delete arg2;
28175 }
28176 return NULL;
28177 }
28178
28179
28180 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28181 PyObject *resultobj = 0;
28182 long arg1 ;
28183 long val1 ;
28184 int ecode1 = 0 ;
28185 PyObject * obj0 = 0 ;
28186 char * kwnames[] = {
28187 (char *) "updateInterval", NULL
28188 };
28189
28190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28191 ecode1 = SWIG_AsVal_long(obj0, &val1);
28192 if (!SWIG_IsOK(ecode1)) {
28193 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28194 }
28195 arg1 = static_cast< long >(val1);
28196 {
28197 PyThreadState* __tstate = wxPyBeginAllowThreads();
28198 wxUpdateUIEvent::SetUpdateInterval(arg1);
28199 wxPyEndAllowThreads(__tstate);
28200 if (PyErr_Occurred()) SWIG_fail;
28201 }
28202 resultobj = SWIG_Py_Void();
28203 return resultobj;
28204 fail:
28205 return NULL;
28206 }
28207
28208
28209 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28210 PyObject *resultobj = 0;
28211 long result;
28212
28213 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28214 {
28215 PyThreadState* __tstate = wxPyBeginAllowThreads();
28216 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28217 wxPyEndAllowThreads(__tstate);
28218 if (PyErr_Occurred()) SWIG_fail;
28219 }
28220 resultobj = SWIG_From_long(static_cast< long >(result));
28221 return resultobj;
28222 fail:
28223 return NULL;
28224 }
28225
28226
28227 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28228 PyObject *resultobj = 0;
28229 wxWindow *arg1 = (wxWindow *) 0 ;
28230 bool result;
28231 void *argp1 = 0 ;
28232 int res1 = 0 ;
28233 PyObject * obj0 = 0 ;
28234 char * kwnames[] = {
28235 (char *) "win", NULL
28236 };
28237
28238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28240 if (!SWIG_IsOK(res1)) {
28241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28242 }
28243 arg1 = reinterpret_cast< wxWindow * >(argp1);
28244 {
28245 PyThreadState* __tstate = wxPyBeginAllowThreads();
28246 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28247 wxPyEndAllowThreads(__tstate);
28248 if (PyErr_Occurred()) SWIG_fail;
28249 }
28250 {
28251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28252 }
28253 return resultobj;
28254 fail:
28255 return NULL;
28256 }
28257
28258
28259 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28260 PyObject *resultobj = 0;
28261
28262 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28263 {
28264 PyThreadState* __tstate = wxPyBeginAllowThreads();
28265 wxUpdateUIEvent::ResetUpdateTime();
28266 wxPyEndAllowThreads(__tstate);
28267 if (PyErr_Occurred()) SWIG_fail;
28268 }
28269 resultobj = SWIG_Py_Void();
28270 return resultobj;
28271 fail:
28272 return NULL;
28273 }
28274
28275
28276 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28277 PyObject *resultobj = 0;
28278 wxUpdateUIMode arg1 ;
28279 int val1 ;
28280 int ecode1 = 0 ;
28281 PyObject * obj0 = 0 ;
28282 char * kwnames[] = {
28283 (char *) "mode", NULL
28284 };
28285
28286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28287 ecode1 = SWIG_AsVal_int(obj0, &val1);
28288 if (!SWIG_IsOK(ecode1)) {
28289 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28290 }
28291 arg1 = static_cast< wxUpdateUIMode >(val1);
28292 {
28293 PyThreadState* __tstate = wxPyBeginAllowThreads();
28294 wxUpdateUIEvent::SetMode(arg1);
28295 wxPyEndAllowThreads(__tstate);
28296 if (PyErr_Occurred()) SWIG_fail;
28297 }
28298 resultobj = SWIG_Py_Void();
28299 return resultobj;
28300 fail:
28301 return NULL;
28302 }
28303
28304
28305 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28306 PyObject *resultobj = 0;
28307 wxUpdateUIMode result;
28308
28309 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28310 {
28311 PyThreadState* __tstate = wxPyBeginAllowThreads();
28312 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28313 wxPyEndAllowThreads(__tstate);
28314 if (PyErr_Occurred()) SWIG_fail;
28315 }
28316 resultobj = SWIG_From_int(static_cast< int >(result));
28317 return resultobj;
28318 fail:
28319 return NULL;
28320 }
28321
28322
28323 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28324 PyObject *obj;
28325 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28326 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28327 return SWIG_Py_Void();
28328 }
28329
28330 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28331 return SWIG_Python_InitShadowInstance(args);
28332 }
28333
28334 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28335 PyObject *resultobj = 0;
28336 wxSysColourChangedEvent *result = 0 ;
28337
28338 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28339 {
28340 PyThreadState* __tstate = wxPyBeginAllowThreads();
28341 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28342 wxPyEndAllowThreads(__tstate);
28343 if (PyErr_Occurred()) SWIG_fail;
28344 }
28345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28346 return resultobj;
28347 fail:
28348 return NULL;
28349 }
28350
28351
28352 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28353 PyObject *obj;
28354 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28355 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28356 return SWIG_Py_Void();
28357 }
28358
28359 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28360 return SWIG_Python_InitShadowInstance(args);
28361 }
28362
28363 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28364 PyObject *resultobj = 0;
28365 int arg1 = (int) 0 ;
28366 wxWindow *arg2 = (wxWindow *) NULL ;
28367 wxMouseCaptureChangedEvent *result = 0 ;
28368 int val1 ;
28369 int ecode1 = 0 ;
28370 void *argp2 = 0 ;
28371 int res2 = 0 ;
28372 PyObject * obj0 = 0 ;
28373 PyObject * obj1 = 0 ;
28374 char * kwnames[] = {
28375 (char *) "winid",(char *) "gainedCapture", NULL
28376 };
28377
28378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28379 if (obj0) {
28380 ecode1 = SWIG_AsVal_int(obj0, &val1);
28381 if (!SWIG_IsOK(ecode1)) {
28382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28383 }
28384 arg1 = static_cast< int >(val1);
28385 }
28386 if (obj1) {
28387 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28388 if (!SWIG_IsOK(res2)) {
28389 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28390 }
28391 arg2 = reinterpret_cast< wxWindow * >(argp2);
28392 }
28393 {
28394 PyThreadState* __tstate = wxPyBeginAllowThreads();
28395 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28396 wxPyEndAllowThreads(__tstate);
28397 if (PyErr_Occurred()) SWIG_fail;
28398 }
28399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28400 return resultobj;
28401 fail:
28402 return NULL;
28403 }
28404
28405
28406 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28407 PyObject *resultobj = 0;
28408 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28409 wxWindow *result = 0 ;
28410 void *argp1 = 0 ;
28411 int res1 = 0 ;
28412 PyObject *swig_obj[1] ;
28413
28414 if (!args) SWIG_fail;
28415 swig_obj[0] = args;
28416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28417 if (!SWIG_IsOK(res1)) {
28418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28419 }
28420 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28421 {
28422 PyThreadState* __tstate = wxPyBeginAllowThreads();
28423 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28424 wxPyEndAllowThreads(__tstate);
28425 if (PyErr_Occurred()) SWIG_fail;
28426 }
28427 {
28428 resultobj = wxPyMake_wxObject(result, (bool)0);
28429 }
28430 return resultobj;
28431 fail:
28432 return NULL;
28433 }
28434
28435
28436 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28437 PyObject *obj;
28438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28439 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28440 return SWIG_Py_Void();
28441 }
28442
28443 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28444 return SWIG_Python_InitShadowInstance(args);
28445 }
28446
28447 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28448 PyObject *resultobj = 0;
28449 int arg1 = (int) 0 ;
28450 wxMouseCaptureLostEvent *result = 0 ;
28451 int val1 ;
28452 int ecode1 = 0 ;
28453 PyObject * obj0 = 0 ;
28454 char * kwnames[] = {
28455 (char *) "winid", NULL
28456 };
28457
28458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28459 if (obj0) {
28460 ecode1 = SWIG_AsVal_int(obj0, &val1);
28461 if (!SWIG_IsOK(ecode1)) {
28462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28463 }
28464 arg1 = static_cast< int >(val1);
28465 }
28466 {
28467 PyThreadState* __tstate = wxPyBeginAllowThreads();
28468 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28469 wxPyEndAllowThreads(__tstate);
28470 if (PyErr_Occurred()) SWIG_fail;
28471 }
28472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28473 return resultobj;
28474 fail:
28475 return NULL;
28476 }
28477
28478
28479 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28480 PyObject *obj;
28481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28482 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28483 return SWIG_Py_Void();
28484 }
28485
28486 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28487 return SWIG_Python_InitShadowInstance(args);
28488 }
28489
28490 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28491 PyObject *resultobj = 0;
28492 wxDisplayChangedEvent *result = 0 ;
28493
28494 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28495 {
28496 PyThreadState* __tstate = wxPyBeginAllowThreads();
28497 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28498 wxPyEndAllowThreads(__tstate);
28499 if (PyErr_Occurred()) SWIG_fail;
28500 }
28501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28502 return resultobj;
28503 fail:
28504 return NULL;
28505 }
28506
28507
28508 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28509 PyObject *obj;
28510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28511 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28512 return SWIG_Py_Void();
28513 }
28514
28515 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28516 return SWIG_Python_InitShadowInstance(args);
28517 }
28518
28519 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28520 PyObject *resultobj = 0;
28521 int arg1 = (int) 0 ;
28522 wxPaletteChangedEvent *result = 0 ;
28523 int val1 ;
28524 int ecode1 = 0 ;
28525 PyObject * obj0 = 0 ;
28526 char * kwnames[] = {
28527 (char *) "id", NULL
28528 };
28529
28530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28531 if (obj0) {
28532 ecode1 = SWIG_AsVal_int(obj0, &val1);
28533 if (!SWIG_IsOK(ecode1)) {
28534 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28535 }
28536 arg1 = static_cast< int >(val1);
28537 }
28538 {
28539 PyThreadState* __tstate = wxPyBeginAllowThreads();
28540 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28541 wxPyEndAllowThreads(__tstate);
28542 if (PyErr_Occurred()) SWIG_fail;
28543 }
28544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28545 return resultobj;
28546 fail:
28547 return NULL;
28548 }
28549
28550
28551 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28552 PyObject *resultobj = 0;
28553 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28554 wxWindow *arg2 = (wxWindow *) 0 ;
28555 void *argp1 = 0 ;
28556 int res1 = 0 ;
28557 void *argp2 = 0 ;
28558 int res2 = 0 ;
28559 PyObject * obj0 = 0 ;
28560 PyObject * obj1 = 0 ;
28561 char * kwnames[] = {
28562 (char *) "self",(char *) "win", NULL
28563 };
28564
28565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28567 if (!SWIG_IsOK(res1)) {
28568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28569 }
28570 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28571 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28572 if (!SWIG_IsOK(res2)) {
28573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28574 }
28575 arg2 = reinterpret_cast< wxWindow * >(argp2);
28576 {
28577 PyThreadState* __tstate = wxPyBeginAllowThreads();
28578 (arg1)->SetChangedWindow(arg2);
28579 wxPyEndAllowThreads(__tstate);
28580 if (PyErr_Occurred()) SWIG_fail;
28581 }
28582 resultobj = SWIG_Py_Void();
28583 return resultobj;
28584 fail:
28585 return NULL;
28586 }
28587
28588
28589 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28590 PyObject *resultobj = 0;
28591 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28592 wxWindow *result = 0 ;
28593 void *argp1 = 0 ;
28594 int res1 = 0 ;
28595 PyObject *swig_obj[1] ;
28596
28597 if (!args) SWIG_fail;
28598 swig_obj[0] = args;
28599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28600 if (!SWIG_IsOK(res1)) {
28601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28602 }
28603 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28604 {
28605 PyThreadState* __tstate = wxPyBeginAllowThreads();
28606 result = (wxWindow *)(arg1)->GetChangedWindow();
28607 wxPyEndAllowThreads(__tstate);
28608 if (PyErr_Occurred()) SWIG_fail;
28609 }
28610 {
28611 resultobj = wxPyMake_wxObject(result, (bool)0);
28612 }
28613 return resultobj;
28614 fail:
28615 return NULL;
28616 }
28617
28618
28619 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28620 PyObject *obj;
28621 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28622 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28623 return SWIG_Py_Void();
28624 }
28625
28626 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28627 return SWIG_Python_InitShadowInstance(args);
28628 }
28629
28630 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28631 PyObject *resultobj = 0;
28632 int arg1 = (int) 0 ;
28633 wxQueryNewPaletteEvent *result = 0 ;
28634 int val1 ;
28635 int ecode1 = 0 ;
28636 PyObject * obj0 = 0 ;
28637 char * kwnames[] = {
28638 (char *) "winid", NULL
28639 };
28640
28641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28642 if (obj0) {
28643 ecode1 = SWIG_AsVal_int(obj0, &val1);
28644 if (!SWIG_IsOK(ecode1)) {
28645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28646 }
28647 arg1 = static_cast< int >(val1);
28648 }
28649 {
28650 PyThreadState* __tstate = wxPyBeginAllowThreads();
28651 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28652 wxPyEndAllowThreads(__tstate);
28653 if (PyErr_Occurred()) SWIG_fail;
28654 }
28655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28656 return resultobj;
28657 fail:
28658 return NULL;
28659 }
28660
28661
28662 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28663 PyObject *resultobj = 0;
28664 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28665 bool arg2 ;
28666 void *argp1 = 0 ;
28667 int res1 = 0 ;
28668 bool val2 ;
28669 int ecode2 = 0 ;
28670 PyObject * obj0 = 0 ;
28671 PyObject * obj1 = 0 ;
28672 char * kwnames[] = {
28673 (char *) "self",(char *) "realized", NULL
28674 };
28675
28676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28678 if (!SWIG_IsOK(res1)) {
28679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28680 }
28681 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28682 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28683 if (!SWIG_IsOK(ecode2)) {
28684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28685 }
28686 arg2 = static_cast< bool >(val2);
28687 {
28688 PyThreadState* __tstate = wxPyBeginAllowThreads();
28689 (arg1)->SetPaletteRealized(arg2);
28690 wxPyEndAllowThreads(__tstate);
28691 if (PyErr_Occurred()) SWIG_fail;
28692 }
28693 resultobj = SWIG_Py_Void();
28694 return resultobj;
28695 fail:
28696 return NULL;
28697 }
28698
28699
28700 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28701 PyObject *resultobj = 0;
28702 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28703 bool result;
28704 void *argp1 = 0 ;
28705 int res1 = 0 ;
28706 PyObject *swig_obj[1] ;
28707
28708 if (!args) SWIG_fail;
28709 swig_obj[0] = args;
28710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28711 if (!SWIG_IsOK(res1)) {
28712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28713 }
28714 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28718 wxPyEndAllowThreads(__tstate);
28719 if (PyErr_Occurred()) SWIG_fail;
28720 }
28721 {
28722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28723 }
28724 return resultobj;
28725 fail:
28726 return NULL;
28727 }
28728
28729
28730 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28731 PyObject *obj;
28732 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28733 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28734 return SWIG_Py_Void();
28735 }
28736
28737 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28738 return SWIG_Python_InitShadowInstance(args);
28739 }
28740
28741 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28742 PyObject *resultobj = 0;
28743 wxNavigationKeyEvent *result = 0 ;
28744
28745 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28746 {
28747 PyThreadState* __tstate = wxPyBeginAllowThreads();
28748 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28749 wxPyEndAllowThreads(__tstate);
28750 if (PyErr_Occurred()) SWIG_fail;
28751 }
28752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28753 return resultobj;
28754 fail:
28755 return NULL;
28756 }
28757
28758
28759 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28760 PyObject *resultobj = 0;
28761 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28762 bool result;
28763 void *argp1 = 0 ;
28764 int res1 = 0 ;
28765 PyObject *swig_obj[1] ;
28766
28767 if (!args) SWIG_fail;
28768 swig_obj[0] = args;
28769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28770 if (!SWIG_IsOK(res1)) {
28771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28772 }
28773 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28774 {
28775 PyThreadState* __tstate = wxPyBeginAllowThreads();
28776 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28777 wxPyEndAllowThreads(__tstate);
28778 if (PyErr_Occurred()) SWIG_fail;
28779 }
28780 {
28781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28782 }
28783 return resultobj;
28784 fail:
28785 return NULL;
28786 }
28787
28788
28789 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28790 PyObject *resultobj = 0;
28791 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28792 bool arg2 ;
28793 void *argp1 = 0 ;
28794 int res1 = 0 ;
28795 bool val2 ;
28796 int ecode2 = 0 ;
28797 PyObject * obj0 = 0 ;
28798 PyObject * obj1 = 0 ;
28799 char * kwnames[] = {
28800 (char *) "self",(char *) "forward", NULL
28801 };
28802
28803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28805 if (!SWIG_IsOK(res1)) {
28806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28807 }
28808 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28809 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28810 if (!SWIG_IsOK(ecode2)) {
28811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28812 }
28813 arg2 = static_cast< bool >(val2);
28814 {
28815 PyThreadState* __tstate = wxPyBeginAllowThreads();
28816 (arg1)->SetDirection(arg2);
28817 wxPyEndAllowThreads(__tstate);
28818 if (PyErr_Occurred()) SWIG_fail;
28819 }
28820 resultobj = SWIG_Py_Void();
28821 return resultobj;
28822 fail:
28823 return NULL;
28824 }
28825
28826
28827 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28828 PyObject *resultobj = 0;
28829 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28830 bool result;
28831 void *argp1 = 0 ;
28832 int res1 = 0 ;
28833 PyObject *swig_obj[1] ;
28834
28835 if (!args) SWIG_fail;
28836 swig_obj[0] = args;
28837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28838 if (!SWIG_IsOK(res1)) {
28839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28840 }
28841 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28842 {
28843 PyThreadState* __tstate = wxPyBeginAllowThreads();
28844 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28845 wxPyEndAllowThreads(__tstate);
28846 if (PyErr_Occurred()) SWIG_fail;
28847 }
28848 {
28849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28850 }
28851 return resultobj;
28852 fail:
28853 return NULL;
28854 }
28855
28856
28857 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28858 PyObject *resultobj = 0;
28859 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28860 bool arg2 ;
28861 void *argp1 = 0 ;
28862 int res1 = 0 ;
28863 bool val2 ;
28864 int ecode2 = 0 ;
28865 PyObject * obj0 = 0 ;
28866 PyObject * obj1 = 0 ;
28867 char * kwnames[] = {
28868 (char *) "self",(char *) "ischange", NULL
28869 };
28870
28871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28873 if (!SWIG_IsOK(res1)) {
28874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28875 }
28876 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28877 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28878 if (!SWIG_IsOK(ecode2)) {
28879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28880 }
28881 arg2 = static_cast< bool >(val2);
28882 {
28883 PyThreadState* __tstate = wxPyBeginAllowThreads();
28884 (arg1)->SetWindowChange(arg2);
28885 wxPyEndAllowThreads(__tstate);
28886 if (PyErr_Occurred()) SWIG_fail;
28887 }
28888 resultobj = SWIG_Py_Void();
28889 return resultobj;
28890 fail:
28891 return NULL;
28892 }
28893
28894
28895 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28896 PyObject *resultobj = 0;
28897 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28898 bool result;
28899 void *argp1 = 0 ;
28900 int res1 = 0 ;
28901 PyObject *swig_obj[1] ;
28902
28903 if (!args) SWIG_fail;
28904 swig_obj[0] = args;
28905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28906 if (!SWIG_IsOK(res1)) {
28907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28908 }
28909 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28910 {
28911 PyThreadState* __tstate = wxPyBeginAllowThreads();
28912 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28913 wxPyEndAllowThreads(__tstate);
28914 if (PyErr_Occurred()) SWIG_fail;
28915 }
28916 {
28917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28918 }
28919 return resultobj;
28920 fail:
28921 return NULL;
28922 }
28923
28924
28925 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28926 PyObject *resultobj = 0;
28927 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28928 bool arg2 ;
28929 void *argp1 = 0 ;
28930 int res1 = 0 ;
28931 bool val2 ;
28932 int ecode2 = 0 ;
28933 PyObject * obj0 = 0 ;
28934 PyObject * obj1 = 0 ;
28935 char * kwnames[] = {
28936 (char *) "self",(char *) "bIs", NULL
28937 };
28938
28939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28941 if (!SWIG_IsOK(res1)) {
28942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28943 }
28944 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28945 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28946 if (!SWIG_IsOK(ecode2)) {
28947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28948 }
28949 arg2 = static_cast< bool >(val2);
28950 {
28951 PyThreadState* __tstate = wxPyBeginAllowThreads();
28952 (arg1)->SetFromTab(arg2);
28953 wxPyEndAllowThreads(__tstate);
28954 if (PyErr_Occurred()) SWIG_fail;
28955 }
28956 resultobj = SWIG_Py_Void();
28957 return resultobj;
28958 fail:
28959 return NULL;
28960 }
28961
28962
28963 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28964 PyObject *resultobj = 0;
28965 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28966 long arg2 ;
28967 void *argp1 = 0 ;
28968 int res1 = 0 ;
28969 long val2 ;
28970 int ecode2 = 0 ;
28971 PyObject * obj0 = 0 ;
28972 PyObject * obj1 = 0 ;
28973 char * kwnames[] = {
28974 (char *) "self",(char *) "flags", NULL
28975 };
28976
28977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28979 if (!SWIG_IsOK(res1)) {
28980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28981 }
28982 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28983 ecode2 = SWIG_AsVal_long(obj1, &val2);
28984 if (!SWIG_IsOK(ecode2)) {
28985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28986 }
28987 arg2 = static_cast< long >(val2);
28988 {
28989 PyThreadState* __tstate = wxPyBeginAllowThreads();
28990 (arg1)->SetFlags(arg2);
28991 wxPyEndAllowThreads(__tstate);
28992 if (PyErr_Occurred()) SWIG_fail;
28993 }
28994 resultobj = SWIG_Py_Void();
28995 return resultobj;
28996 fail:
28997 return NULL;
28998 }
28999
29000
29001 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29002 PyObject *resultobj = 0;
29003 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29004 wxWindow *result = 0 ;
29005 void *argp1 = 0 ;
29006 int res1 = 0 ;
29007 PyObject *swig_obj[1] ;
29008
29009 if (!args) SWIG_fail;
29010 swig_obj[0] = args;
29011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29012 if (!SWIG_IsOK(res1)) {
29013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29014 }
29015 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29016 {
29017 PyThreadState* __tstate = wxPyBeginAllowThreads();
29018 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
29019 wxPyEndAllowThreads(__tstate);
29020 if (PyErr_Occurred()) SWIG_fail;
29021 }
29022 {
29023 resultobj = wxPyMake_wxObject(result, (bool)0);
29024 }
29025 return resultobj;
29026 fail:
29027 return NULL;
29028 }
29029
29030
29031 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29032 PyObject *resultobj = 0;
29033 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29034 wxWindow *arg2 = (wxWindow *) 0 ;
29035 void *argp1 = 0 ;
29036 int res1 = 0 ;
29037 void *argp2 = 0 ;
29038 int res2 = 0 ;
29039 PyObject * obj0 = 0 ;
29040 PyObject * obj1 = 0 ;
29041 char * kwnames[] = {
29042 (char *) "self",(char *) "win", NULL
29043 };
29044
29045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
29046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29047 if (!SWIG_IsOK(res1)) {
29048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29049 }
29050 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29051 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29052 if (!SWIG_IsOK(res2)) {
29053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
29054 }
29055 arg2 = reinterpret_cast< wxWindow * >(argp2);
29056 {
29057 PyThreadState* __tstate = wxPyBeginAllowThreads();
29058 (arg1)->SetCurrentFocus(arg2);
29059 wxPyEndAllowThreads(__tstate);
29060 if (PyErr_Occurred()) SWIG_fail;
29061 }
29062 resultobj = SWIG_Py_Void();
29063 return resultobj;
29064 fail:
29065 return NULL;
29066 }
29067
29068
29069 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29070 PyObject *obj;
29071 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29072 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
29073 return SWIG_Py_Void();
29074 }
29075
29076 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29077 return SWIG_Python_InitShadowInstance(args);
29078 }
29079
29080 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29081 PyObject *resultobj = 0;
29082 wxWindow *arg1 = (wxWindow *) NULL ;
29083 wxWindowCreateEvent *result = 0 ;
29084 void *argp1 = 0 ;
29085 int res1 = 0 ;
29086 PyObject * obj0 = 0 ;
29087 char * kwnames[] = {
29088 (char *) "win", NULL
29089 };
29090
29091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29092 if (obj0) {
29093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29094 if (!SWIG_IsOK(res1)) {
29095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29096 }
29097 arg1 = reinterpret_cast< wxWindow * >(argp1);
29098 }
29099 {
29100 PyThreadState* __tstate = wxPyBeginAllowThreads();
29101 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29102 wxPyEndAllowThreads(__tstate);
29103 if (PyErr_Occurred()) SWIG_fail;
29104 }
29105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29106 return resultobj;
29107 fail:
29108 return NULL;
29109 }
29110
29111
29112 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29113 PyObject *resultobj = 0;
29114 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29115 wxWindow *result = 0 ;
29116 void *argp1 = 0 ;
29117 int res1 = 0 ;
29118 PyObject *swig_obj[1] ;
29119
29120 if (!args) SWIG_fail;
29121 swig_obj[0] = args;
29122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29123 if (!SWIG_IsOK(res1)) {
29124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29125 }
29126 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29127 {
29128 PyThreadState* __tstate = wxPyBeginAllowThreads();
29129 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29130 wxPyEndAllowThreads(__tstate);
29131 if (PyErr_Occurred()) SWIG_fail;
29132 }
29133 {
29134 resultobj = wxPyMake_wxObject(result, (bool)0);
29135 }
29136 return resultobj;
29137 fail:
29138 return NULL;
29139 }
29140
29141
29142 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29143 PyObject *obj;
29144 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29145 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29146 return SWIG_Py_Void();
29147 }
29148
29149 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29150 return SWIG_Python_InitShadowInstance(args);
29151 }
29152
29153 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29154 PyObject *resultobj = 0;
29155 wxWindow *arg1 = (wxWindow *) NULL ;
29156 wxWindowDestroyEvent *result = 0 ;
29157 void *argp1 = 0 ;
29158 int res1 = 0 ;
29159 PyObject * obj0 = 0 ;
29160 char * kwnames[] = {
29161 (char *) "win", NULL
29162 };
29163
29164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29165 if (obj0) {
29166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29167 if (!SWIG_IsOK(res1)) {
29168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29169 }
29170 arg1 = reinterpret_cast< wxWindow * >(argp1);
29171 }
29172 {
29173 PyThreadState* __tstate = wxPyBeginAllowThreads();
29174 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29175 wxPyEndAllowThreads(__tstate);
29176 if (PyErr_Occurred()) SWIG_fail;
29177 }
29178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29179 return resultobj;
29180 fail:
29181 return NULL;
29182 }
29183
29184
29185 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29186 PyObject *resultobj = 0;
29187 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29188 wxWindow *result = 0 ;
29189 void *argp1 = 0 ;
29190 int res1 = 0 ;
29191 PyObject *swig_obj[1] ;
29192
29193 if (!args) SWIG_fail;
29194 swig_obj[0] = args;
29195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29196 if (!SWIG_IsOK(res1)) {
29197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29198 }
29199 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29200 {
29201 PyThreadState* __tstate = wxPyBeginAllowThreads();
29202 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29203 wxPyEndAllowThreads(__tstate);
29204 if (PyErr_Occurred()) SWIG_fail;
29205 }
29206 {
29207 resultobj = wxPyMake_wxObject(result, (bool)0);
29208 }
29209 return resultobj;
29210 fail:
29211 return NULL;
29212 }
29213
29214
29215 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29216 PyObject *obj;
29217 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29218 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29219 return SWIG_Py_Void();
29220 }
29221
29222 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29223 return SWIG_Python_InitShadowInstance(args);
29224 }
29225
29226 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29227 PyObject *resultobj = 0;
29228 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29229 int arg2 = (int) 0 ;
29230 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29231 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29232 wxContextMenuEvent *result = 0 ;
29233 int val1 ;
29234 int ecode1 = 0 ;
29235 int val2 ;
29236 int ecode2 = 0 ;
29237 wxPoint temp3 ;
29238 PyObject * obj0 = 0 ;
29239 PyObject * obj1 = 0 ;
29240 PyObject * obj2 = 0 ;
29241 char * kwnames[] = {
29242 (char *) "type",(char *) "winid",(char *) "pt", NULL
29243 };
29244
29245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29246 if (obj0) {
29247 ecode1 = SWIG_AsVal_int(obj0, &val1);
29248 if (!SWIG_IsOK(ecode1)) {
29249 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29250 }
29251 arg1 = static_cast< wxEventType >(val1);
29252 }
29253 if (obj1) {
29254 ecode2 = SWIG_AsVal_int(obj1, &val2);
29255 if (!SWIG_IsOK(ecode2)) {
29256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29257 }
29258 arg2 = static_cast< int >(val2);
29259 }
29260 if (obj2) {
29261 {
29262 arg3 = &temp3;
29263 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29264 }
29265 }
29266 {
29267 PyThreadState* __tstate = wxPyBeginAllowThreads();
29268 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29269 wxPyEndAllowThreads(__tstate);
29270 if (PyErr_Occurred()) SWIG_fail;
29271 }
29272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29273 return resultobj;
29274 fail:
29275 return NULL;
29276 }
29277
29278
29279 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29280 PyObject *resultobj = 0;
29281 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29282 wxPoint *result = 0 ;
29283 void *argp1 = 0 ;
29284 int res1 = 0 ;
29285 PyObject *swig_obj[1] ;
29286
29287 if (!args) SWIG_fail;
29288 swig_obj[0] = args;
29289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29290 if (!SWIG_IsOK(res1)) {
29291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29292 }
29293 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29294 {
29295 PyThreadState* __tstate = wxPyBeginAllowThreads();
29296 {
29297 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29298 result = (wxPoint *) &_result_ref;
29299 }
29300 wxPyEndAllowThreads(__tstate);
29301 if (PyErr_Occurred()) SWIG_fail;
29302 }
29303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29304 return resultobj;
29305 fail:
29306 return NULL;
29307 }
29308
29309
29310 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29311 PyObject *resultobj = 0;
29312 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29313 wxPoint *arg2 = 0 ;
29314 void *argp1 = 0 ;
29315 int res1 = 0 ;
29316 wxPoint temp2 ;
29317 PyObject * obj0 = 0 ;
29318 PyObject * obj1 = 0 ;
29319 char * kwnames[] = {
29320 (char *) "self",(char *) "pos", NULL
29321 };
29322
29323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29325 if (!SWIG_IsOK(res1)) {
29326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29327 }
29328 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29329 {
29330 arg2 = &temp2;
29331 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29332 }
29333 {
29334 PyThreadState* __tstate = wxPyBeginAllowThreads();
29335 (arg1)->SetPosition((wxPoint const &)*arg2);
29336 wxPyEndAllowThreads(__tstate);
29337 if (PyErr_Occurred()) SWIG_fail;
29338 }
29339 resultobj = SWIG_Py_Void();
29340 return resultobj;
29341 fail:
29342 return NULL;
29343 }
29344
29345
29346 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29347 PyObject *obj;
29348 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29349 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29350 return SWIG_Py_Void();
29351 }
29352
29353 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29354 return SWIG_Python_InitShadowInstance(args);
29355 }
29356
29357 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29358 PyObject *resultobj = 0;
29359 wxIdleEvent *result = 0 ;
29360
29361 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 result = (wxIdleEvent *)new wxIdleEvent();
29365 wxPyEndAllowThreads(__tstate);
29366 if (PyErr_Occurred()) SWIG_fail;
29367 }
29368 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29369 return resultobj;
29370 fail:
29371 return NULL;
29372 }
29373
29374
29375 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29376 PyObject *resultobj = 0;
29377 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29378 bool arg2 = (bool) true ;
29379 void *argp1 = 0 ;
29380 int res1 = 0 ;
29381 bool val2 ;
29382 int ecode2 = 0 ;
29383 PyObject * obj0 = 0 ;
29384 PyObject * obj1 = 0 ;
29385 char * kwnames[] = {
29386 (char *) "self",(char *) "needMore", NULL
29387 };
29388
29389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29391 if (!SWIG_IsOK(res1)) {
29392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29393 }
29394 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29395 if (obj1) {
29396 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29397 if (!SWIG_IsOK(ecode2)) {
29398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29399 }
29400 arg2 = static_cast< bool >(val2);
29401 }
29402 {
29403 PyThreadState* __tstate = wxPyBeginAllowThreads();
29404 (arg1)->RequestMore(arg2);
29405 wxPyEndAllowThreads(__tstate);
29406 if (PyErr_Occurred()) SWIG_fail;
29407 }
29408 resultobj = SWIG_Py_Void();
29409 return resultobj;
29410 fail:
29411 return NULL;
29412 }
29413
29414
29415 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29416 PyObject *resultobj = 0;
29417 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29418 bool result;
29419 void *argp1 = 0 ;
29420 int res1 = 0 ;
29421 PyObject *swig_obj[1] ;
29422
29423 if (!args) SWIG_fail;
29424 swig_obj[0] = args;
29425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29426 if (!SWIG_IsOK(res1)) {
29427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29428 }
29429 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29430 {
29431 PyThreadState* __tstate = wxPyBeginAllowThreads();
29432 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29433 wxPyEndAllowThreads(__tstate);
29434 if (PyErr_Occurred()) SWIG_fail;
29435 }
29436 {
29437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29438 }
29439 return resultobj;
29440 fail:
29441 return NULL;
29442 }
29443
29444
29445 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29446 PyObject *resultobj = 0;
29447 wxIdleMode arg1 ;
29448 int val1 ;
29449 int ecode1 = 0 ;
29450 PyObject * obj0 = 0 ;
29451 char * kwnames[] = {
29452 (char *) "mode", NULL
29453 };
29454
29455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29456 ecode1 = SWIG_AsVal_int(obj0, &val1);
29457 if (!SWIG_IsOK(ecode1)) {
29458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29459 }
29460 arg1 = static_cast< wxIdleMode >(val1);
29461 {
29462 PyThreadState* __tstate = wxPyBeginAllowThreads();
29463 wxIdleEvent::SetMode(arg1);
29464 wxPyEndAllowThreads(__tstate);
29465 if (PyErr_Occurred()) SWIG_fail;
29466 }
29467 resultobj = SWIG_Py_Void();
29468 return resultobj;
29469 fail:
29470 return NULL;
29471 }
29472
29473
29474 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29475 PyObject *resultobj = 0;
29476 wxIdleMode result;
29477
29478 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29479 {
29480 PyThreadState* __tstate = wxPyBeginAllowThreads();
29481 result = (wxIdleMode)wxIdleEvent::GetMode();
29482 wxPyEndAllowThreads(__tstate);
29483 if (PyErr_Occurred()) SWIG_fail;
29484 }
29485 resultobj = SWIG_From_int(static_cast< int >(result));
29486 return resultobj;
29487 fail:
29488 return NULL;
29489 }
29490
29491
29492 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29493 PyObject *resultobj = 0;
29494 wxWindow *arg1 = (wxWindow *) 0 ;
29495 bool result;
29496 void *argp1 = 0 ;
29497 int res1 = 0 ;
29498 PyObject * obj0 = 0 ;
29499 char * kwnames[] = {
29500 (char *) "win", NULL
29501 };
29502
29503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29505 if (!SWIG_IsOK(res1)) {
29506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29507 }
29508 arg1 = reinterpret_cast< wxWindow * >(argp1);
29509 {
29510 PyThreadState* __tstate = wxPyBeginAllowThreads();
29511 result = (bool)wxIdleEvent::CanSend(arg1);
29512 wxPyEndAllowThreads(__tstate);
29513 if (PyErr_Occurred()) SWIG_fail;
29514 }
29515 {
29516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29517 }
29518 return resultobj;
29519 fail:
29520 return NULL;
29521 }
29522
29523
29524 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29525 PyObject *obj;
29526 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29527 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29528 return SWIG_Py_Void();
29529 }
29530
29531 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29532 return SWIG_Python_InitShadowInstance(args);
29533 }
29534
29535 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29536 PyObject *resultobj = 0;
29537 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29538 int arg2 = (int) 0 ;
29539 wxClipboardTextEvent *result = 0 ;
29540 int val1 ;
29541 int ecode1 = 0 ;
29542 int val2 ;
29543 int ecode2 = 0 ;
29544 PyObject * obj0 = 0 ;
29545 PyObject * obj1 = 0 ;
29546 char * kwnames[] = {
29547 (char *) "type",(char *) "winid", NULL
29548 };
29549
29550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29551 if (obj0) {
29552 ecode1 = SWIG_AsVal_int(obj0, &val1);
29553 if (!SWIG_IsOK(ecode1)) {
29554 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29555 }
29556 arg1 = static_cast< wxEventType >(val1);
29557 }
29558 if (obj1) {
29559 ecode2 = SWIG_AsVal_int(obj1, &val2);
29560 if (!SWIG_IsOK(ecode2)) {
29561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29562 }
29563 arg2 = static_cast< int >(val2);
29564 }
29565 {
29566 PyThreadState* __tstate = wxPyBeginAllowThreads();
29567 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29568 wxPyEndAllowThreads(__tstate);
29569 if (PyErr_Occurred()) SWIG_fail;
29570 }
29571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29572 return resultobj;
29573 fail:
29574 return NULL;
29575 }
29576
29577
29578 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29579 PyObject *obj;
29580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29581 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29582 return SWIG_Py_Void();
29583 }
29584
29585 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29586 return SWIG_Python_InitShadowInstance(args);
29587 }
29588
29589 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29590 PyObject *resultobj = 0;
29591 int arg1 = (int) 0 ;
29592 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29593 wxPyEvent *result = 0 ;
29594 int val1 ;
29595 int ecode1 = 0 ;
29596 int val2 ;
29597 int ecode2 = 0 ;
29598 PyObject * obj0 = 0 ;
29599 PyObject * obj1 = 0 ;
29600 char * kwnames[] = {
29601 (char *) "winid",(char *) "eventType", NULL
29602 };
29603
29604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29605 if (obj0) {
29606 ecode1 = SWIG_AsVal_int(obj0, &val1);
29607 if (!SWIG_IsOK(ecode1)) {
29608 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29609 }
29610 arg1 = static_cast< int >(val1);
29611 }
29612 if (obj1) {
29613 ecode2 = SWIG_AsVal_int(obj1, &val2);
29614 if (!SWIG_IsOK(ecode2)) {
29615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29616 }
29617 arg2 = static_cast< wxEventType >(val2);
29618 }
29619 {
29620 PyThreadState* __tstate = wxPyBeginAllowThreads();
29621 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29622 wxPyEndAllowThreads(__tstate);
29623 if (PyErr_Occurred()) SWIG_fail;
29624 }
29625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29626 return resultobj;
29627 fail:
29628 return NULL;
29629 }
29630
29631
29632 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29633 PyObject *resultobj = 0;
29634 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29635 void *argp1 = 0 ;
29636 int res1 = 0 ;
29637 PyObject *swig_obj[1] ;
29638
29639 if (!args) SWIG_fail;
29640 swig_obj[0] = args;
29641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29642 if (!SWIG_IsOK(res1)) {
29643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29644 }
29645 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29646 {
29647 PyThreadState* __tstate = wxPyBeginAllowThreads();
29648 delete arg1;
29649
29650 wxPyEndAllowThreads(__tstate);
29651 if (PyErr_Occurred()) SWIG_fail;
29652 }
29653 resultobj = SWIG_Py_Void();
29654 return resultobj;
29655 fail:
29656 return NULL;
29657 }
29658
29659
29660 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29661 PyObject *resultobj = 0;
29662 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29663 PyObject *arg2 = (PyObject *) 0 ;
29664 void *argp1 = 0 ;
29665 int res1 = 0 ;
29666 PyObject * obj0 = 0 ;
29667 PyObject * obj1 = 0 ;
29668 char * kwnames[] = {
29669 (char *) "self",(char *) "self", NULL
29670 };
29671
29672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29674 if (!SWIG_IsOK(res1)) {
29675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29676 }
29677 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29678 arg2 = obj1;
29679 {
29680 PyThreadState* __tstate = wxPyBeginAllowThreads();
29681 (arg1)->SetSelf(arg2);
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 resultobj = SWIG_Py_Void();
29686 return resultobj;
29687 fail:
29688 return NULL;
29689 }
29690
29691
29692 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29693 PyObject *resultobj = 0;
29694 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29695 PyObject *result = 0 ;
29696 void *argp1 = 0 ;
29697 int res1 = 0 ;
29698 PyObject *swig_obj[1] ;
29699
29700 if (!args) SWIG_fail;
29701 swig_obj[0] = args;
29702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29703 if (!SWIG_IsOK(res1)) {
29704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29705 }
29706 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29707 {
29708 PyThreadState* __tstate = wxPyBeginAllowThreads();
29709 result = (PyObject *)(arg1)->GetSelf();
29710 wxPyEndAllowThreads(__tstate);
29711 if (PyErr_Occurred()) SWIG_fail;
29712 }
29713 resultobj = result;
29714 return resultobj;
29715 fail:
29716 return NULL;
29717 }
29718
29719
29720 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29721 PyObject *obj;
29722 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29723 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29724 return SWIG_Py_Void();
29725 }
29726
29727 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29728 return SWIG_Python_InitShadowInstance(args);
29729 }
29730
29731 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29732 PyObject *resultobj = 0;
29733 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29734 int arg2 = (int) 0 ;
29735 wxPyCommandEvent *result = 0 ;
29736 int val1 ;
29737 int ecode1 = 0 ;
29738 int val2 ;
29739 int ecode2 = 0 ;
29740 PyObject * obj0 = 0 ;
29741 PyObject * obj1 = 0 ;
29742 char * kwnames[] = {
29743 (char *) "eventType",(char *) "id", NULL
29744 };
29745
29746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29747 if (obj0) {
29748 ecode1 = SWIG_AsVal_int(obj0, &val1);
29749 if (!SWIG_IsOK(ecode1)) {
29750 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29751 }
29752 arg1 = static_cast< wxEventType >(val1);
29753 }
29754 if (obj1) {
29755 ecode2 = SWIG_AsVal_int(obj1, &val2);
29756 if (!SWIG_IsOK(ecode2)) {
29757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29758 }
29759 arg2 = static_cast< int >(val2);
29760 }
29761 {
29762 PyThreadState* __tstate = wxPyBeginAllowThreads();
29763 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29764 wxPyEndAllowThreads(__tstate);
29765 if (PyErr_Occurred()) SWIG_fail;
29766 }
29767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29768 return resultobj;
29769 fail:
29770 return NULL;
29771 }
29772
29773
29774 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29775 PyObject *resultobj = 0;
29776 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29777 void *argp1 = 0 ;
29778 int res1 = 0 ;
29779 PyObject *swig_obj[1] ;
29780
29781 if (!args) SWIG_fail;
29782 swig_obj[0] = args;
29783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29784 if (!SWIG_IsOK(res1)) {
29785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29786 }
29787 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29788 {
29789 PyThreadState* __tstate = wxPyBeginAllowThreads();
29790 delete arg1;
29791
29792 wxPyEndAllowThreads(__tstate);
29793 if (PyErr_Occurred()) SWIG_fail;
29794 }
29795 resultobj = SWIG_Py_Void();
29796 return resultobj;
29797 fail:
29798 return NULL;
29799 }
29800
29801
29802 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29803 PyObject *resultobj = 0;
29804 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29805 PyObject *arg2 = (PyObject *) 0 ;
29806 void *argp1 = 0 ;
29807 int res1 = 0 ;
29808 PyObject * obj0 = 0 ;
29809 PyObject * obj1 = 0 ;
29810 char * kwnames[] = {
29811 (char *) "self",(char *) "self", NULL
29812 };
29813
29814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29816 if (!SWIG_IsOK(res1)) {
29817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29818 }
29819 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29820 arg2 = obj1;
29821 {
29822 PyThreadState* __tstate = wxPyBeginAllowThreads();
29823 (arg1)->SetSelf(arg2);
29824 wxPyEndAllowThreads(__tstate);
29825 if (PyErr_Occurred()) SWIG_fail;
29826 }
29827 resultobj = SWIG_Py_Void();
29828 return resultobj;
29829 fail:
29830 return NULL;
29831 }
29832
29833
29834 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29835 PyObject *resultobj = 0;
29836 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29837 PyObject *result = 0 ;
29838 void *argp1 = 0 ;
29839 int res1 = 0 ;
29840 PyObject *swig_obj[1] ;
29841
29842 if (!args) SWIG_fail;
29843 swig_obj[0] = args;
29844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29845 if (!SWIG_IsOK(res1)) {
29846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29847 }
29848 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29849 {
29850 PyThreadState* __tstate = wxPyBeginAllowThreads();
29851 result = (PyObject *)(arg1)->GetSelf();
29852 wxPyEndAllowThreads(__tstate);
29853 if (PyErr_Occurred()) SWIG_fail;
29854 }
29855 resultobj = result;
29856 return resultobj;
29857 fail:
29858 return NULL;
29859 }
29860
29861
29862 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29863 PyObject *obj;
29864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29865 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29866 return SWIG_Py_Void();
29867 }
29868
29869 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29870 return SWIG_Python_InitShadowInstance(args);
29871 }
29872
29873 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29874 PyObject *resultobj = 0;
29875 wxWindow *arg1 = (wxWindow *) 0 ;
29876 wxDateTime *arg2 = 0 ;
29877 wxEventType arg3 ;
29878 wxDateEvent *result = 0 ;
29879 void *argp1 = 0 ;
29880 int res1 = 0 ;
29881 void *argp2 = 0 ;
29882 int res2 = 0 ;
29883 int val3 ;
29884 int ecode3 = 0 ;
29885 PyObject * obj0 = 0 ;
29886 PyObject * obj1 = 0 ;
29887 PyObject * obj2 = 0 ;
29888 char * kwnames[] = {
29889 (char *) "win",(char *) "dt",(char *) "type", NULL
29890 };
29891
29892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29894 if (!SWIG_IsOK(res1)) {
29895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29896 }
29897 arg1 = reinterpret_cast< wxWindow * >(argp1);
29898 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29899 if (!SWIG_IsOK(res2)) {
29900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29901 }
29902 if (!argp2) {
29903 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29904 }
29905 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29906 ecode3 = SWIG_AsVal_int(obj2, &val3);
29907 if (!SWIG_IsOK(ecode3)) {
29908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29909 }
29910 arg3 = static_cast< wxEventType >(val3);
29911 {
29912 PyThreadState* __tstate = wxPyBeginAllowThreads();
29913 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29914 wxPyEndAllowThreads(__tstate);
29915 if (PyErr_Occurred()) SWIG_fail;
29916 }
29917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29918 return resultobj;
29919 fail:
29920 return NULL;
29921 }
29922
29923
29924 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29925 PyObject *resultobj = 0;
29926 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29927 wxDateTime *result = 0 ;
29928 void *argp1 = 0 ;
29929 int res1 = 0 ;
29930 PyObject *swig_obj[1] ;
29931
29932 if (!args) SWIG_fail;
29933 swig_obj[0] = args;
29934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29935 if (!SWIG_IsOK(res1)) {
29936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29937 }
29938 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29939 {
29940 PyThreadState* __tstate = wxPyBeginAllowThreads();
29941 {
29942 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29943 result = (wxDateTime *) &_result_ref;
29944 }
29945 wxPyEndAllowThreads(__tstate);
29946 if (PyErr_Occurred()) SWIG_fail;
29947 }
29948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29949 return resultobj;
29950 fail:
29951 return NULL;
29952 }
29953
29954
29955 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29956 PyObject *resultobj = 0;
29957 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29958 wxDateTime *arg2 = 0 ;
29959 void *argp1 = 0 ;
29960 int res1 = 0 ;
29961 void *argp2 = 0 ;
29962 int res2 = 0 ;
29963 PyObject * obj0 = 0 ;
29964 PyObject * obj1 = 0 ;
29965 char * kwnames[] = {
29966 (char *) "self",(char *) "date", NULL
29967 };
29968
29969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29971 if (!SWIG_IsOK(res1)) {
29972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29973 }
29974 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29975 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29976 if (!SWIG_IsOK(res2)) {
29977 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29978 }
29979 if (!argp2) {
29980 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29981 }
29982 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29983 {
29984 PyThreadState* __tstate = wxPyBeginAllowThreads();
29985 (arg1)->SetDate((wxDateTime const &)*arg2);
29986 wxPyEndAllowThreads(__tstate);
29987 if (PyErr_Occurred()) SWIG_fail;
29988 }
29989 resultobj = SWIG_Py_Void();
29990 return resultobj;
29991 fail:
29992 return NULL;
29993 }
29994
29995
29996 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29997 PyObject *obj;
29998 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29999 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
30000 return SWIG_Py_Void();
30001 }
30002
30003 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30004 return SWIG_Python_InitShadowInstance(args);
30005 }
30006
30007 SWIGINTERN PyObject *_wrap_new_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30008 PyObject *resultobj = 0;
30009 wxWindow *arg1 = (wxWindow *) 0 ;
30010 wxEventType arg2 = (wxEventType) wxEVT_ANY ;
30011 wxEventBlocker *result = 0 ;
30012 void *argp1 = 0 ;
30013 int res1 = 0 ;
30014 int val2 ;
30015 int ecode2 = 0 ;
30016 PyObject * obj0 = 0 ;
30017 PyObject * obj1 = 0 ;
30018 char * kwnames[] = {
30019 (char *) "win",(char *) "type", NULL
30020 };
30021
30022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_EventBlocker",kwnames,&obj0,&obj1)) SWIG_fail;
30023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30024 if (!SWIG_IsOK(res1)) {
30025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventBlocker" "', expected argument " "1"" of type '" "wxWindow *""'");
30026 }
30027 arg1 = reinterpret_cast< wxWindow * >(argp1);
30028 if (obj1) {
30029 ecode2 = SWIG_AsVal_int(obj1, &val2);
30030 if (!SWIG_IsOK(ecode2)) {
30031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EventBlocker" "', expected argument " "2"" of type '" "wxEventType""'");
30032 }
30033 arg2 = static_cast< wxEventType >(val2);
30034 }
30035 {
30036 PyThreadState* __tstate = wxPyBeginAllowThreads();
30037 result = (wxEventBlocker *)new wxEventBlocker(arg1,arg2);
30038 wxPyEndAllowThreads(__tstate);
30039 if (PyErr_Occurred()) SWIG_fail;
30040 }
30041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_NEW | 0 );
30042 return resultobj;
30043 fail:
30044 return NULL;
30045 }
30046
30047
30048 SWIGINTERN PyObject *_wrap_delete_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30049 PyObject *resultobj = 0;
30050 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30051 void *argp1 = 0 ;
30052 int res1 = 0 ;
30053 PyObject *swig_obj[1] ;
30054
30055 if (!args) SWIG_fail;
30056 swig_obj[0] = args;
30057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_DISOWN | 0 );
30058 if (!SWIG_IsOK(res1)) {
30059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventBlocker" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30060 }
30061 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30062 {
30063 PyThreadState* __tstate = wxPyBeginAllowThreads();
30064 delete arg1;
30065
30066 wxPyEndAllowThreads(__tstate);
30067 if (PyErr_Occurred()) SWIG_fail;
30068 }
30069 resultobj = SWIG_Py_Void();
30070 return resultobj;
30071 fail:
30072 return NULL;
30073 }
30074
30075
30076 SWIGINTERN PyObject *_wrap_EventBlocker_Block(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30077 PyObject *resultobj = 0;
30078 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30079 wxEventType arg2 ;
30080 void *argp1 = 0 ;
30081 int res1 = 0 ;
30082 int val2 ;
30083 int ecode2 = 0 ;
30084 PyObject * obj0 = 0 ;
30085 PyObject * obj1 = 0 ;
30086 char * kwnames[] = {
30087 (char *) "self",(char *) "type", NULL
30088 };
30089
30090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EventBlocker_Block",kwnames,&obj0,&obj1)) SWIG_fail;
30091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventBlocker, 0 | 0 );
30092 if (!SWIG_IsOK(res1)) {
30093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventBlocker_Block" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30094 }
30095 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30096 ecode2 = SWIG_AsVal_int(obj1, &val2);
30097 if (!SWIG_IsOK(ecode2)) {
30098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventBlocker_Block" "', expected argument " "2"" of type '" "wxEventType""'");
30099 }
30100 arg2 = static_cast< wxEventType >(val2);
30101 {
30102 PyThreadState* __tstate = wxPyBeginAllowThreads();
30103 (arg1)->Block(arg2);
30104 wxPyEndAllowThreads(__tstate);
30105 if (PyErr_Occurred()) SWIG_fail;
30106 }
30107 resultobj = SWIG_Py_Void();
30108 return resultobj;
30109 fail:
30110 return NULL;
30111 }
30112
30113
30114 SWIGINTERN PyObject *EventBlocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30115 PyObject *obj;
30116 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30117 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventBlocker, SWIG_NewClientData(obj));
30118 return SWIG_Py_Void();
30119 }
30120
30121 SWIGINTERN PyObject *EventBlocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30122 return SWIG_Python_InitShadowInstance(args);
30123 }
30124
30125 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30126 PyObject *resultobj = 0;
30127 wxPyApp *result = 0 ;
30128
30129 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
30130 {
30131 PyThreadState* __tstate = wxPyBeginAllowThreads();
30132 result = (wxPyApp *)new_wxPyApp();
30133 wxPyEndAllowThreads(__tstate);
30134 if (PyErr_Occurred()) SWIG_fail;
30135 }
30136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
30137 return resultobj;
30138 fail:
30139 return NULL;
30140 }
30141
30142
30143 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30144 PyObject *resultobj = 0;
30145 wxPyApp *arg1 = (wxPyApp *) 0 ;
30146 void *argp1 = 0 ;
30147 int res1 = 0 ;
30148 PyObject *swig_obj[1] ;
30149
30150 if (!args) SWIG_fail;
30151 swig_obj[0] = args;
30152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30153 if (!SWIG_IsOK(res1)) {
30154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30155 }
30156 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30157 {
30158 PyThreadState* __tstate = wxPyBeginAllowThreads();
30159 delete arg1;
30160
30161 wxPyEndAllowThreads(__tstate);
30162 if (PyErr_Occurred()) SWIG_fail;
30163 }
30164 resultobj = SWIG_Py_Void();
30165 return resultobj;
30166 fail:
30167 return NULL;
30168 }
30169
30170
30171 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30172 PyObject *resultobj = 0;
30173 wxPyApp *arg1 = (wxPyApp *) 0 ;
30174 PyObject *arg2 = (PyObject *) 0 ;
30175 PyObject *arg3 = (PyObject *) 0 ;
30176 bool arg4 = (bool) false ;
30177 void *argp1 = 0 ;
30178 int res1 = 0 ;
30179 bool val4 ;
30180 int ecode4 = 0 ;
30181 PyObject * obj0 = 0 ;
30182 PyObject * obj1 = 0 ;
30183 PyObject * obj2 = 0 ;
30184 PyObject * obj3 = 0 ;
30185 char * kwnames[] = {
30186 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30187 };
30188
30189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30191 if (!SWIG_IsOK(res1)) {
30192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30193 }
30194 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30195 arg2 = obj1;
30196 arg3 = obj2;
30197 if (obj3) {
30198 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30199 if (!SWIG_IsOK(ecode4)) {
30200 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30201 }
30202 arg4 = static_cast< bool >(val4);
30203 }
30204 {
30205 PyThreadState* __tstate = wxPyBeginAllowThreads();
30206 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30207 wxPyEndAllowThreads(__tstate);
30208 if (PyErr_Occurred()) SWIG_fail;
30209 }
30210 resultobj = SWIG_Py_Void();
30211 return resultobj;
30212 fail:
30213 return NULL;
30214 }
30215
30216
30217 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30218 PyObject *resultobj = 0;
30219 wxPyApp *arg1 = (wxPyApp *) 0 ;
30220 wxString result;
30221 void *argp1 = 0 ;
30222 int res1 = 0 ;
30223 PyObject *swig_obj[1] ;
30224
30225 if (!args) SWIG_fail;
30226 swig_obj[0] = args;
30227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30228 if (!SWIG_IsOK(res1)) {
30229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30230 }
30231 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30232 {
30233 PyThreadState* __tstate = wxPyBeginAllowThreads();
30234 result = ((wxPyApp const *)arg1)->GetAppName();
30235 wxPyEndAllowThreads(__tstate);
30236 if (PyErr_Occurred()) SWIG_fail;
30237 }
30238 {
30239 #if wxUSE_UNICODE
30240 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30241 #else
30242 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30243 #endif
30244 }
30245 return resultobj;
30246 fail:
30247 return NULL;
30248 }
30249
30250
30251 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30252 PyObject *resultobj = 0;
30253 wxPyApp *arg1 = (wxPyApp *) 0 ;
30254 wxString *arg2 = 0 ;
30255 void *argp1 = 0 ;
30256 int res1 = 0 ;
30257 bool temp2 = false ;
30258 PyObject * obj0 = 0 ;
30259 PyObject * obj1 = 0 ;
30260 char * kwnames[] = {
30261 (char *) "self",(char *) "name", NULL
30262 };
30263
30264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30266 if (!SWIG_IsOK(res1)) {
30267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30268 }
30269 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30270 {
30271 arg2 = wxString_in_helper(obj1);
30272 if (arg2 == NULL) SWIG_fail;
30273 temp2 = true;
30274 }
30275 {
30276 PyThreadState* __tstate = wxPyBeginAllowThreads();
30277 (arg1)->SetAppName((wxString const &)*arg2);
30278 wxPyEndAllowThreads(__tstate);
30279 if (PyErr_Occurred()) SWIG_fail;
30280 }
30281 resultobj = SWIG_Py_Void();
30282 {
30283 if (temp2)
30284 delete arg2;
30285 }
30286 return resultobj;
30287 fail:
30288 {
30289 if (temp2)
30290 delete arg2;
30291 }
30292 return NULL;
30293 }
30294
30295
30296 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30297 PyObject *resultobj = 0;
30298 wxPyApp *arg1 = (wxPyApp *) 0 ;
30299 wxString result;
30300 void *argp1 = 0 ;
30301 int res1 = 0 ;
30302 PyObject *swig_obj[1] ;
30303
30304 if (!args) SWIG_fail;
30305 swig_obj[0] = args;
30306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30307 if (!SWIG_IsOK(res1)) {
30308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30309 }
30310 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30311 {
30312 PyThreadState* __tstate = wxPyBeginAllowThreads();
30313 result = ((wxPyApp const *)arg1)->GetClassName();
30314 wxPyEndAllowThreads(__tstate);
30315 if (PyErr_Occurred()) SWIG_fail;
30316 }
30317 {
30318 #if wxUSE_UNICODE
30319 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30320 #else
30321 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30322 #endif
30323 }
30324 return resultobj;
30325 fail:
30326 return NULL;
30327 }
30328
30329
30330 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30331 PyObject *resultobj = 0;
30332 wxPyApp *arg1 = (wxPyApp *) 0 ;
30333 wxString *arg2 = 0 ;
30334 void *argp1 = 0 ;
30335 int res1 = 0 ;
30336 bool temp2 = false ;
30337 PyObject * obj0 = 0 ;
30338 PyObject * obj1 = 0 ;
30339 char * kwnames[] = {
30340 (char *) "self",(char *) "name", NULL
30341 };
30342
30343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30345 if (!SWIG_IsOK(res1)) {
30346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30347 }
30348 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30349 {
30350 arg2 = wxString_in_helper(obj1);
30351 if (arg2 == NULL) SWIG_fail;
30352 temp2 = true;
30353 }
30354 {
30355 PyThreadState* __tstate = wxPyBeginAllowThreads();
30356 (arg1)->SetClassName((wxString const &)*arg2);
30357 wxPyEndAllowThreads(__tstate);
30358 if (PyErr_Occurred()) SWIG_fail;
30359 }
30360 resultobj = SWIG_Py_Void();
30361 {
30362 if (temp2)
30363 delete arg2;
30364 }
30365 return resultobj;
30366 fail:
30367 {
30368 if (temp2)
30369 delete arg2;
30370 }
30371 return NULL;
30372 }
30373
30374
30375 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30376 PyObject *resultobj = 0;
30377 wxPyApp *arg1 = (wxPyApp *) 0 ;
30378 wxString *result = 0 ;
30379 void *argp1 = 0 ;
30380 int res1 = 0 ;
30381 PyObject *swig_obj[1] ;
30382
30383 if (!args) SWIG_fail;
30384 swig_obj[0] = args;
30385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30386 if (!SWIG_IsOK(res1)) {
30387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30388 }
30389 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30390 {
30391 PyThreadState* __tstate = wxPyBeginAllowThreads();
30392 {
30393 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30394 result = (wxString *) &_result_ref;
30395 }
30396 wxPyEndAllowThreads(__tstate);
30397 if (PyErr_Occurred()) SWIG_fail;
30398 }
30399 {
30400 #if wxUSE_UNICODE
30401 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30402 #else
30403 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30404 #endif
30405 }
30406 return resultobj;
30407 fail:
30408 return NULL;
30409 }
30410
30411
30412 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30413 PyObject *resultobj = 0;
30414 wxPyApp *arg1 = (wxPyApp *) 0 ;
30415 wxString *arg2 = 0 ;
30416 void *argp1 = 0 ;
30417 int res1 = 0 ;
30418 bool temp2 = false ;
30419 PyObject * obj0 = 0 ;
30420 PyObject * obj1 = 0 ;
30421 char * kwnames[] = {
30422 (char *) "self",(char *) "name", NULL
30423 };
30424
30425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30427 if (!SWIG_IsOK(res1)) {
30428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30429 }
30430 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30431 {
30432 arg2 = wxString_in_helper(obj1);
30433 if (arg2 == NULL) SWIG_fail;
30434 temp2 = true;
30435 }
30436 {
30437 PyThreadState* __tstate = wxPyBeginAllowThreads();
30438 (arg1)->SetVendorName((wxString const &)*arg2);
30439 wxPyEndAllowThreads(__tstate);
30440 if (PyErr_Occurred()) SWIG_fail;
30441 }
30442 resultobj = SWIG_Py_Void();
30443 {
30444 if (temp2)
30445 delete arg2;
30446 }
30447 return resultobj;
30448 fail:
30449 {
30450 if (temp2)
30451 delete arg2;
30452 }
30453 return NULL;
30454 }
30455
30456
30457 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30458 PyObject *resultobj = 0;
30459 wxPyApp *arg1 = (wxPyApp *) 0 ;
30460 wxAppTraits *result = 0 ;
30461 void *argp1 = 0 ;
30462 int res1 = 0 ;
30463 PyObject *swig_obj[1] ;
30464
30465 if (!args) SWIG_fail;
30466 swig_obj[0] = args;
30467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30468 if (!SWIG_IsOK(res1)) {
30469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30470 }
30471 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30472 {
30473 PyThreadState* __tstate = wxPyBeginAllowThreads();
30474 result = (wxAppTraits *)(arg1)->GetTraits();
30475 wxPyEndAllowThreads(__tstate);
30476 if (PyErr_Occurred()) SWIG_fail;
30477 }
30478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30479 return resultobj;
30480 fail:
30481 return NULL;
30482 }
30483
30484
30485 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30486 PyObject *resultobj = 0;
30487 wxPyApp *arg1 = (wxPyApp *) 0 ;
30488 void *argp1 = 0 ;
30489 int res1 = 0 ;
30490 PyObject *swig_obj[1] ;
30491
30492 if (!args) SWIG_fail;
30493 swig_obj[0] = args;
30494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30495 if (!SWIG_IsOK(res1)) {
30496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30497 }
30498 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30499 {
30500 PyThreadState* __tstate = wxPyBeginAllowThreads();
30501 (arg1)->ProcessPendingEvents();
30502 wxPyEndAllowThreads(__tstate);
30503 if (PyErr_Occurred()) SWIG_fail;
30504 }
30505 resultobj = SWIG_Py_Void();
30506 return resultobj;
30507 fail:
30508 return NULL;
30509 }
30510
30511
30512 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30513 PyObject *resultobj = 0;
30514 wxPyApp *arg1 = (wxPyApp *) 0 ;
30515 bool arg2 = (bool) false ;
30516 bool result;
30517 void *argp1 = 0 ;
30518 int res1 = 0 ;
30519 bool val2 ;
30520 int ecode2 = 0 ;
30521 PyObject * obj0 = 0 ;
30522 PyObject * obj1 = 0 ;
30523 char * kwnames[] = {
30524 (char *) "self",(char *) "onlyIfNeeded", NULL
30525 };
30526
30527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30529 if (!SWIG_IsOK(res1)) {
30530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30531 }
30532 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30533 if (obj1) {
30534 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30535 if (!SWIG_IsOK(ecode2)) {
30536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30537 }
30538 arg2 = static_cast< bool >(val2);
30539 }
30540 {
30541 PyThreadState* __tstate = wxPyBeginAllowThreads();
30542 result = (bool)(arg1)->Yield(arg2);
30543 wxPyEndAllowThreads(__tstate);
30544 if (PyErr_Occurred()) SWIG_fail;
30545 }
30546 {
30547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30548 }
30549 return resultobj;
30550 fail:
30551 return NULL;
30552 }
30553
30554
30555 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30556 PyObject *resultobj = 0;
30557 wxPyApp *arg1 = (wxPyApp *) 0 ;
30558 void *argp1 = 0 ;
30559 int res1 = 0 ;
30560 PyObject *swig_obj[1] ;
30561
30562 if (!args) SWIG_fail;
30563 swig_obj[0] = args;
30564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30565 if (!SWIG_IsOK(res1)) {
30566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30567 }
30568 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30569 {
30570 PyThreadState* __tstate = wxPyBeginAllowThreads();
30571 (arg1)->WakeUpIdle();
30572 wxPyEndAllowThreads(__tstate);
30573 if (PyErr_Occurred()) SWIG_fail;
30574 }
30575 resultobj = SWIG_Py_Void();
30576 return resultobj;
30577 fail:
30578 return NULL;
30579 }
30580
30581
30582 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30583 PyObject *resultobj = 0;
30584 bool result;
30585
30586 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30587 {
30588 PyThreadState* __tstate = wxPyBeginAllowThreads();
30589 result = (bool)wxPyApp::IsMainLoopRunning();
30590 wxPyEndAllowThreads(__tstate);
30591 if (PyErr_Occurred()) SWIG_fail;
30592 }
30593 {
30594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30595 }
30596 return resultobj;
30597 fail:
30598 return NULL;
30599 }
30600
30601
30602 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30603 PyObject *resultobj = 0;
30604 wxPyApp *arg1 = (wxPyApp *) 0 ;
30605 int result;
30606 void *argp1 = 0 ;
30607 int res1 = 0 ;
30608 PyObject *swig_obj[1] ;
30609
30610 if (!args) SWIG_fail;
30611 swig_obj[0] = args;
30612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30613 if (!SWIG_IsOK(res1)) {
30614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30615 }
30616 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30617 {
30618 PyThreadState* __tstate = wxPyBeginAllowThreads();
30619 result = (int)(arg1)->MainLoop();
30620 wxPyEndAllowThreads(__tstate);
30621 if (PyErr_Occurred()) SWIG_fail;
30622 }
30623 resultobj = SWIG_From_int(static_cast< int >(result));
30624 return resultobj;
30625 fail:
30626 return NULL;
30627 }
30628
30629
30630 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30631 PyObject *resultobj = 0;
30632 wxPyApp *arg1 = (wxPyApp *) 0 ;
30633 void *argp1 = 0 ;
30634 int res1 = 0 ;
30635 PyObject *swig_obj[1] ;
30636
30637 if (!args) SWIG_fail;
30638 swig_obj[0] = args;
30639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30640 if (!SWIG_IsOK(res1)) {
30641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30642 }
30643 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30644 {
30645 PyThreadState* __tstate = wxPyBeginAllowThreads();
30646 (arg1)->Exit();
30647 wxPyEndAllowThreads(__tstate);
30648 if (PyErr_Occurred()) SWIG_fail;
30649 }
30650 resultobj = SWIG_Py_Void();
30651 return resultobj;
30652 fail:
30653 return NULL;
30654 }
30655
30656
30657 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30658 PyObject *resultobj = 0;
30659 wxPyApp *arg1 = (wxPyApp *) 0 ;
30660 wxLayoutDirection result;
30661 void *argp1 = 0 ;
30662 int res1 = 0 ;
30663 PyObject *swig_obj[1] ;
30664
30665 if (!args) SWIG_fail;
30666 swig_obj[0] = args;
30667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30668 if (!SWIG_IsOK(res1)) {
30669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30670 }
30671 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30672 {
30673 PyThreadState* __tstate = wxPyBeginAllowThreads();
30674 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30675 wxPyEndAllowThreads(__tstate);
30676 if (PyErr_Occurred()) SWIG_fail;
30677 }
30678 resultobj = SWIG_From_int(static_cast< int >(result));
30679 return resultobj;
30680 fail:
30681 return NULL;
30682 }
30683
30684
30685 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30686 PyObject *resultobj = 0;
30687 wxPyApp *arg1 = (wxPyApp *) 0 ;
30688 void *argp1 = 0 ;
30689 int res1 = 0 ;
30690 PyObject *swig_obj[1] ;
30691
30692 if (!args) SWIG_fail;
30693 swig_obj[0] = args;
30694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30695 if (!SWIG_IsOK(res1)) {
30696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30697 }
30698 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30699 {
30700 PyThreadState* __tstate = wxPyBeginAllowThreads();
30701 (arg1)->ExitMainLoop();
30702 wxPyEndAllowThreads(__tstate);
30703 if (PyErr_Occurred()) SWIG_fail;
30704 }
30705 resultobj = SWIG_Py_Void();
30706 return resultobj;
30707 fail:
30708 return NULL;
30709 }
30710
30711
30712 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30713 PyObject *resultobj = 0;
30714 wxPyApp *arg1 = (wxPyApp *) 0 ;
30715 bool result;
30716 void *argp1 = 0 ;
30717 int res1 = 0 ;
30718 PyObject *swig_obj[1] ;
30719
30720 if (!args) SWIG_fail;
30721 swig_obj[0] = args;
30722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30723 if (!SWIG_IsOK(res1)) {
30724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30725 }
30726 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30727 {
30728 PyThreadState* __tstate = wxPyBeginAllowThreads();
30729 result = (bool)(arg1)->Pending();
30730 wxPyEndAllowThreads(__tstate);
30731 if (PyErr_Occurred()) SWIG_fail;
30732 }
30733 {
30734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30735 }
30736 return resultobj;
30737 fail:
30738 return NULL;
30739 }
30740
30741
30742 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30743 PyObject *resultobj = 0;
30744 wxPyApp *arg1 = (wxPyApp *) 0 ;
30745 bool result;
30746 void *argp1 = 0 ;
30747 int res1 = 0 ;
30748 PyObject *swig_obj[1] ;
30749
30750 if (!args) SWIG_fail;
30751 swig_obj[0] = args;
30752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30753 if (!SWIG_IsOK(res1)) {
30754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30755 }
30756 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30757 {
30758 PyThreadState* __tstate = wxPyBeginAllowThreads();
30759 result = (bool)(arg1)->Dispatch();
30760 wxPyEndAllowThreads(__tstate);
30761 if (PyErr_Occurred()) SWIG_fail;
30762 }
30763 {
30764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30765 }
30766 return resultobj;
30767 fail:
30768 return NULL;
30769 }
30770
30771
30772 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30773 PyObject *resultobj = 0;
30774 wxPyApp *arg1 = (wxPyApp *) 0 ;
30775 bool result;
30776 void *argp1 = 0 ;
30777 int res1 = 0 ;
30778 PyObject *swig_obj[1] ;
30779
30780 if (!args) SWIG_fail;
30781 swig_obj[0] = args;
30782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30783 if (!SWIG_IsOK(res1)) {
30784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30785 }
30786 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30787 {
30788 PyThreadState* __tstate = wxPyBeginAllowThreads();
30789 result = (bool)(arg1)->ProcessIdle();
30790 wxPyEndAllowThreads(__tstate);
30791 if (PyErr_Occurred()) SWIG_fail;
30792 }
30793 {
30794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30795 }
30796 return resultobj;
30797 fail:
30798 return NULL;
30799 }
30800
30801
30802 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30803 PyObject *resultobj = 0;
30804 wxPyApp *arg1 = (wxPyApp *) 0 ;
30805 wxWindow *arg2 = (wxWindow *) 0 ;
30806 wxIdleEvent *arg3 = 0 ;
30807 bool result;
30808 void *argp1 = 0 ;
30809 int res1 = 0 ;
30810 void *argp2 = 0 ;
30811 int res2 = 0 ;
30812 void *argp3 = 0 ;
30813 int res3 = 0 ;
30814 PyObject * obj0 = 0 ;
30815 PyObject * obj1 = 0 ;
30816 PyObject * obj2 = 0 ;
30817 char * kwnames[] = {
30818 (char *) "self",(char *) "win",(char *) "event", NULL
30819 };
30820
30821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30823 if (!SWIG_IsOK(res1)) {
30824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30825 }
30826 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30827 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30828 if (!SWIG_IsOK(res2)) {
30829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30830 }
30831 arg2 = reinterpret_cast< wxWindow * >(argp2);
30832 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30833 if (!SWIG_IsOK(res3)) {
30834 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30835 }
30836 if (!argp3) {
30837 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30838 }
30839 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30840 {
30841 PyThreadState* __tstate = wxPyBeginAllowThreads();
30842 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30843 wxPyEndAllowThreads(__tstate);
30844 if (PyErr_Occurred()) SWIG_fail;
30845 }
30846 {
30847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30848 }
30849 return resultobj;
30850 fail:
30851 return NULL;
30852 }
30853
30854
30855 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30856 PyObject *resultobj = 0;
30857 wxPyApp *arg1 = (wxPyApp *) 0 ;
30858 bool result;
30859 void *argp1 = 0 ;
30860 int res1 = 0 ;
30861 PyObject *swig_obj[1] ;
30862
30863 if (!args) SWIG_fail;
30864 swig_obj[0] = args;
30865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30866 if (!SWIG_IsOK(res1)) {
30867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30868 }
30869 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30870 {
30871 PyThreadState* __tstate = wxPyBeginAllowThreads();
30872 result = (bool)((wxPyApp const *)arg1)->IsActive();
30873 wxPyEndAllowThreads(__tstate);
30874 if (PyErr_Occurred()) SWIG_fail;
30875 }
30876 {
30877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30878 }
30879 return resultobj;
30880 fail:
30881 return NULL;
30882 }
30883
30884
30885 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30886 PyObject *resultobj = 0;
30887 wxPyApp *arg1 = (wxPyApp *) 0 ;
30888 wxWindow *arg2 = (wxWindow *) 0 ;
30889 void *argp1 = 0 ;
30890 int res1 = 0 ;
30891 void *argp2 = 0 ;
30892 int res2 = 0 ;
30893 PyObject * obj0 = 0 ;
30894 PyObject * obj1 = 0 ;
30895 char * kwnames[] = {
30896 (char *) "self",(char *) "win", NULL
30897 };
30898
30899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30901 if (!SWIG_IsOK(res1)) {
30902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30903 }
30904 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30905 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30906 if (!SWIG_IsOK(res2)) {
30907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30908 }
30909 arg2 = reinterpret_cast< wxWindow * >(argp2);
30910 {
30911 PyThreadState* __tstate = wxPyBeginAllowThreads();
30912 (arg1)->SetTopWindow(arg2);
30913 wxPyEndAllowThreads(__tstate);
30914 if (PyErr_Occurred()) SWIG_fail;
30915 }
30916 resultobj = SWIG_Py_Void();
30917 return resultobj;
30918 fail:
30919 return NULL;
30920 }
30921
30922
30923 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30924 PyObject *resultobj = 0;
30925 wxPyApp *arg1 = (wxPyApp *) 0 ;
30926 wxWindow *result = 0 ;
30927 void *argp1 = 0 ;
30928 int res1 = 0 ;
30929 PyObject *swig_obj[1] ;
30930
30931 if (!args) SWIG_fail;
30932 swig_obj[0] = args;
30933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30934 if (!SWIG_IsOK(res1)) {
30935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30936 }
30937 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30938 {
30939 PyThreadState* __tstate = wxPyBeginAllowThreads();
30940 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30941 wxPyEndAllowThreads(__tstate);
30942 if (PyErr_Occurred()) SWIG_fail;
30943 }
30944 {
30945 resultobj = wxPyMake_wxObject(result, (bool)0);
30946 }
30947 return resultobj;
30948 fail:
30949 return NULL;
30950 }
30951
30952
30953 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30954 PyObject *resultobj = 0;
30955 wxPyApp *arg1 = (wxPyApp *) 0 ;
30956 bool arg2 ;
30957 void *argp1 = 0 ;
30958 int res1 = 0 ;
30959 bool val2 ;
30960 int ecode2 = 0 ;
30961 PyObject * obj0 = 0 ;
30962 PyObject * obj1 = 0 ;
30963 char * kwnames[] = {
30964 (char *) "self",(char *) "flag", NULL
30965 };
30966
30967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30969 if (!SWIG_IsOK(res1)) {
30970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30971 }
30972 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30973 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30974 if (!SWIG_IsOK(ecode2)) {
30975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30976 }
30977 arg2 = static_cast< bool >(val2);
30978 {
30979 PyThreadState* __tstate = wxPyBeginAllowThreads();
30980 (arg1)->SetExitOnFrameDelete(arg2);
30981 wxPyEndAllowThreads(__tstate);
30982 if (PyErr_Occurred()) SWIG_fail;
30983 }
30984 resultobj = SWIG_Py_Void();
30985 return resultobj;
30986 fail:
30987 return NULL;
30988 }
30989
30990
30991 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30992 PyObject *resultobj = 0;
30993 wxPyApp *arg1 = (wxPyApp *) 0 ;
30994 bool result;
30995 void *argp1 = 0 ;
30996 int res1 = 0 ;
30997 PyObject *swig_obj[1] ;
30998
30999 if (!args) SWIG_fail;
31000 swig_obj[0] = args;
31001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31002 if (!SWIG_IsOK(res1)) {
31003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31004 }
31005 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31006 {
31007 PyThreadState* __tstate = wxPyBeginAllowThreads();
31008 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
31009 wxPyEndAllowThreads(__tstate);
31010 if (PyErr_Occurred()) SWIG_fail;
31011 }
31012 {
31013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31014 }
31015 return resultobj;
31016 fail:
31017 return NULL;
31018 }
31019
31020
31021 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31022 PyObject *resultobj = 0;
31023 wxPyApp *arg1 = (wxPyApp *) 0 ;
31024 bool arg2 ;
31025 bool arg3 = (bool) false ;
31026 void *argp1 = 0 ;
31027 int res1 = 0 ;
31028 bool val2 ;
31029 int ecode2 = 0 ;
31030 bool val3 ;
31031 int ecode3 = 0 ;
31032 PyObject * obj0 = 0 ;
31033 PyObject * obj1 = 0 ;
31034 PyObject * obj2 = 0 ;
31035 char * kwnames[] = {
31036 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
31037 };
31038
31039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31041 if (!SWIG_IsOK(res1)) {
31042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
31043 }
31044 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31045 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31046 if (!SWIG_IsOK(ecode2)) {
31047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
31048 }
31049 arg2 = static_cast< bool >(val2);
31050 if (obj2) {
31051 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31052 if (!SWIG_IsOK(ecode3)) {
31053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
31054 }
31055 arg3 = static_cast< bool >(val3);
31056 }
31057 {
31058 PyThreadState* __tstate = wxPyBeginAllowThreads();
31059 (arg1)->SetUseBestVisual(arg2,arg3);
31060 wxPyEndAllowThreads(__tstate);
31061 if (PyErr_Occurred()) SWIG_fail;
31062 }
31063 resultobj = SWIG_Py_Void();
31064 return resultobj;
31065 fail:
31066 return NULL;
31067 }
31068
31069
31070 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31071 PyObject *resultobj = 0;
31072 wxPyApp *arg1 = (wxPyApp *) 0 ;
31073 bool result;
31074 void *argp1 = 0 ;
31075 int res1 = 0 ;
31076 PyObject *swig_obj[1] ;
31077
31078 if (!args) SWIG_fail;
31079 swig_obj[0] = args;
31080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31081 if (!SWIG_IsOK(res1)) {
31082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31083 }
31084 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31085 {
31086 PyThreadState* __tstate = wxPyBeginAllowThreads();
31087 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
31088 wxPyEndAllowThreads(__tstate);
31089 if (PyErr_Occurred()) SWIG_fail;
31090 }
31091 {
31092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31093 }
31094 return resultobj;
31095 fail:
31096 return NULL;
31097 }
31098
31099
31100 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31101 PyObject *resultobj = 0;
31102 wxPyApp *arg1 = (wxPyApp *) 0 ;
31103 int arg2 ;
31104 void *argp1 = 0 ;
31105 int res1 = 0 ;
31106 int val2 ;
31107 int ecode2 = 0 ;
31108 PyObject * obj0 = 0 ;
31109 PyObject * obj1 = 0 ;
31110 char * kwnames[] = {
31111 (char *) "self",(char *) "mode", NULL
31112 };
31113
31114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
31115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31116 if (!SWIG_IsOK(res1)) {
31117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31118 }
31119 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31120 ecode2 = SWIG_AsVal_int(obj1, &val2);
31121 if (!SWIG_IsOK(ecode2)) {
31122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
31123 }
31124 arg2 = static_cast< int >(val2);
31125 {
31126 PyThreadState* __tstate = wxPyBeginAllowThreads();
31127 (arg1)->SetPrintMode(arg2);
31128 wxPyEndAllowThreads(__tstate);
31129 if (PyErr_Occurred()) SWIG_fail;
31130 }
31131 resultobj = SWIG_Py_Void();
31132 return resultobj;
31133 fail:
31134 return NULL;
31135 }
31136
31137
31138 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31139 PyObject *resultobj = 0;
31140 wxPyApp *arg1 = (wxPyApp *) 0 ;
31141 int result;
31142 void *argp1 = 0 ;
31143 int res1 = 0 ;
31144 PyObject *swig_obj[1] ;
31145
31146 if (!args) SWIG_fail;
31147 swig_obj[0] = args;
31148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31149 if (!SWIG_IsOK(res1)) {
31150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31151 }
31152 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31153 {
31154 PyThreadState* __tstate = wxPyBeginAllowThreads();
31155 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
31156 wxPyEndAllowThreads(__tstate);
31157 if (PyErr_Occurred()) SWIG_fail;
31158 }
31159 resultobj = SWIG_From_int(static_cast< int >(result));
31160 return resultobj;
31161 fail:
31162 return NULL;
31163 }
31164
31165
31166 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31167 PyObject *resultobj = 0;
31168 wxPyApp *arg1 = (wxPyApp *) 0 ;
31169 int arg2 ;
31170 void *argp1 = 0 ;
31171 int res1 = 0 ;
31172 int val2 ;
31173 int ecode2 = 0 ;
31174 PyObject * obj0 = 0 ;
31175 PyObject * obj1 = 0 ;
31176 char * kwnames[] = {
31177 (char *) "self",(char *) "mode", NULL
31178 };
31179
31180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31182 if (!SWIG_IsOK(res1)) {
31183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31184 }
31185 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31186 ecode2 = SWIG_AsVal_int(obj1, &val2);
31187 if (!SWIG_IsOK(ecode2)) {
31188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31189 }
31190 arg2 = static_cast< int >(val2);
31191 {
31192 PyThreadState* __tstate = wxPyBeginAllowThreads();
31193 (arg1)->SetAssertMode(arg2);
31194 wxPyEndAllowThreads(__tstate);
31195 if (PyErr_Occurred()) SWIG_fail;
31196 }
31197 resultobj = SWIG_Py_Void();
31198 return resultobj;
31199 fail:
31200 return NULL;
31201 }
31202
31203
31204 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31205 PyObject *resultobj = 0;
31206 wxPyApp *arg1 = (wxPyApp *) 0 ;
31207 int result;
31208 void *argp1 = 0 ;
31209 int res1 = 0 ;
31210 PyObject *swig_obj[1] ;
31211
31212 if (!args) SWIG_fail;
31213 swig_obj[0] = args;
31214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31215 if (!SWIG_IsOK(res1)) {
31216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31217 }
31218 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31219 {
31220 PyThreadState* __tstate = wxPyBeginAllowThreads();
31221 result = (int)(arg1)->GetAssertMode();
31222 wxPyEndAllowThreads(__tstate);
31223 if (PyErr_Occurred()) SWIG_fail;
31224 }
31225 resultobj = SWIG_From_int(static_cast< int >(result));
31226 return resultobj;
31227 fail:
31228 return NULL;
31229 }
31230
31231
31232 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31233 PyObject *resultobj = 0;
31234 bool result;
31235
31236 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31237 {
31238 PyThreadState* __tstate = wxPyBeginAllowThreads();
31239 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31240 wxPyEndAllowThreads(__tstate);
31241 if (PyErr_Occurred()) SWIG_fail;
31242 }
31243 {
31244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31245 }
31246 return resultobj;
31247 fail:
31248 return NULL;
31249 }
31250
31251
31252 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31253 PyObject *resultobj = 0;
31254 long result;
31255
31256 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31257 {
31258 PyThreadState* __tstate = wxPyBeginAllowThreads();
31259 result = (long)wxPyApp::GetMacAboutMenuItemId();
31260 wxPyEndAllowThreads(__tstate);
31261 if (PyErr_Occurred()) SWIG_fail;
31262 }
31263 resultobj = SWIG_From_long(static_cast< long >(result));
31264 return resultobj;
31265 fail:
31266 return NULL;
31267 }
31268
31269
31270 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31271 PyObject *resultobj = 0;
31272 long result;
31273
31274 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31275 {
31276 PyThreadState* __tstate = wxPyBeginAllowThreads();
31277 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31278 wxPyEndAllowThreads(__tstate);
31279 if (PyErr_Occurred()) SWIG_fail;
31280 }
31281 resultobj = SWIG_From_long(static_cast< long >(result));
31282 return resultobj;
31283 fail:
31284 return NULL;
31285 }
31286
31287
31288 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31289 PyObject *resultobj = 0;
31290 long result;
31291
31292 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31293 {
31294 PyThreadState* __tstate = wxPyBeginAllowThreads();
31295 result = (long)wxPyApp::GetMacExitMenuItemId();
31296 wxPyEndAllowThreads(__tstate);
31297 if (PyErr_Occurred()) SWIG_fail;
31298 }
31299 resultobj = SWIG_From_long(static_cast< long >(result));
31300 return resultobj;
31301 fail:
31302 return NULL;
31303 }
31304
31305
31306 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31307 PyObject *resultobj = 0;
31308 wxString result;
31309
31310 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31311 {
31312 PyThreadState* __tstate = wxPyBeginAllowThreads();
31313 result = wxPyApp::GetMacHelpMenuTitleName();
31314 wxPyEndAllowThreads(__tstate);
31315 if (PyErr_Occurred()) SWIG_fail;
31316 }
31317 {
31318 #if wxUSE_UNICODE
31319 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31320 #else
31321 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31322 #endif
31323 }
31324 return resultobj;
31325 fail:
31326 return NULL;
31327 }
31328
31329
31330 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31331 PyObject *resultobj = 0;
31332 bool arg1 ;
31333 bool val1 ;
31334 int ecode1 = 0 ;
31335 PyObject * obj0 = 0 ;
31336 char * kwnames[] = {
31337 (char *) "val", NULL
31338 };
31339
31340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31341 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31342 if (!SWIG_IsOK(ecode1)) {
31343 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31344 }
31345 arg1 = static_cast< bool >(val1);
31346 {
31347 PyThreadState* __tstate = wxPyBeginAllowThreads();
31348 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31349 wxPyEndAllowThreads(__tstate);
31350 if (PyErr_Occurred()) SWIG_fail;
31351 }
31352 resultobj = SWIG_Py_Void();
31353 return resultobj;
31354 fail:
31355 return NULL;
31356 }
31357
31358
31359 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31360 PyObject *resultobj = 0;
31361 long arg1 ;
31362 long val1 ;
31363 int ecode1 = 0 ;
31364 PyObject * obj0 = 0 ;
31365 char * kwnames[] = {
31366 (char *) "val", NULL
31367 };
31368
31369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31370 ecode1 = SWIG_AsVal_long(obj0, &val1);
31371 if (!SWIG_IsOK(ecode1)) {
31372 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31373 }
31374 arg1 = static_cast< long >(val1);
31375 {
31376 PyThreadState* __tstate = wxPyBeginAllowThreads();
31377 wxPyApp::SetMacAboutMenuItemId(arg1);
31378 wxPyEndAllowThreads(__tstate);
31379 if (PyErr_Occurred()) SWIG_fail;
31380 }
31381 resultobj = SWIG_Py_Void();
31382 return resultobj;
31383 fail:
31384 return NULL;
31385 }
31386
31387
31388 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31389 PyObject *resultobj = 0;
31390 long arg1 ;
31391 long val1 ;
31392 int ecode1 = 0 ;
31393 PyObject * obj0 = 0 ;
31394 char * kwnames[] = {
31395 (char *) "val", NULL
31396 };
31397
31398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31399 ecode1 = SWIG_AsVal_long(obj0, &val1);
31400 if (!SWIG_IsOK(ecode1)) {
31401 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31402 }
31403 arg1 = static_cast< long >(val1);
31404 {
31405 PyThreadState* __tstate = wxPyBeginAllowThreads();
31406 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31407 wxPyEndAllowThreads(__tstate);
31408 if (PyErr_Occurred()) SWIG_fail;
31409 }
31410 resultobj = SWIG_Py_Void();
31411 return resultobj;
31412 fail:
31413 return NULL;
31414 }
31415
31416
31417 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31418 PyObject *resultobj = 0;
31419 long arg1 ;
31420 long val1 ;
31421 int ecode1 = 0 ;
31422 PyObject * obj0 = 0 ;
31423 char * kwnames[] = {
31424 (char *) "val", NULL
31425 };
31426
31427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31428 ecode1 = SWIG_AsVal_long(obj0, &val1);
31429 if (!SWIG_IsOK(ecode1)) {
31430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31431 }
31432 arg1 = static_cast< long >(val1);
31433 {
31434 PyThreadState* __tstate = wxPyBeginAllowThreads();
31435 wxPyApp::SetMacExitMenuItemId(arg1);
31436 wxPyEndAllowThreads(__tstate);
31437 if (PyErr_Occurred()) SWIG_fail;
31438 }
31439 resultobj = SWIG_Py_Void();
31440 return resultobj;
31441 fail:
31442 return NULL;
31443 }
31444
31445
31446 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31447 PyObject *resultobj = 0;
31448 wxString *arg1 = 0 ;
31449 bool temp1 = false ;
31450 PyObject * obj0 = 0 ;
31451 char * kwnames[] = {
31452 (char *) "val", NULL
31453 };
31454
31455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31456 {
31457 arg1 = wxString_in_helper(obj0);
31458 if (arg1 == NULL) SWIG_fail;
31459 temp1 = true;
31460 }
31461 {
31462 PyThreadState* __tstate = wxPyBeginAllowThreads();
31463 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31464 wxPyEndAllowThreads(__tstate);
31465 if (PyErr_Occurred()) SWIG_fail;
31466 }
31467 resultobj = SWIG_Py_Void();
31468 {
31469 if (temp1)
31470 delete arg1;
31471 }
31472 return resultobj;
31473 fail:
31474 {
31475 if (temp1)
31476 delete arg1;
31477 }
31478 return NULL;
31479 }
31480
31481
31482 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31483 PyObject *resultobj = 0;
31484 wxPyApp *arg1 = (wxPyApp *) 0 ;
31485 void *argp1 = 0 ;
31486 int res1 = 0 ;
31487 PyObject *swig_obj[1] ;
31488
31489 if (!args) SWIG_fail;
31490 swig_obj[0] = args;
31491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31492 if (!SWIG_IsOK(res1)) {
31493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31494 }
31495 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31496 {
31497 PyThreadState* __tstate = wxPyBeginAllowThreads();
31498 (arg1)->_BootstrapApp();
31499 wxPyEndAllowThreads(__tstate);
31500 if (PyErr_Occurred()) SWIG_fail;
31501 }
31502 resultobj = SWIG_Py_Void();
31503 return resultobj;
31504 fail:
31505 return NULL;
31506 }
31507
31508
31509 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31510 PyObject *resultobj = 0;
31511 int result;
31512
31513 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31514 {
31515 PyThreadState* __tstate = wxPyBeginAllowThreads();
31516 result = (int)wxPyApp_GetComCtl32Version();
31517 wxPyEndAllowThreads(__tstate);
31518 if (PyErr_Occurred()) SWIG_fail;
31519 }
31520 resultobj = SWIG_From_int(static_cast< int >(result));
31521 return resultobj;
31522 fail:
31523 return NULL;
31524 }
31525
31526
31527 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31528 PyObject *resultobj = 0;
31529 bool result;
31530
31531 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31532 {
31533 PyThreadState* __tstate = wxPyBeginAllowThreads();
31534 result = (bool)wxPyApp_IsDisplayAvailable();
31535 wxPyEndAllowThreads(__tstate);
31536 if (PyErr_Occurred()) SWIG_fail;
31537 }
31538 {
31539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31540 }
31541 return resultobj;
31542 fail:
31543 return NULL;
31544 }
31545
31546
31547 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31548 PyObject *obj;
31549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31550 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31551 return SWIG_Py_Void();
31552 }
31553
31554 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31555 return SWIG_Python_InitShadowInstance(args);
31556 }
31557
31558 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31559 PyObject *resultobj = 0;
31560
31561 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31562 {
31563 PyThreadState* __tstate = wxPyBeginAllowThreads();
31564 wxExit();
31565 wxPyEndAllowThreads(__tstate);
31566 if (PyErr_Occurred()) SWIG_fail;
31567 }
31568 resultobj = SWIG_Py_Void();
31569 return resultobj;
31570 fail:
31571 return NULL;
31572 }
31573
31574
31575 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31576 PyObject *resultobj = 0;
31577 bool result;
31578
31579 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31580 {
31581 PyThreadState* __tstate = wxPyBeginAllowThreads();
31582 result = (bool)wxYield();
31583 wxPyEndAllowThreads(__tstate);
31584 if (PyErr_Occurred()) SWIG_fail;
31585 }
31586 {
31587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31588 }
31589 return resultobj;
31590 fail:
31591 return NULL;
31592 }
31593
31594
31595 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31596 PyObject *resultobj = 0;
31597 bool result;
31598
31599 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31600 {
31601 PyThreadState* __tstate = wxPyBeginAllowThreads();
31602 result = (bool)wxYieldIfNeeded();
31603 wxPyEndAllowThreads(__tstate);
31604 if (PyErr_Occurred()) SWIG_fail;
31605 }
31606 {
31607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31608 }
31609 return resultobj;
31610 fail:
31611 return NULL;
31612 }
31613
31614
31615 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31616 PyObject *resultobj = 0;
31617 wxWindow *arg1 = (wxWindow *) NULL ;
31618 bool arg2 = (bool) false ;
31619 bool result;
31620 void *argp1 = 0 ;
31621 int res1 = 0 ;
31622 bool val2 ;
31623 int ecode2 = 0 ;
31624 PyObject * obj0 = 0 ;
31625 PyObject * obj1 = 0 ;
31626 char * kwnames[] = {
31627 (char *) "win",(char *) "onlyIfNeeded", NULL
31628 };
31629
31630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31631 if (obj0) {
31632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31633 if (!SWIG_IsOK(res1)) {
31634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31635 }
31636 arg1 = reinterpret_cast< wxWindow * >(argp1);
31637 }
31638 if (obj1) {
31639 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31640 if (!SWIG_IsOK(ecode2)) {
31641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31642 }
31643 arg2 = static_cast< bool >(val2);
31644 }
31645 {
31646 PyThreadState* __tstate = wxPyBeginAllowThreads();
31647 result = (bool)wxSafeYield(arg1,arg2);
31648 wxPyEndAllowThreads(__tstate);
31649 if (PyErr_Occurred()) SWIG_fail;
31650 }
31651 {
31652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31653 }
31654 return resultobj;
31655 fail:
31656 return NULL;
31657 }
31658
31659
31660 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31661 PyObject *resultobj = 0;
31662
31663 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31664 {
31665 PyThreadState* __tstate = wxPyBeginAllowThreads();
31666 wxWakeUpIdle();
31667 wxPyEndAllowThreads(__tstate);
31668 if (PyErr_Occurred()) SWIG_fail;
31669 }
31670 resultobj = SWIG_Py_Void();
31671 return resultobj;
31672 fail:
31673 return NULL;
31674 }
31675
31676
31677 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31678 PyObject *resultobj = 0;
31679 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31680 wxEvent *arg2 = 0 ;
31681 void *argp1 = 0 ;
31682 int res1 = 0 ;
31683 void *argp2 = 0 ;
31684 int res2 = 0 ;
31685 PyObject * obj0 = 0 ;
31686 PyObject * obj1 = 0 ;
31687 char * kwnames[] = {
31688 (char *) "dest",(char *) "event", NULL
31689 };
31690
31691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31693 if (!SWIG_IsOK(res1)) {
31694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31695 }
31696 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31697 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31698 if (!SWIG_IsOK(res2)) {
31699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31700 }
31701 if (!argp2) {
31702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31703 }
31704 arg2 = reinterpret_cast< wxEvent * >(argp2);
31705 {
31706 PyThreadState* __tstate = wxPyBeginAllowThreads();
31707 wxPostEvent(arg1,*arg2);
31708 wxPyEndAllowThreads(__tstate);
31709 if (PyErr_Occurred()) SWIG_fail;
31710 }
31711 resultobj = SWIG_Py_Void();
31712 return resultobj;
31713 fail:
31714 return NULL;
31715 }
31716
31717
31718 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31719 PyObject *resultobj = 0;
31720
31721 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31722 {
31723 PyThreadState* __tstate = wxPyBeginAllowThreads();
31724 wxApp_CleanUp();
31725 wxPyEndAllowThreads(__tstate);
31726 if (PyErr_Occurred()) SWIG_fail;
31727 }
31728 resultobj = SWIG_Py_Void();
31729 return resultobj;
31730 fail:
31731 return NULL;
31732 }
31733
31734
31735 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31736 PyObject *resultobj = 0;
31737 wxPyApp *result = 0 ;
31738
31739 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31740 {
31741 PyThreadState* __tstate = wxPyBeginAllowThreads();
31742 result = (wxPyApp *)wxPyGetApp();
31743 wxPyEndAllowThreads(__tstate);
31744 if (PyErr_Occurred()) SWIG_fail;
31745 }
31746 {
31747 resultobj = wxPyMake_wxObject(result, 0);
31748 }
31749 return resultobj;
31750 fail:
31751 return NULL;
31752 }
31753
31754
31755 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31756 PyObject *resultobj = 0;
31757 char *arg1 = (char *) 0 ;
31758 int res1 ;
31759 char *buf1 = 0 ;
31760 int alloc1 = 0 ;
31761 PyObject * obj0 = 0 ;
31762 char * kwnames[] = {
31763 (char *) "encoding", NULL
31764 };
31765
31766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31767 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31768 if (!SWIG_IsOK(res1)) {
31769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31770 }
31771 arg1 = buf1;
31772 {
31773 PyThreadState* __tstate = wxPyBeginAllowThreads();
31774 wxSetDefaultPyEncoding((char const *)arg1);
31775 wxPyEndAllowThreads(__tstate);
31776 if (PyErr_Occurred()) SWIG_fail;
31777 }
31778 resultobj = SWIG_Py_Void();
31779 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31780 return resultobj;
31781 fail:
31782 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31783 return NULL;
31784 }
31785
31786
31787 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31788 PyObject *resultobj = 0;
31789 char *result = 0 ;
31790
31791 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31792 {
31793 PyThreadState* __tstate = wxPyBeginAllowThreads();
31794 result = (char *)wxGetDefaultPyEncoding();
31795 wxPyEndAllowThreads(__tstate);
31796 if (PyErr_Occurred()) SWIG_fail;
31797 }
31798 resultobj = SWIG_FromCharPtr(result);
31799 return resultobj;
31800 fail:
31801 return NULL;
31802 }
31803
31804
31805 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31806 PyObject *resultobj = 0;
31807 wxEventLoop *result = 0 ;
31808
31809 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31810 {
31811 PyThreadState* __tstate = wxPyBeginAllowThreads();
31812 result = (wxEventLoop *)new wxEventLoop();
31813 wxPyEndAllowThreads(__tstate);
31814 if (PyErr_Occurred()) SWIG_fail;
31815 }
31816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31817 return resultobj;
31818 fail:
31819 return NULL;
31820 }
31821
31822
31823 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31824 PyObject *resultobj = 0;
31825 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31826 void *argp1 = 0 ;
31827 int res1 = 0 ;
31828 PyObject *swig_obj[1] ;
31829
31830 if (!args) SWIG_fail;
31831 swig_obj[0] = args;
31832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31833 if (!SWIG_IsOK(res1)) {
31834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31835 }
31836 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31837 {
31838 PyThreadState* __tstate = wxPyBeginAllowThreads();
31839 delete arg1;
31840
31841 wxPyEndAllowThreads(__tstate);
31842 if (PyErr_Occurred()) SWIG_fail;
31843 }
31844 resultobj = SWIG_Py_Void();
31845 return resultobj;
31846 fail:
31847 return NULL;
31848 }
31849
31850
31851 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31852 PyObject *resultobj = 0;
31853 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31854 int result;
31855 void *argp1 = 0 ;
31856 int res1 = 0 ;
31857 PyObject *swig_obj[1] ;
31858
31859 if (!args) SWIG_fail;
31860 swig_obj[0] = args;
31861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31862 if (!SWIG_IsOK(res1)) {
31863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31864 }
31865 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31866 {
31867 PyThreadState* __tstate = wxPyBeginAllowThreads();
31868 result = (int)(arg1)->Run();
31869 wxPyEndAllowThreads(__tstate);
31870 if (PyErr_Occurred()) SWIG_fail;
31871 }
31872 resultobj = SWIG_From_int(static_cast< int >(result));
31873 return resultobj;
31874 fail:
31875 return NULL;
31876 }
31877
31878
31879 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31880 PyObject *resultobj = 0;
31881 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31882 int arg2 = (int) 0 ;
31883 void *argp1 = 0 ;
31884 int res1 = 0 ;
31885 int val2 ;
31886 int ecode2 = 0 ;
31887 PyObject * obj0 = 0 ;
31888 PyObject * obj1 = 0 ;
31889 char * kwnames[] = {
31890 (char *) "self",(char *) "rc", NULL
31891 };
31892
31893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31895 if (!SWIG_IsOK(res1)) {
31896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31897 }
31898 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31899 if (obj1) {
31900 ecode2 = SWIG_AsVal_int(obj1, &val2);
31901 if (!SWIG_IsOK(ecode2)) {
31902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31903 }
31904 arg2 = static_cast< int >(val2);
31905 }
31906 {
31907 PyThreadState* __tstate = wxPyBeginAllowThreads();
31908 (arg1)->Exit(arg2);
31909 wxPyEndAllowThreads(__tstate);
31910 if (PyErr_Occurred()) SWIG_fail;
31911 }
31912 resultobj = SWIG_Py_Void();
31913 return resultobj;
31914 fail:
31915 return NULL;
31916 }
31917
31918
31919 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31920 PyObject *resultobj = 0;
31921 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31922 bool result;
31923 void *argp1 = 0 ;
31924 int res1 = 0 ;
31925 PyObject *swig_obj[1] ;
31926
31927 if (!args) SWIG_fail;
31928 swig_obj[0] = args;
31929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31930 if (!SWIG_IsOK(res1)) {
31931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31932 }
31933 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31934 {
31935 PyThreadState* __tstate = wxPyBeginAllowThreads();
31936 result = (bool)((wxEventLoop const *)arg1)->Pending();
31937 wxPyEndAllowThreads(__tstate);
31938 if (PyErr_Occurred()) SWIG_fail;
31939 }
31940 {
31941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31942 }
31943 return resultobj;
31944 fail:
31945 return NULL;
31946 }
31947
31948
31949 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31950 PyObject *resultobj = 0;
31951 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31952 bool result;
31953 void *argp1 = 0 ;
31954 int res1 = 0 ;
31955 PyObject *swig_obj[1] ;
31956
31957 if (!args) SWIG_fail;
31958 swig_obj[0] = args;
31959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31960 if (!SWIG_IsOK(res1)) {
31961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31962 }
31963 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31964 {
31965 PyThreadState* __tstate = wxPyBeginAllowThreads();
31966 result = (bool)(arg1)->Dispatch();
31967 wxPyEndAllowThreads(__tstate);
31968 if (PyErr_Occurred()) SWIG_fail;
31969 }
31970 {
31971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31972 }
31973 return resultobj;
31974 fail:
31975 return NULL;
31976 }
31977
31978
31979 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31980 PyObject *resultobj = 0;
31981 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31982 bool result;
31983 void *argp1 = 0 ;
31984 int res1 = 0 ;
31985 PyObject *swig_obj[1] ;
31986
31987 if (!args) SWIG_fail;
31988 swig_obj[0] = args;
31989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31990 if (!SWIG_IsOK(res1)) {
31991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31992 }
31993 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31994 {
31995 PyThreadState* __tstate = wxPyBeginAllowThreads();
31996 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31997 wxPyEndAllowThreads(__tstate);
31998 if (PyErr_Occurred()) SWIG_fail;
31999 }
32000 {
32001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32002 }
32003 return resultobj;
32004 fail:
32005 return NULL;
32006 }
32007
32008
32009 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32010 PyObject *resultobj = 0;
32011 wxEventLoop *result = 0 ;
32012
32013 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
32014 {
32015 PyThreadState* __tstate = wxPyBeginAllowThreads();
32016 result = (wxEventLoop *)wxEventLoop::GetActive();
32017 wxPyEndAllowThreads(__tstate);
32018 if (PyErr_Occurred()) SWIG_fail;
32019 }
32020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
32021 return resultobj;
32022 fail:
32023 return NULL;
32024 }
32025
32026
32027 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32028 PyObject *resultobj = 0;
32029 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32030 void *argp1 = 0 ;
32031 int res1 = 0 ;
32032 PyObject * obj0 = 0 ;
32033 char * kwnames[] = {
32034 (char *) "loop", NULL
32035 };
32036
32037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
32038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32039 if (!SWIG_IsOK(res1)) {
32040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32041 }
32042 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32043 {
32044 PyThreadState* __tstate = wxPyBeginAllowThreads();
32045 wxEventLoop::SetActive(arg1);
32046 wxPyEndAllowThreads(__tstate);
32047 if (PyErr_Occurred()) SWIG_fail;
32048 }
32049 resultobj = SWIG_Py_Void();
32050 return resultobj;
32051 fail:
32052 return NULL;
32053 }
32054
32055
32056 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32057 PyObject *obj;
32058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32059 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
32060 return SWIG_Py_Void();
32061 }
32062
32063 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32064 return SWIG_Python_InitShadowInstance(args);
32065 }
32066
32067 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32068 PyObject *resultobj = 0;
32069 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32070 wxEventLoopActivator *result = 0 ;
32071 void *argp1 = 0 ;
32072 int res1 = 0 ;
32073 PyObject * obj0 = 0 ;
32074 char * kwnames[] = {
32075 (char *) "evtLoop", NULL
32076 };
32077
32078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
32079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32080 if (!SWIG_IsOK(res1)) {
32081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32082 }
32083 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32084 {
32085 PyThreadState* __tstate = wxPyBeginAllowThreads();
32086 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
32087 wxPyEndAllowThreads(__tstate);
32088 if (PyErr_Occurred()) SWIG_fail;
32089 }
32090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
32091 return resultobj;
32092 fail:
32093 return NULL;
32094 }
32095
32096
32097 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32098 PyObject *resultobj = 0;
32099 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
32100 void *argp1 = 0 ;
32101 int res1 = 0 ;
32102 PyObject *swig_obj[1] ;
32103
32104 if (!args) SWIG_fail;
32105 swig_obj[0] = args;
32106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
32107 if (!SWIG_IsOK(res1)) {
32108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
32109 }
32110 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
32111 {
32112 PyThreadState* __tstate = wxPyBeginAllowThreads();
32113 delete arg1;
32114
32115 wxPyEndAllowThreads(__tstate);
32116 if (PyErr_Occurred()) SWIG_fail;
32117 }
32118 resultobj = SWIG_Py_Void();
32119 return resultobj;
32120 fail:
32121 return NULL;
32122 }
32123
32124
32125 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32126 PyObject *obj;
32127 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32128 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
32129 return SWIG_Py_Void();
32130 }
32131
32132 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32133 return SWIG_Python_InitShadowInstance(args);
32134 }
32135
32136 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32137 PyObject *resultobj = 0;
32138 int arg1 = (int) 0 ;
32139 int arg2 = (int) 0 ;
32140 int arg3 = (int) 0 ;
32141 wxAcceleratorEntry *result = 0 ;
32142 int val1 ;
32143 int ecode1 = 0 ;
32144 int val2 ;
32145 int ecode2 = 0 ;
32146 int val3 ;
32147 int ecode3 = 0 ;
32148 PyObject * obj0 = 0 ;
32149 PyObject * obj1 = 0 ;
32150 PyObject * obj2 = 0 ;
32151 char * kwnames[] = {
32152 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
32153 };
32154
32155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32156 if (obj0) {
32157 ecode1 = SWIG_AsVal_int(obj0, &val1);
32158 if (!SWIG_IsOK(ecode1)) {
32159 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
32160 }
32161 arg1 = static_cast< int >(val1);
32162 }
32163 if (obj1) {
32164 ecode2 = SWIG_AsVal_int(obj1, &val2);
32165 if (!SWIG_IsOK(ecode2)) {
32166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32167 }
32168 arg2 = static_cast< int >(val2);
32169 }
32170 if (obj2) {
32171 ecode3 = SWIG_AsVal_int(obj2, &val3);
32172 if (!SWIG_IsOK(ecode3)) {
32173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32174 }
32175 arg3 = static_cast< int >(val3);
32176 }
32177 {
32178 PyThreadState* __tstate = wxPyBeginAllowThreads();
32179 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32180 wxPyEndAllowThreads(__tstate);
32181 if (PyErr_Occurred()) SWIG_fail;
32182 }
32183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32184 return resultobj;
32185 fail:
32186 return NULL;
32187 }
32188
32189
32190 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32191 PyObject *resultobj = 0;
32192 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32193 void *argp1 = 0 ;
32194 int res1 = 0 ;
32195 PyObject *swig_obj[1] ;
32196
32197 if (!args) SWIG_fail;
32198 swig_obj[0] = args;
32199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32200 if (!SWIG_IsOK(res1)) {
32201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32202 }
32203 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32204 {
32205 PyThreadState* __tstate = wxPyBeginAllowThreads();
32206 delete arg1;
32207
32208 wxPyEndAllowThreads(__tstate);
32209 if (PyErr_Occurred()) SWIG_fail;
32210 }
32211 resultobj = SWIG_Py_Void();
32212 return resultobj;
32213 fail:
32214 return NULL;
32215 }
32216
32217
32218 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32219 PyObject *resultobj = 0;
32220 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32221 int arg2 ;
32222 int arg3 ;
32223 int arg4 ;
32224 void *argp1 = 0 ;
32225 int res1 = 0 ;
32226 int val2 ;
32227 int ecode2 = 0 ;
32228 int val3 ;
32229 int ecode3 = 0 ;
32230 int val4 ;
32231 int ecode4 = 0 ;
32232 PyObject * obj0 = 0 ;
32233 PyObject * obj1 = 0 ;
32234 PyObject * obj2 = 0 ;
32235 PyObject * obj3 = 0 ;
32236 char * kwnames[] = {
32237 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32238 };
32239
32240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32242 if (!SWIG_IsOK(res1)) {
32243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32244 }
32245 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32246 ecode2 = SWIG_AsVal_int(obj1, &val2);
32247 if (!SWIG_IsOK(ecode2)) {
32248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32249 }
32250 arg2 = static_cast< int >(val2);
32251 ecode3 = SWIG_AsVal_int(obj2, &val3);
32252 if (!SWIG_IsOK(ecode3)) {
32253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32254 }
32255 arg3 = static_cast< int >(val3);
32256 ecode4 = SWIG_AsVal_int(obj3, &val4);
32257 if (!SWIG_IsOK(ecode4)) {
32258 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32259 }
32260 arg4 = static_cast< int >(val4);
32261 {
32262 PyThreadState* __tstate = wxPyBeginAllowThreads();
32263 (arg1)->Set(arg2,arg3,arg4);
32264 wxPyEndAllowThreads(__tstate);
32265 if (PyErr_Occurred()) SWIG_fail;
32266 }
32267 resultobj = SWIG_Py_Void();
32268 return resultobj;
32269 fail:
32270 return NULL;
32271 }
32272
32273
32274 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32275 PyObject *resultobj = 0;
32276 wxString *arg1 = 0 ;
32277 wxAcceleratorEntry *result = 0 ;
32278 bool temp1 = false ;
32279 PyObject * obj0 = 0 ;
32280 char * kwnames[] = {
32281 (char *) "str", NULL
32282 };
32283
32284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32285 {
32286 arg1 = wxString_in_helper(obj0);
32287 if (arg1 == NULL) SWIG_fail;
32288 temp1 = true;
32289 }
32290 {
32291 PyThreadState* __tstate = wxPyBeginAllowThreads();
32292 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32293 wxPyEndAllowThreads(__tstate);
32294 if (PyErr_Occurred()) SWIG_fail;
32295 }
32296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32297 {
32298 if (temp1)
32299 delete arg1;
32300 }
32301 return resultobj;
32302 fail:
32303 {
32304 if (temp1)
32305 delete arg1;
32306 }
32307 return NULL;
32308 }
32309
32310
32311 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32312 PyObject *resultobj = 0;
32313 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32314 int result;
32315 void *argp1 = 0 ;
32316 int res1 = 0 ;
32317 PyObject *swig_obj[1] ;
32318
32319 if (!args) SWIG_fail;
32320 swig_obj[0] = args;
32321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32322 if (!SWIG_IsOK(res1)) {
32323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32324 }
32325 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32326 {
32327 PyThreadState* __tstate = wxPyBeginAllowThreads();
32328 result = (int)(arg1)->GetFlags();
32329 wxPyEndAllowThreads(__tstate);
32330 if (PyErr_Occurred()) SWIG_fail;
32331 }
32332 resultobj = SWIG_From_int(static_cast< int >(result));
32333 return resultobj;
32334 fail:
32335 return NULL;
32336 }
32337
32338
32339 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32340 PyObject *resultobj = 0;
32341 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32342 int result;
32343 void *argp1 = 0 ;
32344 int res1 = 0 ;
32345 PyObject *swig_obj[1] ;
32346
32347 if (!args) SWIG_fail;
32348 swig_obj[0] = args;
32349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32350 if (!SWIG_IsOK(res1)) {
32351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32352 }
32353 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32354 {
32355 PyThreadState* __tstate = wxPyBeginAllowThreads();
32356 result = (int)(arg1)->GetKeyCode();
32357 wxPyEndAllowThreads(__tstate);
32358 if (PyErr_Occurred()) SWIG_fail;
32359 }
32360 resultobj = SWIG_From_int(static_cast< int >(result));
32361 return resultobj;
32362 fail:
32363 return NULL;
32364 }
32365
32366
32367 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32368 PyObject *resultobj = 0;
32369 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32370 int result;
32371 void *argp1 = 0 ;
32372 int res1 = 0 ;
32373 PyObject *swig_obj[1] ;
32374
32375 if (!args) SWIG_fail;
32376 swig_obj[0] = args;
32377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32378 if (!SWIG_IsOK(res1)) {
32379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32380 }
32381 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32382 {
32383 PyThreadState* __tstate = wxPyBeginAllowThreads();
32384 result = (int)(arg1)->GetCommand();
32385 wxPyEndAllowThreads(__tstate);
32386 if (PyErr_Occurred()) SWIG_fail;
32387 }
32388 resultobj = SWIG_From_int(static_cast< int >(result));
32389 return resultobj;
32390 fail:
32391 return NULL;
32392 }
32393
32394
32395 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32396 PyObject *resultobj = 0;
32397 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32398 bool result;
32399 void *argp1 = 0 ;
32400 int res1 = 0 ;
32401 PyObject *swig_obj[1] ;
32402
32403 if (!args) SWIG_fail;
32404 swig_obj[0] = args;
32405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32406 if (!SWIG_IsOK(res1)) {
32407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32408 }
32409 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32410 {
32411 PyThreadState* __tstate = wxPyBeginAllowThreads();
32412 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32413 wxPyEndAllowThreads(__tstate);
32414 if (PyErr_Occurred()) SWIG_fail;
32415 }
32416 {
32417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32418 }
32419 return resultobj;
32420 fail:
32421 return NULL;
32422 }
32423
32424
32425 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32426 PyObject *resultobj = 0;
32427 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32428 wxString result;
32429 void *argp1 = 0 ;
32430 int res1 = 0 ;
32431 PyObject *swig_obj[1] ;
32432
32433 if (!args) SWIG_fail;
32434 swig_obj[0] = args;
32435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32436 if (!SWIG_IsOK(res1)) {
32437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32438 }
32439 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32440 {
32441 PyThreadState* __tstate = wxPyBeginAllowThreads();
32442 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32443 wxPyEndAllowThreads(__tstate);
32444 if (PyErr_Occurred()) SWIG_fail;
32445 }
32446 {
32447 #if wxUSE_UNICODE
32448 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32449 #else
32450 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32451 #endif
32452 }
32453 return resultobj;
32454 fail:
32455 return NULL;
32456 }
32457
32458
32459 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32460 PyObject *resultobj = 0;
32461 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32462 wxString *arg2 = 0 ;
32463 bool result;
32464 void *argp1 = 0 ;
32465 int res1 = 0 ;
32466 bool temp2 = false ;
32467 PyObject * obj0 = 0 ;
32468 PyObject * obj1 = 0 ;
32469 char * kwnames[] = {
32470 (char *) "self",(char *) "str", NULL
32471 };
32472
32473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32475 if (!SWIG_IsOK(res1)) {
32476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32477 }
32478 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32479 {
32480 arg2 = wxString_in_helper(obj1);
32481 if (arg2 == NULL) SWIG_fail;
32482 temp2 = true;
32483 }
32484 {
32485 PyThreadState* __tstate = wxPyBeginAllowThreads();
32486 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32487 wxPyEndAllowThreads(__tstate);
32488 if (PyErr_Occurred()) SWIG_fail;
32489 }
32490 {
32491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32492 }
32493 {
32494 if (temp2)
32495 delete arg2;
32496 }
32497 return resultobj;
32498 fail:
32499 {
32500 if (temp2)
32501 delete arg2;
32502 }
32503 return NULL;
32504 }
32505
32506
32507 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32508 PyObject *obj;
32509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32510 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32511 return SWIG_Py_Void();
32512 }
32513
32514 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32515 return SWIG_Python_InitShadowInstance(args);
32516 }
32517
32518 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32519 PyObject *resultobj = 0;
32520 int arg1 ;
32521 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32522 wxAcceleratorTable *result = 0 ;
32523 PyObject * obj0 = 0 ;
32524 char * kwnames[] = {
32525 (char *) "n", NULL
32526 };
32527
32528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32529 {
32530 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32531 if (arg2) arg1 = PyList_Size(obj0);
32532 else arg1 = 0;
32533 }
32534 {
32535 PyThreadState* __tstate = wxPyBeginAllowThreads();
32536 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32537 wxPyEndAllowThreads(__tstate);
32538 if (PyErr_Occurred()) SWIG_fail;
32539 }
32540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32541 return resultobj;
32542 fail:
32543 return NULL;
32544 }
32545
32546
32547 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32548 PyObject *resultobj = 0;
32549 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32550 void *argp1 = 0 ;
32551 int res1 = 0 ;
32552 PyObject *swig_obj[1] ;
32553
32554 if (!args) SWIG_fail;
32555 swig_obj[0] = args;
32556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32557 if (!SWIG_IsOK(res1)) {
32558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32559 }
32560 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32561 {
32562 PyThreadState* __tstate = wxPyBeginAllowThreads();
32563 delete arg1;
32564
32565 wxPyEndAllowThreads(__tstate);
32566 if (PyErr_Occurred()) SWIG_fail;
32567 }
32568 resultobj = SWIG_Py_Void();
32569 return resultobj;
32570 fail:
32571 return NULL;
32572 }
32573
32574
32575 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32576 PyObject *resultobj = 0;
32577 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32578 bool result;
32579 void *argp1 = 0 ;
32580 int res1 = 0 ;
32581 PyObject *swig_obj[1] ;
32582
32583 if (!args) SWIG_fail;
32584 swig_obj[0] = args;
32585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32586 if (!SWIG_IsOK(res1)) {
32587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32588 }
32589 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32590 {
32591 PyThreadState* __tstate = wxPyBeginAllowThreads();
32592 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32593 wxPyEndAllowThreads(__tstate);
32594 if (PyErr_Occurred()) SWIG_fail;
32595 }
32596 {
32597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32598 }
32599 return resultobj;
32600 fail:
32601 return NULL;
32602 }
32603
32604
32605 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32606 PyObject *obj;
32607 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32608 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32609 return SWIG_Py_Void();
32610 }
32611
32612 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32613 return SWIG_Python_InitShadowInstance(args);
32614 }
32615
32616 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32617 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32618 return 1;
32619 }
32620
32621
32622 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32623 PyObject *pyobj = 0;
32624
32625 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32626 return pyobj;
32627 }
32628
32629
32630 SWIGINTERN int PanelNameStr_set(PyObject *) {
32631 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32632 return 1;
32633 }
32634
32635
32636 SWIGINTERN PyObject *PanelNameStr_get(void) {
32637 PyObject *pyobj = 0;
32638
32639 {
32640 #if wxUSE_UNICODE
32641 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32642 #else
32643 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32644 #endif
32645 }
32646 return pyobj;
32647 }
32648
32649
32650 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32651 PyObject *resultobj = 0;
32652 wxVisualAttributes *result = 0 ;
32653
32654 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32655 {
32656 PyThreadState* __tstate = wxPyBeginAllowThreads();
32657 result = (wxVisualAttributes *)new_wxVisualAttributes();
32658 wxPyEndAllowThreads(__tstate);
32659 if (PyErr_Occurred()) SWIG_fail;
32660 }
32661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32662 return resultobj;
32663 fail:
32664 return NULL;
32665 }
32666
32667
32668 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32669 PyObject *resultobj = 0;
32670 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32671 void *argp1 = 0 ;
32672 int res1 = 0 ;
32673 PyObject *swig_obj[1] ;
32674
32675 if (!args) SWIG_fail;
32676 swig_obj[0] = args;
32677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32678 if (!SWIG_IsOK(res1)) {
32679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32680 }
32681 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32682 {
32683 PyThreadState* __tstate = wxPyBeginAllowThreads();
32684 delete_wxVisualAttributes(arg1);
32685
32686 wxPyEndAllowThreads(__tstate);
32687 if (PyErr_Occurred()) SWIG_fail;
32688 }
32689 resultobj = SWIG_Py_Void();
32690 return resultobj;
32691 fail:
32692 return NULL;
32693 }
32694
32695
32696 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32697 PyObject *resultobj = 0;
32698 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32699 wxFont *arg2 = (wxFont *) 0 ;
32700 void *argp1 = 0 ;
32701 int res1 = 0 ;
32702 void *argp2 = 0 ;
32703 int res2 = 0 ;
32704 PyObject *swig_obj[2] ;
32705
32706 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32708 if (!SWIG_IsOK(res1)) {
32709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32710 }
32711 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32712 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32713 if (!SWIG_IsOK(res2)) {
32714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32715 }
32716 arg2 = reinterpret_cast< wxFont * >(argp2);
32717 if (arg1) (arg1)->font = *arg2;
32718
32719 resultobj = SWIG_Py_Void();
32720 return resultobj;
32721 fail:
32722 return NULL;
32723 }
32724
32725
32726 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32727 PyObject *resultobj = 0;
32728 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32729 wxFont *result = 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_wxVisualAttributes, 0 | 0 );
32737 if (!SWIG_IsOK(res1)) {
32738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32739 }
32740 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32741 result = (wxFont *)& ((arg1)->font);
32742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32743 return resultobj;
32744 fail:
32745 return NULL;
32746 }
32747
32748
32749 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32750 PyObject *resultobj = 0;
32751 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32752 wxColour *arg2 = (wxColour *) 0 ;
32753 void *argp1 = 0 ;
32754 int res1 = 0 ;
32755 void *argp2 = 0 ;
32756 int res2 = 0 ;
32757 PyObject *swig_obj[2] ;
32758
32759 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32761 if (!SWIG_IsOK(res1)) {
32762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32763 }
32764 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32765 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32766 if (!SWIG_IsOK(res2)) {
32767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32768 }
32769 arg2 = reinterpret_cast< wxColour * >(argp2);
32770 if (arg1) (arg1)->colFg = *arg2;
32771
32772 resultobj = SWIG_Py_Void();
32773 return resultobj;
32774 fail:
32775 return NULL;
32776 }
32777
32778
32779 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32780 PyObject *resultobj = 0;
32781 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32782 wxColour *result = 0 ;
32783 void *argp1 = 0 ;
32784 int res1 = 0 ;
32785 PyObject *swig_obj[1] ;
32786
32787 if (!args) SWIG_fail;
32788 swig_obj[0] = args;
32789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32790 if (!SWIG_IsOK(res1)) {
32791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32792 }
32793 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32794 result = (wxColour *)& ((arg1)->colFg);
32795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32796 return resultobj;
32797 fail:
32798 return NULL;
32799 }
32800
32801
32802 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32803 PyObject *resultobj = 0;
32804 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32805 wxColour *arg2 = (wxColour *) 0 ;
32806 void *argp1 = 0 ;
32807 int res1 = 0 ;
32808 void *argp2 = 0 ;
32809 int res2 = 0 ;
32810 PyObject *swig_obj[2] ;
32811
32812 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32814 if (!SWIG_IsOK(res1)) {
32815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32816 }
32817 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32818 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32819 if (!SWIG_IsOK(res2)) {
32820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32821 }
32822 arg2 = reinterpret_cast< wxColour * >(argp2);
32823 if (arg1) (arg1)->colBg = *arg2;
32824
32825 resultobj = SWIG_Py_Void();
32826 return resultobj;
32827 fail:
32828 return NULL;
32829 }
32830
32831
32832 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32833 PyObject *resultobj = 0;
32834 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32835 wxColour *result = 0 ;
32836 void *argp1 = 0 ;
32837 int res1 = 0 ;
32838 PyObject *swig_obj[1] ;
32839
32840 if (!args) SWIG_fail;
32841 swig_obj[0] = args;
32842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32843 if (!SWIG_IsOK(res1)) {
32844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32845 }
32846 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32847 result = (wxColour *)& ((arg1)->colBg);
32848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32849 return resultobj;
32850 fail:
32851 return NULL;
32852 }
32853
32854
32855 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32856 PyObject *obj;
32857 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32858 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32859 return SWIG_Py_Void();
32860 }
32861
32862 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32863 return SWIG_Python_InitShadowInstance(args);
32864 }
32865
32866 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32867 PyObject *resultobj = 0;
32868 wxWindow *arg1 = (wxWindow *) 0 ;
32869 int arg2 = (int) (int)-1 ;
32870 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32871 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32872 wxSize const &arg4_defvalue = wxDefaultSize ;
32873 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32874 long arg5 = (long) 0 ;
32875 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32876 wxString *arg6 = (wxString *) &arg6_defvalue ;
32877 wxWindow *result = 0 ;
32878 void *argp1 = 0 ;
32879 int res1 = 0 ;
32880 int val2 ;
32881 int ecode2 = 0 ;
32882 wxPoint temp3 ;
32883 wxSize temp4 ;
32884 long val5 ;
32885 int ecode5 = 0 ;
32886 bool temp6 = false ;
32887 PyObject * obj0 = 0 ;
32888 PyObject * obj1 = 0 ;
32889 PyObject * obj2 = 0 ;
32890 PyObject * obj3 = 0 ;
32891 PyObject * obj4 = 0 ;
32892 PyObject * obj5 = 0 ;
32893 char * kwnames[] = {
32894 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32895 };
32896
32897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32899 if (!SWIG_IsOK(res1)) {
32900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32901 }
32902 arg1 = reinterpret_cast< wxWindow * >(argp1);
32903 if (obj1) {
32904 ecode2 = SWIG_AsVal_int(obj1, &val2);
32905 if (!SWIG_IsOK(ecode2)) {
32906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32907 }
32908 arg2 = static_cast< int >(val2);
32909 }
32910 if (obj2) {
32911 {
32912 arg3 = &temp3;
32913 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32914 }
32915 }
32916 if (obj3) {
32917 {
32918 arg4 = &temp4;
32919 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32920 }
32921 }
32922 if (obj4) {
32923 ecode5 = SWIG_AsVal_long(obj4, &val5);
32924 if (!SWIG_IsOK(ecode5)) {
32925 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32926 }
32927 arg5 = static_cast< long >(val5);
32928 }
32929 if (obj5) {
32930 {
32931 arg6 = wxString_in_helper(obj5);
32932 if (arg6 == NULL) SWIG_fail;
32933 temp6 = true;
32934 }
32935 }
32936 {
32937 if (!wxPyCheckForApp()) SWIG_fail;
32938 PyThreadState* __tstate = wxPyBeginAllowThreads();
32939 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32940 wxPyEndAllowThreads(__tstate);
32941 if (PyErr_Occurred()) SWIG_fail;
32942 }
32943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32944 {
32945 if (temp6)
32946 delete arg6;
32947 }
32948 return resultobj;
32949 fail:
32950 {
32951 if (temp6)
32952 delete arg6;
32953 }
32954 return NULL;
32955 }
32956
32957
32958 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32959 PyObject *resultobj = 0;
32960 wxWindow *result = 0 ;
32961
32962 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32963 {
32964 if (!wxPyCheckForApp()) SWIG_fail;
32965 PyThreadState* __tstate = wxPyBeginAllowThreads();
32966 result = (wxWindow *)new wxWindow();
32967 wxPyEndAllowThreads(__tstate);
32968 if (PyErr_Occurred()) SWIG_fail;
32969 }
32970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32971 return resultobj;
32972 fail:
32973 return NULL;
32974 }
32975
32976
32977 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32978 PyObject *resultobj = 0;
32979 wxWindow *arg1 = (wxWindow *) 0 ;
32980 wxWindow *arg2 = (wxWindow *) 0 ;
32981 int arg3 = (int) (int)-1 ;
32982 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32983 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32984 wxSize const &arg5_defvalue = wxDefaultSize ;
32985 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32986 long arg6 = (long) 0 ;
32987 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32988 wxString *arg7 = (wxString *) &arg7_defvalue ;
32989 bool result;
32990 void *argp1 = 0 ;
32991 int res1 = 0 ;
32992 void *argp2 = 0 ;
32993 int res2 = 0 ;
32994 int val3 ;
32995 int ecode3 = 0 ;
32996 wxPoint temp4 ;
32997 wxSize temp5 ;
32998 long val6 ;
32999 int ecode6 = 0 ;
33000 bool temp7 = false ;
33001 PyObject * obj0 = 0 ;
33002 PyObject * obj1 = 0 ;
33003 PyObject * obj2 = 0 ;
33004 PyObject * obj3 = 0 ;
33005 PyObject * obj4 = 0 ;
33006 PyObject * obj5 = 0 ;
33007 PyObject * obj6 = 0 ;
33008 char * kwnames[] = {
33009 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
33010 };
33011
33012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
33013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33014 if (!SWIG_IsOK(res1)) {
33015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
33016 }
33017 arg1 = reinterpret_cast< wxWindow * >(argp1);
33018 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33019 if (!SWIG_IsOK(res2)) {
33020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
33021 }
33022 arg2 = reinterpret_cast< wxWindow * >(argp2);
33023 if (obj2) {
33024 ecode3 = SWIG_AsVal_int(obj2, &val3);
33025 if (!SWIG_IsOK(ecode3)) {
33026 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
33027 }
33028 arg3 = static_cast< int >(val3);
33029 }
33030 if (obj3) {
33031 {
33032 arg4 = &temp4;
33033 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
33034 }
33035 }
33036 if (obj4) {
33037 {
33038 arg5 = &temp5;
33039 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
33040 }
33041 }
33042 if (obj5) {
33043 ecode6 = SWIG_AsVal_long(obj5, &val6);
33044 if (!SWIG_IsOK(ecode6)) {
33045 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
33046 }
33047 arg6 = static_cast< long >(val6);
33048 }
33049 if (obj6) {
33050 {
33051 arg7 = wxString_in_helper(obj6);
33052 if (arg7 == NULL) SWIG_fail;
33053 temp7 = true;
33054 }
33055 }
33056 {
33057 PyThreadState* __tstate = wxPyBeginAllowThreads();
33058 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
33059 wxPyEndAllowThreads(__tstate);
33060 if (PyErr_Occurred()) SWIG_fail;
33061 }
33062 {
33063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33064 }
33065 {
33066 if (temp7)
33067 delete arg7;
33068 }
33069 return resultobj;
33070 fail:
33071 {
33072 if (temp7)
33073 delete arg7;
33074 }
33075 return NULL;
33076 }
33077
33078
33079 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33080 PyObject *resultobj = 0;
33081 wxWindow *arg1 = (wxWindow *) 0 ;
33082 bool arg2 = (bool) false ;
33083 bool result;
33084 void *argp1 = 0 ;
33085 int res1 = 0 ;
33086 bool val2 ;
33087 int ecode2 = 0 ;
33088 PyObject * obj0 = 0 ;
33089 PyObject * obj1 = 0 ;
33090 char * kwnames[] = {
33091 (char *) "self",(char *) "force", NULL
33092 };
33093
33094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
33095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33096 if (!SWIG_IsOK(res1)) {
33097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
33098 }
33099 arg1 = reinterpret_cast< wxWindow * >(argp1);
33100 if (obj1) {
33101 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33102 if (!SWIG_IsOK(ecode2)) {
33103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
33104 }
33105 arg2 = static_cast< bool >(val2);
33106 }
33107 {
33108 PyThreadState* __tstate = wxPyBeginAllowThreads();
33109 result = (bool)(arg1)->Close(arg2);
33110 wxPyEndAllowThreads(__tstate);
33111 if (PyErr_Occurred()) SWIG_fail;
33112 }
33113 {
33114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33115 }
33116 return resultobj;
33117 fail:
33118 return NULL;
33119 }
33120
33121
33122 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33123 PyObject *resultobj = 0;
33124 wxWindow *arg1 = (wxWindow *) 0 ;
33125 bool result;
33126 void *argp1 = 0 ;
33127 int res1 = 0 ;
33128 PyObject *swig_obj[1] ;
33129
33130 if (!args) SWIG_fail;
33131 swig_obj[0] = args;
33132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33133 if (!SWIG_IsOK(res1)) {
33134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33135 }
33136 arg1 = reinterpret_cast< wxWindow * >(argp1);
33137 {
33138 PyThreadState* __tstate = wxPyBeginAllowThreads();
33139 result = (bool)(arg1)->Destroy();
33140 wxPyEndAllowThreads(__tstate);
33141 if (PyErr_Occurred()) SWIG_fail;
33142 }
33143 {
33144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33145 }
33146 return resultobj;
33147 fail:
33148 return NULL;
33149 }
33150
33151
33152 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33153 PyObject *resultobj = 0;
33154 wxWindow *arg1 = (wxWindow *) 0 ;
33155 bool result;
33156 void *argp1 = 0 ;
33157 int res1 = 0 ;
33158 PyObject *swig_obj[1] ;
33159
33160 if (!args) SWIG_fail;
33161 swig_obj[0] = args;
33162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33163 if (!SWIG_IsOK(res1)) {
33164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33165 }
33166 arg1 = reinterpret_cast< wxWindow * >(argp1);
33167 {
33168 PyThreadState* __tstate = wxPyBeginAllowThreads();
33169 result = (bool)(arg1)->DestroyChildren();
33170 wxPyEndAllowThreads(__tstate);
33171 if (PyErr_Occurred()) SWIG_fail;
33172 }
33173 {
33174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33175 }
33176 return resultobj;
33177 fail:
33178 return NULL;
33179 }
33180
33181
33182 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33183 PyObject *resultobj = 0;
33184 wxWindow *arg1 = (wxWindow *) 0 ;
33185 bool result;
33186 void *argp1 = 0 ;
33187 int res1 = 0 ;
33188 PyObject *swig_obj[1] ;
33189
33190 if (!args) SWIG_fail;
33191 swig_obj[0] = args;
33192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33193 if (!SWIG_IsOK(res1)) {
33194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33195 }
33196 arg1 = reinterpret_cast< wxWindow * >(argp1);
33197 {
33198 PyThreadState* __tstate = wxPyBeginAllowThreads();
33199 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33200 wxPyEndAllowThreads(__tstate);
33201 if (PyErr_Occurred()) SWIG_fail;
33202 }
33203 {
33204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33205 }
33206 return resultobj;
33207 fail:
33208 return NULL;
33209 }
33210
33211
33212 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33213 PyObject *resultobj = 0;
33214 wxWindow *arg1 = (wxWindow *) 0 ;
33215 wxString *arg2 = 0 ;
33216 void *argp1 = 0 ;
33217 int res1 = 0 ;
33218 bool temp2 = false ;
33219 PyObject * obj0 = 0 ;
33220 PyObject * obj1 = 0 ;
33221 char * kwnames[] = {
33222 (char *) "self",(char *) "label", NULL
33223 };
33224
33225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33227 if (!SWIG_IsOK(res1)) {
33228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33229 }
33230 arg1 = reinterpret_cast< wxWindow * >(argp1);
33231 {
33232 arg2 = wxString_in_helper(obj1);
33233 if (arg2 == NULL) SWIG_fail;
33234 temp2 = true;
33235 }
33236 {
33237 PyThreadState* __tstate = wxPyBeginAllowThreads();
33238 (arg1)->SetLabel((wxString const &)*arg2);
33239 wxPyEndAllowThreads(__tstate);
33240 if (PyErr_Occurred()) SWIG_fail;
33241 }
33242 resultobj = SWIG_Py_Void();
33243 {
33244 if (temp2)
33245 delete arg2;
33246 }
33247 return resultobj;
33248 fail:
33249 {
33250 if (temp2)
33251 delete arg2;
33252 }
33253 return NULL;
33254 }
33255
33256
33257 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33258 PyObject *resultobj = 0;
33259 wxWindow *arg1 = (wxWindow *) 0 ;
33260 wxString result;
33261 void *argp1 = 0 ;
33262 int res1 = 0 ;
33263 PyObject *swig_obj[1] ;
33264
33265 if (!args) SWIG_fail;
33266 swig_obj[0] = args;
33267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33268 if (!SWIG_IsOK(res1)) {
33269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33270 }
33271 arg1 = reinterpret_cast< wxWindow * >(argp1);
33272 {
33273 PyThreadState* __tstate = wxPyBeginAllowThreads();
33274 result = ((wxWindow const *)arg1)->GetLabel();
33275 wxPyEndAllowThreads(__tstate);
33276 if (PyErr_Occurred()) SWIG_fail;
33277 }
33278 {
33279 #if wxUSE_UNICODE
33280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33281 #else
33282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33283 #endif
33284 }
33285 return resultobj;
33286 fail:
33287 return NULL;
33288 }
33289
33290
33291 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33292 PyObject *resultobj = 0;
33293 wxWindow *arg1 = (wxWindow *) 0 ;
33294 wxString *arg2 = 0 ;
33295 void *argp1 = 0 ;
33296 int res1 = 0 ;
33297 bool temp2 = false ;
33298 PyObject * obj0 = 0 ;
33299 PyObject * obj1 = 0 ;
33300 char * kwnames[] = {
33301 (char *) "self",(char *) "name", NULL
33302 };
33303
33304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33306 if (!SWIG_IsOK(res1)) {
33307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33308 }
33309 arg1 = reinterpret_cast< wxWindow * >(argp1);
33310 {
33311 arg2 = wxString_in_helper(obj1);
33312 if (arg2 == NULL) SWIG_fail;
33313 temp2 = true;
33314 }
33315 {
33316 PyThreadState* __tstate = wxPyBeginAllowThreads();
33317 (arg1)->SetName((wxString const &)*arg2);
33318 wxPyEndAllowThreads(__tstate);
33319 if (PyErr_Occurred()) SWIG_fail;
33320 }
33321 resultobj = SWIG_Py_Void();
33322 {
33323 if (temp2)
33324 delete arg2;
33325 }
33326 return resultobj;
33327 fail:
33328 {
33329 if (temp2)
33330 delete arg2;
33331 }
33332 return NULL;
33333 }
33334
33335
33336 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33337 PyObject *resultobj = 0;
33338 wxWindow *arg1 = (wxWindow *) 0 ;
33339 wxString result;
33340 void *argp1 = 0 ;
33341 int res1 = 0 ;
33342 PyObject *swig_obj[1] ;
33343
33344 if (!args) SWIG_fail;
33345 swig_obj[0] = args;
33346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33347 if (!SWIG_IsOK(res1)) {
33348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33349 }
33350 arg1 = reinterpret_cast< wxWindow * >(argp1);
33351 {
33352 PyThreadState* __tstate = wxPyBeginAllowThreads();
33353 result = ((wxWindow const *)arg1)->GetName();
33354 wxPyEndAllowThreads(__tstate);
33355 if (PyErr_Occurred()) SWIG_fail;
33356 }
33357 {
33358 #if wxUSE_UNICODE
33359 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33360 #else
33361 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33362 #endif
33363 }
33364 return resultobj;
33365 fail:
33366 return NULL;
33367 }
33368
33369
33370 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33371 PyObject *resultobj = 0;
33372 wxWindow *arg1 = (wxWindow *) 0 ;
33373 wxWindowVariant arg2 ;
33374 void *argp1 = 0 ;
33375 int res1 = 0 ;
33376 int val2 ;
33377 int ecode2 = 0 ;
33378 PyObject * obj0 = 0 ;
33379 PyObject * obj1 = 0 ;
33380 char * kwnames[] = {
33381 (char *) "self",(char *) "variant", NULL
33382 };
33383
33384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33386 if (!SWIG_IsOK(res1)) {
33387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33388 }
33389 arg1 = reinterpret_cast< wxWindow * >(argp1);
33390 ecode2 = SWIG_AsVal_int(obj1, &val2);
33391 if (!SWIG_IsOK(ecode2)) {
33392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33393 }
33394 arg2 = static_cast< wxWindowVariant >(val2);
33395 {
33396 PyThreadState* __tstate = wxPyBeginAllowThreads();
33397 (arg1)->SetWindowVariant(arg2);
33398 wxPyEndAllowThreads(__tstate);
33399 if (PyErr_Occurred()) SWIG_fail;
33400 }
33401 resultobj = SWIG_Py_Void();
33402 return resultobj;
33403 fail:
33404 return NULL;
33405 }
33406
33407
33408 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33409 PyObject *resultobj = 0;
33410 wxWindow *arg1 = (wxWindow *) 0 ;
33411 wxWindowVariant result;
33412 void *argp1 = 0 ;
33413 int res1 = 0 ;
33414 PyObject *swig_obj[1] ;
33415
33416 if (!args) SWIG_fail;
33417 swig_obj[0] = args;
33418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33419 if (!SWIG_IsOK(res1)) {
33420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33421 }
33422 arg1 = reinterpret_cast< wxWindow * >(argp1);
33423 {
33424 PyThreadState* __tstate = wxPyBeginAllowThreads();
33425 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33426 wxPyEndAllowThreads(__tstate);
33427 if (PyErr_Occurred()) SWIG_fail;
33428 }
33429 resultobj = SWIG_From_int(static_cast< int >(result));
33430 return resultobj;
33431 fail:
33432 return NULL;
33433 }
33434
33435
33436 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33437 PyObject *resultobj = 0;
33438 wxWindow *arg1 = (wxWindow *) 0 ;
33439 int arg2 ;
33440 void *argp1 = 0 ;
33441 int res1 = 0 ;
33442 int val2 ;
33443 int ecode2 = 0 ;
33444 PyObject * obj0 = 0 ;
33445 PyObject * obj1 = 0 ;
33446 char * kwnames[] = {
33447 (char *) "self",(char *) "winid", NULL
33448 };
33449
33450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33452 if (!SWIG_IsOK(res1)) {
33453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33454 }
33455 arg1 = reinterpret_cast< wxWindow * >(argp1);
33456 ecode2 = SWIG_AsVal_int(obj1, &val2);
33457 if (!SWIG_IsOK(ecode2)) {
33458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33459 }
33460 arg2 = static_cast< int >(val2);
33461 {
33462 PyThreadState* __tstate = wxPyBeginAllowThreads();
33463 (arg1)->SetId(arg2);
33464 wxPyEndAllowThreads(__tstate);
33465 if (PyErr_Occurred()) SWIG_fail;
33466 }
33467 resultobj = SWIG_Py_Void();
33468 return resultobj;
33469 fail:
33470 return NULL;
33471 }
33472
33473
33474 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33475 PyObject *resultobj = 0;
33476 wxWindow *arg1 = (wxWindow *) 0 ;
33477 int result;
33478 void *argp1 = 0 ;
33479 int res1 = 0 ;
33480 PyObject *swig_obj[1] ;
33481
33482 if (!args) SWIG_fail;
33483 swig_obj[0] = args;
33484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33485 if (!SWIG_IsOK(res1)) {
33486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33487 }
33488 arg1 = reinterpret_cast< wxWindow * >(argp1);
33489 {
33490 PyThreadState* __tstate = wxPyBeginAllowThreads();
33491 result = (int)((wxWindow const *)arg1)->GetId();
33492 wxPyEndAllowThreads(__tstate);
33493 if (PyErr_Occurred()) SWIG_fail;
33494 }
33495 resultobj = SWIG_From_int(static_cast< int >(result));
33496 return resultobj;
33497 fail:
33498 return NULL;
33499 }
33500
33501
33502 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33503 PyObject *resultobj = 0;
33504 int result;
33505
33506 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33507 {
33508 PyThreadState* __tstate = wxPyBeginAllowThreads();
33509 result = (int)wxWindow::NewControlId();
33510 wxPyEndAllowThreads(__tstate);
33511 if (PyErr_Occurred()) SWIG_fail;
33512 }
33513 resultobj = SWIG_From_int(static_cast< int >(result));
33514 return resultobj;
33515 fail:
33516 return NULL;
33517 }
33518
33519
33520 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33521 PyObject *resultobj = 0;
33522 int arg1 ;
33523 int result;
33524 int val1 ;
33525 int ecode1 = 0 ;
33526 PyObject * obj0 = 0 ;
33527 char * kwnames[] = {
33528 (char *) "winid", NULL
33529 };
33530
33531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33532 ecode1 = SWIG_AsVal_int(obj0, &val1);
33533 if (!SWIG_IsOK(ecode1)) {
33534 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33535 }
33536 arg1 = static_cast< int >(val1);
33537 {
33538 PyThreadState* __tstate = wxPyBeginAllowThreads();
33539 result = (int)wxWindow::NextControlId(arg1);
33540 wxPyEndAllowThreads(__tstate);
33541 if (PyErr_Occurred()) SWIG_fail;
33542 }
33543 resultobj = SWIG_From_int(static_cast< int >(result));
33544 return resultobj;
33545 fail:
33546 return NULL;
33547 }
33548
33549
33550 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33551 PyObject *resultobj = 0;
33552 int arg1 ;
33553 int result;
33554 int val1 ;
33555 int ecode1 = 0 ;
33556 PyObject * obj0 = 0 ;
33557 char * kwnames[] = {
33558 (char *) "winid", NULL
33559 };
33560
33561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33562 ecode1 = SWIG_AsVal_int(obj0, &val1);
33563 if (!SWIG_IsOK(ecode1)) {
33564 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33565 }
33566 arg1 = static_cast< int >(val1);
33567 {
33568 PyThreadState* __tstate = wxPyBeginAllowThreads();
33569 result = (int)wxWindow::PrevControlId(arg1);
33570 wxPyEndAllowThreads(__tstate);
33571 if (PyErr_Occurred()) SWIG_fail;
33572 }
33573 resultobj = SWIG_From_int(static_cast< int >(result));
33574 return resultobj;
33575 fail:
33576 return NULL;
33577 }
33578
33579
33580 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33581 PyObject *resultobj = 0;
33582 wxWindow *arg1 = (wxWindow *) 0 ;
33583 wxLayoutDirection result;
33584 void *argp1 = 0 ;
33585 int res1 = 0 ;
33586 PyObject *swig_obj[1] ;
33587
33588 if (!args) SWIG_fail;
33589 swig_obj[0] = args;
33590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33591 if (!SWIG_IsOK(res1)) {
33592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33593 }
33594 arg1 = reinterpret_cast< wxWindow * >(argp1);
33595 {
33596 PyThreadState* __tstate = wxPyBeginAllowThreads();
33597 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33598 wxPyEndAllowThreads(__tstate);
33599 if (PyErr_Occurred()) SWIG_fail;
33600 }
33601 resultobj = SWIG_From_int(static_cast< int >(result));
33602 return resultobj;
33603 fail:
33604 return NULL;
33605 }
33606
33607
33608 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33609 PyObject *resultobj = 0;
33610 wxWindow *arg1 = (wxWindow *) 0 ;
33611 wxLayoutDirection arg2 ;
33612 void *argp1 = 0 ;
33613 int res1 = 0 ;
33614 int val2 ;
33615 int ecode2 = 0 ;
33616 PyObject * obj0 = 0 ;
33617 PyObject * obj1 = 0 ;
33618 char * kwnames[] = {
33619 (char *) "self",(char *) "dir", NULL
33620 };
33621
33622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33624 if (!SWIG_IsOK(res1)) {
33625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33626 }
33627 arg1 = reinterpret_cast< wxWindow * >(argp1);
33628 ecode2 = SWIG_AsVal_int(obj1, &val2);
33629 if (!SWIG_IsOK(ecode2)) {
33630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33631 }
33632 arg2 = static_cast< wxLayoutDirection >(val2);
33633 {
33634 PyThreadState* __tstate = wxPyBeginAllowThreads();
33635 (arg1)->SetLayoutDirection(arg2);
33636 wxPyEndAllowThreads(__tstate);
33637 if (PyErr_Occurred()) SWIG_fail;
33638 }
33639 resultobj = SWIG_Py_Void();
33640 return resultobj;
33641 fail:
33642 return NULL;
33643 }
33644
33645
33646 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33647 PyObject *resultobj = 0;
33648 wxWindow *arg1 = (wxWindow *) 0 ;
33649 int arg2 ;
33650 int arg3 ;
33651 int arg4 ;
33652 int result;
33653 void *argp1 = 0 ;
33654 int res1 = 0 ;
33655 int val2 ;
33656 int ecode2 = 0 ;
33657 int val3 ;
33658 int ecode3 = 0 ;
33659 int val4 ;
33660 int ecode4 = 0 ;
33661 PyObject * obj0 = 0 ;
33662 PyObject * obj1 = 0 ;
33663 PyObject * obj2 = 0 ;
33664 PyObject * obj3 = 0 ;
33665 char * kwnames[] = {
33666 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33667 };
33668
33669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33671 if (!SWIG_IsOK(res1)) {
33672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33673 }
33674 arg1 = reinterpret_cast< wxWindow * >(argp1);
33675 ecode2 = SWIG_AsVal_int(obj1, &val2);
33676 if (!SWIG_IsOK(ecode2)) {
33677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33678 }
33679 arg2 = static_cast< int >(val2);
33680 ecode3 = SWIG_AsVal_int(obj2, &val3);
33681 if (!SWIG_IsOK(ecode3)) {
33682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33683 }
33684 arg3 = static_cast< int >(val3);
33685 ecode4 = SWIG_AsVal_int(obj3, &val4);
33686 if (!SWIG_IsOK(ecode4)) {
33687 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33688 }
33689 arg4 = static_cast< int >(val4);
33690 {
33691 PyThreadState* __tstate = wxPyBeginAllowThreads();
33692 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33693 wxPyEndAllowThreads(__tstate);
33694 if (PyErr_Occurred()) SWIG_fail;
33695 }
33696 resultobj = SWIG_From_int(static_cast< int >(result));
33697 return resultobj;
33698 fail:
33699 return NULL;
33700 }
33701
33702
33703 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33704 PyObject *resultobj = 0;
33705 wxWindow *arg1 = (wxWindow *) 0 ;
33706 wxSize *arg2 = 0 ;
33707 void *argp1 = 0 ;
33708 int res1 = 0 ;
33709 wxSize temp2 ;
33710 PyObject * obj0 = 0 ;
33711 PyObject * obj1 = 0 ;
33712 char * kwnames[] = {
33713 (char *) "self",(char *) "size", NULL
33714 };
33715
33716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33718 if (!SWIG_IsOK(res1)) {
33719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33720 }
33721 arg1 = reinterpret_cast< wxWindow * >(argp1);
33722 {
33723 arg2 = &temp2;
33724 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33725 }
33726 {
33727 PyThreadState* __tstate = wxPyBeginAllowThreads();
33728 (arg1)->SetSize((wxSize const &)*arg2);
33729 wxPyEndAllowThreads(__tstate);
33730 if (PyErr_Occurred()) SWIG_fail;
33731 }
33732 resultobj = SWIG_Py_Void();
33733 return resultobj;
33734 fail:
33735 return NULL;
33736 }
33737
33738
33739 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33740 PyObject *resultobj = 0;
33741 wxWindow *arg1 = (wxWindow *) 0 ;
33742 int arg2 ;
33743 int arg3 ;
33744 int arg4 ;
33745 int arg5 ;
33746 int arg6 = (int) wxSIZE_AUTO ;
33747 void *argp1 = 0 ;
33748 int res1 = 0 ;
33749 int val2 ;
33750 int ecode2 = 0 ;
33751 int val3 ;
33752 int ecode3 = 0 ;
33753 int val4 ;
33754 int ecode4 = 0 ;
33755 int val5 ;
33756 int ecode5 = 0 ;
33757 int val6 ;
33758 int ecode6 = 0 ;
33759 PyObject * obj0 = 0 ;
33760 PyObject * obj1 = 0 ;
33761 PyObject * obj2 = 0 ;
33762 PyObject * obj3 = 0 ;
33763 PyObject * obj4 = 0 ;
33764 PyObject * obj5 = 0 ;
33765 char * kwnames[] = {
33766 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33767 };
33768
33769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33771 if (!SWIG_IsOK(res1)) {
33772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33773 }
33774 arg1 = reinterpret_cast< wxWindow * >(argp1);
33775 ecode2 = SWIG_AsVal_int(obj1, &val2);
33776 if (!SWIG_IsOK(ecode2)) {
33777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33778 }
33779 arg2 = static_cast< int >(val2);
33780 ecode3 = SWIG_AsVal_int(obj2, &val3);
33781 if (!SWIG_IsOK(ecode3)) {
33782 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33783 }
33784 arg3 = static_cast< int >(val3);
33785 ecode4 = SWIG_AsVal_int(obj3, &val4);
33786 if (!SWIG_IsOK(ecode4)) {
33787 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33788 }
33789 arg4 = static_cast< int >(val4);
33790 ecode5 = SWIG_AsVal_int(obj4, &val5);
33791 if (!SWIG_IsOK(ecode5)) {
33792 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33793 }
33794 arg5 = static_cast< int >(val5);
33795 if (obj5) {
33796 ecode6 = SWIG_AsVal_int(obj5, &val6);
33797 if (!SWIG_IsOK(ecode6)) {
33798 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33799 }
33800 arg6 = static_cast< int >(val6);
33801 }
33802 {
33803 PyThreadState* __tstate = wxPyBeginAllowThreads();
33804 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33805 wxPyEndAllowThreads(__tstate);
33806 if (PyErr_Occurred()) SWIG_fail;
33807 }
33808 resultobj = SWIG_Py_Void();
33809 return resultobj;
33810 fail:
33811 return NULL;
33812 }
33813
33814
33815 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33816 PyObject *resultobj = 0;
33817 wxWindow *arg1 = (wxWindow *) 0 ;
33818 wxRect *arg2 = 0 ;
33819 int arg3 = (int) wxSIZE_AUTO ;
33820 void *argp1 = 0 ;
33821 int res1 = 0 ;
33822 wxRect temp2 ;
33823 int val3 ;
33824 int ecode3 = 0 ;
33825 PyObject * obj0 = 0 ;
33826 PyObject * obj1 = 0 ;
33827 PyObject * obj2 = 0 ;
33828 char * kwnames[] = {
33829 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33830 };
33831
33832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33834 if (!SWIG_IsOK(res1)) {
33835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33836 }
33837 arg1 = reinterpret_cast< wxWindow * >(argp1);
33838 {
33839 arg2 = &temp2;
33840 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33841 }
33842 if (obj2) {
33843 ecode3 = SWIG_AsVal_int(obj2, &val3);
33844 if (!SWIG_IsOK(ecode3)) {
33845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33846 }
33847 arg3 = static_cast< int >(val3);
33848 }
33849 {
33850 PyThreadState* __tstate = wxPyBeginAllowThreads();
33851 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33852 wxPyEndAllowThreads(__tstate);
33853 if (PyErr_Occurred()) SWIG_fail;
33854 }
33855 resultobj = SWIG_Py_Void();
33856 return resultobj;
33857 fail:
33858 return NULL;
33859 }
33860
33861
33862 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33863 PyObject *resultobj = 0;
33864 wxWindow *arg1 = (wxWindow *) 0 ;
33865 int arg2 ;
33866 int arg3 ;
33867 void *argp1 = 0 ;
33868 int res1 = 0 ;
33869 int val2 ;
33870 int ecode2 = 0 ;
33871 int val3 ;
33872 int ecode3 = 0 ;
33873 PyObject * obj0 = 0 ;
33874 PyObject * obj1 = 0 ;
33875 PyObject * obj2 = 0 ;
33876 char * kwnames[] = {
33877 (char *) "self",(char *) "width",(char *) "height", NULL
33878 };
33879
33880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33882 if (!SWIG_IsOK(res1)) {
33883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33884 }
33885 arg1 = reinterpret_cast< wxWindow * >(argp1);
33886 ecode2 = SWIG_AsVal_int(obj1, &val2);
33887 if (!SWIG_IsOK(ecode2)) {
33888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33889 }
33890 arg2 = static_cast< int >(val2);
33891 ecode3 = SWIG_AsVal_int(obj2, &val3);
33892 if (!SWIG_IsOK(ecode3)) {
33893 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33894 }
33895 arg3 = static_cast< int >(val3);
33896 {
33897 PyThreadState* __tstate = wxPyBeginAllowThreads();
33898 (arg1)->SetSize(arg2,arg3);
33899 wxPyEndAllowThreads(__tstate);
33900 if (PyErr_Occurred()) SWIG_fail;
33901 }
33902 resultobj = SWIG_Py_Void();
33903 return resultobj;
33904 fail:
33905 return NULL;
33906 }
33907
33908
33909 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33910 PyObject *resultobj = 0;
33911 wxWindow *arg1 = (wxWindow *) 0 ;
33912 wxPoint *arg2 = 0 ;
33913 int arg3 = (int) wxSIZE_USE_EXISTING ;
33914 void *argp1 = 0 ;
33915 int res1 = 0 ;
33916 wxPoint temp2 ;
33917 int val3 ;
33918 int ecode3 = 0 ;
33919 PyObject * obj0 = 0 ;
33920 PyObject * obj1 = 0 ;
33921 PyObject * obj2 = 0 ;
33922 char * kwnames[] = {
33923 (char *) "self",(char *) "pt",(char *) "flags", NULL
33924 };
33925
33926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33928 if (!SWIG_IsOK(res1)) {
33929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33930 }
33931 arg1 = reinterpret_cast< wxWindow * >(argp1);
33932 {
33933 arg2 = &temp2;
33934 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33935 }
33936 if (obj2) {
33937 ecode3 = SWIG_AsVal_int(obj2, &val3);
33938 if (!SWIG_IsOK(ecode3)) {
33939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33940 }
33941 arg3 = static_cast< int >(val3);
33942 }
33943 {
33944 PyThreadState* __tstate = wxPyBeginAllowThreads();
33945 (arg1)->Move((wxPoint const &)*arg2,arg3);
33946 wxPyEndAllowThreads(__tstate);
33947 if (PyErr_Occurred()) SWIG_fail;
33948 }
33949 resultobj = SWIG_Py_Void();
33950 return resultobj;
33951 fail:
33952 return NULL;
33953 }
33954
33955
33956 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33957 PyObject *resultobj = 0;
33958 wxWindow *arg1 = (wxWindow *) 0 ;
33959 int arg2 ;
33960 int arg3 ;
33961 int arg4 = (int) wxSIZE_USE_EXISTING ;
33962 void *argp1 = 0 ;
33963 int res1 = 0 ;
33964 int val2 ;
33965 int ecode2 = 0 ;
33966 int val3 ;
33967 int ecode3 = 0 ;
33968 int val4 ;
33969 int ecode4 = 0 ;
33970 PyObject * obj0 = 0 ;
33971 PyObject * obj1 = 0 ;
33972 PyObject * obj2 = 0 ;
33973 PyObject * obj3 = 0 ;
33974 char * kwnames[] = {
33975 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33976 };
33977
33978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33980 if (!SWIG_IsOK(res1)) {
33981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33982 }
33983 arg1 = reinterpret_cast< wxWindow * >(argp1);
33984 ecode2 = SWIG_AsVal_int(obj1, &val2);
33985 if (!SWIG_IsOK(ecode2)) {
33986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33987 }
33988 arg2 = static_cast< int >(val2);
33989 ecode3 = SWIG_AsVal_int(obj2, &val3);
33990 if (!SWIG_IsOK(ecode3)) {
33991 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33992 }
33993 arg3 = static_cast< int >(val3);
33994 if (obj3) {
33995 ecode4 = SWIG_AsVal_int(obj3, &val4);
33996 if (!SWIG_IsOK(ecode4)) {
33997 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33998 }
33999 arg4 = static_cast< int >(val4);
34000 }
34001 {
34002 PyThreadState* __tstate = wxPyBeginAllowThreads();
34003 (arg1)->Move(arg2,arg3,arg4);
34004 wxPyEndAllowThreads(__tstate);
34005 if (PyErr_Occurred()) SWIG_fail;
34006 }
34007 resultobj = SWIG_Py_Void();
34008 return resultobj;
34009 fail:
34010 return NULL;
34011 }
34012
34013
34014 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34015 PyObject *resultobj = 0;
34016 wxWindow *arg1 = (wxWindow *) 0 ;
34017 wxSize const &arg2_defvalue = wxDefaultSize ;
34018 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
34019 void *argp1 = 0 ;
34020 int res1 = 0 ;
34021 wxSize temp2 ;
34022 PyObject * obj0 = 0 ;
34023 PyObject * obj1 = 0 ;
34024 char * kwnames[] = {
34025 (char *) "self",(char *) "size", NULL
34026 };
34027
34028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
34029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34030 if (!SWIG_IsOK(res1)) {
34031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34032 }
34033 arg1 = reinterpret_cast< wxWindow * >(argp1);
34034 if (obj1) {
34035 {
34036 arg2 = &temp2;
34037 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34038 }
34039 }
34040 {
34041 PyThreadState* __tstate = wxPyBeginAllowThreads();
34042 (arg1)->SetInitialSize((wxSize const &)*arg2);
34043 wxPyEndAllowThreads(__tstate);
34044 if (PyErr_Occurred()) SWIG_fail;
34045 }
34046 resultobj = SWIG_Py_Void();
34047 return resultobj;
34048 fail:
34049 return NULL;
34050 }
34051
34052
34053 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34054 PyObject *resultobj = 0;
34055 wxWindow *arg1 = (wxWindow *) 0 ;
34056 void *argp1 = 0 ;
34057 int res1 = 0 ;
34058 PyObject *swig_obj[1] ;
34059
34060 if (!args) SWIG_fail;
34061 swig_obj[0] = args;
34062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34063 if (!SWIG_IsOK(res1)) {
34064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
34065 }
34066 arg1 = reinterpret_cast< wxWindow * >(argp1);
34067 {
34068 PyThreadState* __tstate = wxPyBeginAllowThreads();
34069 (arg1)->Raise();
34070 wxPyEndAllowThreads(__tstate);
34071 if (PyErr_Occurred()) SWIG_fail;
34072 }
34073 resultobj = SWIG_Py_Void();
34074 return resultobj;
34075 fail:
34076 return NULL;
34077 }
34078
34079
34080 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34081 PyObject *resultobj = 0;
34082 wxWindow *arg1 = (wxWindow *) 0 ;
34083 void *argp1 = 0 ;
34084 int res1 = 0 ;
34085 PyObject *swig_obj[1] ;
34086
34087 if (!args) SWIG_fail;
34088 swig_obj[0] = args;
34089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34090 if (!SWIG_IsOK(res1)) {
34091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
34092 }
34093 arg1 = reinterpret_cast< wxWindow * >(argp1);
34094 {
34095 PyThreadState* __tstate = wxPyBeginAllowThreads();
34096 (arg1)->Lower();
34097 wxPyEndAllowThreads(__tstate);
34098 if (PyErr_Occurred()) SWIG_fail;
34099 }
34100 resultobj = SWIG_Py_Void();
34101 return resultobj;
34102 fail:
34103 return NULL;
34104 }
34105
34106
34107 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34108 PyObject *resultobj = 0;
34109 wxWindow *arg1 = (wxWindow *) 0 ;
34110 wxSize *arg2 = 0 ;
34111 void *argp1 = 0 ;
34112 int res1 = 0 ;
34113 wxSize temp2 ;
34114 PyObject * obj0 = 0 ;
34115 PyObject * obj1 = 0 ;
34116 char * kwnames[] = {
34117 (char *) "self",(char *) "size", NULL
34118 };
34119
34120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
34121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34122 if (!SWIG_IsOK(res1)) {
34123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34124 }
34125 arg1 = reinterpret_cast< wxWindow * >(argp1);
34126 {
34127 arg2 = &temp2;
34128 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34129 }
34130 {
34131 PyThreadState* __tstate = wxPyBeginAllowThreads();
34132 (arg1)->SetClientSize((wxSize const &)*arg2);
34133 wxPyEndAllowThreads(__tstate);
34134 if (PyErr_Occurred()) SWIG_fail;
34135 }
34136 resultobj = SWIG_Py_Void();
34137 return resultobj;
34138 fail:
34139 return NULL;
34140 }
34141
34142
34143 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34144 PyObject *resultobj = 0;
34145 wxWindow *arg1 = (wxWindow *) 0 ;
34146 int arg2 ;
34147 int arg3 ;
34148 void *argp1 = 0 ;
34149 int res1 = 0 ;
34150 int val2 ;
34151 int ecode2 = 0 ;
34152 int val3 ;
34153 int ecode3 = 0 ;
34154 PyObject * obj0 = 0 ;
34155 PyObject * obj1 = 0 ;
34156 PyObject * obj2 = 0 ;
34157 char * kwnames[] = {
34158 (char *) "self",(char *) "width",(char *) "height", NULL
34159 };
34160
34161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34163 if (!SWIG_IsOK(res1)) {
34164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34165 }
34166 arg1 = reinterpret_cast< wxWindow * >(argp1);
34167 ecode2 = SWIG_AsVal_int(obj1, &val2);
34168 if (!SWIG_IsOK(ecode2)) {
34169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34170 }
34171 arg2 = static_cast< int >(val2);
34172 ecode3 = SWIG_AsVal_int(obj2, &val3);
34173 if (!SWIG_IsOK(ecode3)) {
34174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34175 }
34176 arg3 = static_cast< int >(val3);
34177 {
34178 PyThreadState* __tstate = wxPyBeginAllowThreads();
34179 (arg1)->SetClientSize(arg2,arg3);
34180 wxPyEndAllowThreads(__tstate);
34181 if (PyErr_Occurred()) SWIG_fail;
34182 }
34183 resultobj = SWIG_Py_Void();
34184 return resultobj;
34185 fail:
34186 return NULL;
34187 }
34188
34189
34190 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34191 PyObject *resultobj = 0;
34192 wxWindow *arg1 = (wxWindow *) 0 ;
34193 wxRect *arg2 = 0 ;
34194 void *argp1 = 0 ;
34195 int res1 = 0 ;
34196 wxRect temp2 ;
34197 PyObject * obj0 = 0 ;
34198 PyObject * obj1 = 0 ;
34199 char * kwnames[] = {
34200 (char *) "self",(char *) "rect", NULL
34201 };
34202
34203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34205 if (!SWIG_IsOK(res1)) {
34206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34207 }
34208 arg1 = reinterpret_cast< wxWindow * >(argp1);
34209 {
34210 arg2 = &temp2;
34211 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34212 }
34213 {
34214 PyThreadState* __tstate = wxPyBeginAllowThreads();
34215 (arg1)->SetClientSize((wxRect const &)*arg2);
34216 wxPyEndAllowThreads(__tstate);
34217 if (PyErr_Occurred()) SWIG_fail;
34218 }
34219 resultobj = SWIG_Py_Void();
34220 return resultobj;
34221 fail:
34222 return NULL;
34223 }
34224
34225
34226 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34227 PyObject *resultobj = 0;
34228 wxWindow *arg1 = (wxWindow *) 0 ;
34229 wxPoint result;
34230 void *argp1 = 0 ;
34231 int res1 = 0 ;
34232 PyObject *swig_obj[1] ;
34233
34234 if (!args) SWIG_fail;
34235 swig_obj[0] = args;
34236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34237 if (!SWIG_IsOK(res1)) {
34238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34239 }
34240 arg1 = reinterpret_cast< wxWindow * >(argp1);
34241 {
34242 PyThreadState* __tstate = wxPyBeginAllowThreads();
34243 result = ((wxWindow const *)arg1)->GetPosition();
34244 wxPyEndAllowThreads(__tstate);
34245 if (PyErr_Occurred()) SWIG_fail;
34246 }
34247 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34248 return resultobj;
34249 fail:
34250 return NULL;
34251 }
34252
34253
34254 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34255 PyObject *resultobj = 0;
34256 wxWindow *arg1 = (wxWindow *) 0 ;
34257 int *arg2 = (int *) 0 ;
34258 int *arg3 = (int *) 0 ;
34259 void *argp1 = 0 ;
34260 int res1 = 0 ;
34261 int temp2 ;
34262 int res2 = SWIG_TMPOBJ ;
34263 int temp3 ;
34264 int res3 = SWIG_TMPOBJ ;
34265 PyObject *swig_obj[1] ;
34266
34267 arg2 = &temp2;
34268 arg3 = &temp3;
34269 if (!args) SWIG_fail;
34270 swig_obj[0] = args;
34271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34272 if (!SWIG_IsOK(res1)) {
34273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34274 }
34275 arg1 = reinterpret_cast< wxWindow * >(argp1);
34276 {
34277 PyThreadState* __tstate = wxPyBeginAllowThreads();
34278 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34279 wxPyEndAllowThreads(__tstate);
34280 if (PyErr_Occurred()) SWIG_fail;
34281 }
34282 resultobj = SWIG_Py_Void();
34283 if (SWIG_IsTmpObj(res2)) {
34284 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34285 } else {
34286 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34287 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34288 }
34289 if (SWIG_IsTmpObj(res3)) {
34290 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34291 } else {
34292 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34293 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34294 }
34295 return resultobj;
34296 fail:
34297 return NULL;
34298 }
34299
34300
34301 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34302 PyObject *resultobj = 0;
34303 wxWindow *arg1 = (wxWindow *) 0 ;
34304 wxPoint result;
34305 void *argp1 = 0 ;
34306 int res1 = 0 ;
34307 PyObject *swig_obj[1] ;
34308
34309 if (!args) SWIG_fail;
34310 swig_obj[0] = args;
34311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34312 if (!SWIG_IsOK(res1)) {
34313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34314 }
34315 arg1 = reinterpret_cast< wxWindow * >(argp1);
34316 {
34317 PyThreadState* __tstate = wxPyBeginAllowThreads();
34318 result = ((wxWindow const *)arg1)->GetScreenPosition();
34319 wxPyEndAllowThreads(__tstate);
34320 if (PyErr_Occurred()) SWIG_fail;
34321 }
34322 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34323 return resultobj;
34324 fail:
34325 return NULL;
34326 }
34327
34328
34329 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34330 PyObject *resultobj = 0;
34331 wxWindow *arg1 = (wxWindow *) 0 ;
34332 int *arg2 = (int *) 0 ;
34333 int *arg3 = (int *) 0 ;
34334 void *argp1 = 0 ;
34335 int res1 = 0 ;
34336 int temp2 ;
34337 int res2 = SWIG_TMPOBJ ;
34338 int temp3 ;
34339 int res3 = SWIG_TMPOBJ ;
34340 PyObject *swig_obj[1] ;
34341
34342 arg2 = &temp2;
34343 arg3 = &temp3;
34344 if (!args) SWIG_fail;
34345 swig_obj[0] = args;
34346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34347 if (!SWIG_IsOK(res1)) {
34348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34349 }
34350 arg1 = reinterpret_cast< wxWindow * >(argp1);
34351 {
34352 PyThreadState* __tstate = wxPyBeginAllowThreads();
34353 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34354 wxPyEndAllowThreads(__tstate);
34355 if (PyErr_Occurred()) SWIG_fail;
34356 }
34357 resultobj = SWIG_Py_Void();
34358 if (SWIG_IsTmpObj(res2)) {
34359 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34360 } else {
34361 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34362 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34363 }
34364 if (SWIG_IsTmpObj(res3)) {
34365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34366 } else {
34367 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34369 }
34370 return resultobj;
34371 fail:
34372 return NULL;
34373 }
34374
34375
34376 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34377 PyObject *resultobj = 0;
34378 wxWindow *arg1 = (wxWindow *) 0 ;
34379 wxRect result;
34380 void *argp1 = 0 ;
34381 int res1 = 0 ;
34382 PyObject *swig_obj[1] ;
34383
34384 if (!args) SWIG_fail;
34385 swig_obj[0] = args;
34386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34387 if (!SWIG_IsOK(res1)) {
34388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34389 }
34390 arg1 = reinterpret_cast< wxWindow * >(argp1);
34391 {
34392 PyThreadState* __tstate = wxPyBeginAllowThreads();
34393 result = ((wxWindow const *)arg1)->GetScreenRect();
34394 wxPyEndAllowThreads(__tstate);
34395 if (PyErr_Occurred()) SWIG_fail;
34396 }
34397 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34398 return resultobj;
34399 fail:
34400 return NULL;
34401 }
34402
34403
34404 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34405 PyObject *resultobj = 0;
34406 wxWindow *arg1 = (wxWindow *) 0 ;
34407 wxSize result;
34408 void *argp1 = 0 ;
34409 int res1 = 0 ;
34410 PyObject *swig_obj[1] ;
34411
34412 if (!args) SWIG_fail;
34413 swig_obj[0] = args;
34414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34415 if (!SWIG_IsOK(res1)) {
34416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34417 }
34418 arg1 = reinterpret_cast< wxWindow * >(argp1);
34419 {
34420 PyThreadState* __tstate = wxPyBeginAllowThreads();
34421 result = ((wxWindow const *)arg1)->GetSize();
34422 wxPyEndAllowThreads(__tstate);
34423 if (PyErr_Occurred()) SWIG_fail;
34424 }
34425 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34426 return resultobj;
34427 fail:
34428 return NULL;
34429 }
34430
34431
34432 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34433 PyObject *resultobj = 0;
34434 wxWindow *arg1 = (wxWindow *) 0 ;
34435 int *arg2 = (int *) 0 ;
34436 int *arg3 = (int *) 0 ;
34437 void *argp1 = 0 ;
34438 int res1 = 0 ;
34439 int temp2 ;
34440 int res2 = SWIG_TMPOBJ ;
34441 int temp3 ;
34442 int res3 = SWIG_TMPOBJ ;
34443 PyObject *swig_obj[1] ;
34444
34445 arg2 = &temp2;
34446 arg3 = &temp3;
34447 if (!args) SWIG_fail;
34448 swig_obj[0] = args;
34449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34450 if (!SWIG_IsOK(res1)) {
34451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34452 }
34453 arg1 = reinterpret_cast< wxWindow * >(argp1);
34454 {
34455 PyThreadState* __tstate = wxPyBeginAllowThreads();
34456 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34457 wxPyEndAllowThreads(__tstate);
34458 if (PyErr_Occurred()) SWIG_fail;
34459 }
34460 resultobj = SWIG_Py_Void();
34461 if (SWIG_IsTmpObj(res2)) {
34462 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34463 } else {
34464 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34465 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34466 }
34467 if (SWIG_IsTmpObj(res3)) {
34468 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34469 } else {
34470 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34471 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34472 }
34473 return resultobj;
34474 fail:
34475 return NULL;
34476 }
34477
34478
34479 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34480 PyObject *resultobj = 0;
34481 wxWindow *arg1 = (wxWindow *) 0 ;
34482 wxRect result;
34483 void *argp1 = 0 ;
34484 int res1 = 0 ;
34485 PyObject *swig_obj[1] ;
34486
34487 if (!args) SWIG_fail;
34488 swig_obj[0] = args;
34489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34490 if (!SWIG_IsOK(res1)) {
34491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34492 }
34493 arg1 = reinterpret_cast< wxWindow * >(argp1);
34494 {
34495 PyThreadState* __tstate = wxPyBeginAllowThreads();
34496 result = ((wxWindow const *)arg1)->GetRect();
34497 wxPyEndAllowThreads(__tstate);
34498 if (PyErr_Occurred()) SWIG_fail;
34499 }
34500 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34501 return resultobj;
34502 fail:
34503 return NULL;
34504 }
34505
34506
34507 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34508 PyObject *resultobj = 0;
34509 wxWindow *arg1 = (wxWindow *) 0 ;
34510 wxSize result;
34511 void *argp1 = 0 ;
34512 int res1 = 0 ;
34513 PyObject *swig_obj[1] ;
34514
34515 if (!args) SWIG_fail;
34516 swig_obj[0] = args;
34517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34518 if (!SWIG_IsOK(res1)) {
34519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34520 }
34521 arg1 = reinterpret_cast< wxWindow * >(argp1);
34522 {
34523 PyThreadState* __tstate = wxPyBeginAllowThreads();
34524 result = ((wxWindow const *)arg1)->GetClientSize();
34525 wxPyEndAllowThreads(__tstate);
34526 if (PyErr_Occurred()) SWIG_fail;
34527 }
34528 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34529 return resultobj;
34530 fail:
34531 return NULL;
34532 }
34533
34534
34535 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34536 PyObject *resultobj = 0;
34537 wxWindow *arg1 = (wxWindow *) 0 ;
34538 int *arg2 = (int *) 0 ;
34539 int *arg3 = (int *) 0 ;
34540 void *argp1 = 0 ;
34541 int res1 = 0 ;
34542 int temp2 ;
34543 int res2 = SWIG_TMPOBJ ;
34544 int temp3 ;
34545 int res3 = SWIG_TMPOBJ ;
34546 PyObject *swig_obj[1] ;
34547
34548 arg2 = &temp2;
34549 arg3 = &temp3;
34550 if (!args) SWIG_fail;
34551 swig_obj[0] = args;
34552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34553 if (!SWIG_IsOK(res1)) {
34554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34555 }
34556 arg1 = reinterpret_cast< wxWindow * >(argp1);
34557 {
34558 PyThreadState* __tstate = wxPyBeginAllowThreads();
34559 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34560 wxPyEndAllowThreads(__tstate);
34561 if (PyErr_Occurred()) SWIG_fail;
34562 }
34563 resultobj = SWIG_Py_Void();
34564 if (SWIG_IsTmpObj(res2)) {
34565 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34566 } else {
34567 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34568 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34569 }
34570 if (SWIG_IsTmpObj(res3)) {
34571 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34572 } else {
34573 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34574 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34575 }
34576 return resultobj;
34577 fail:
34578 return NULL;
34579 }
34580
34581
34582 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34583 PyObject *resultobj = 0;
34584 wxWindow *arg1 = (wxWindow *) 0 ;
34585 wxPoint result;
34586 void *argp1 = 0 ;
34587 int res1 = 0 ;
34588 PyObject *swig_obj[1] ;
34589
34590 if (!args) SWIG_fail;
34591 swig_obj[0] = args;
34592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34593 if (!SWIG_IsOK(res1)) {
34594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34595 }
34596 arg1 = reinterpret_cast< wxWindow * >(argp1);
34597 {
34598 PyThreadState* __tstate = wxPyBeginAllowThreads();
34599 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34600 wxPyEndAllowThreads(__tstate);
34601 if (PyErr_Occurred()) SWIG_fail;
34602 }
34603 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34604 return resultobj;
34605 fail:
34606 return NULL;
34607 }
34608
34609
34610 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34611 PyObject *resultobj = 0;
34612 wxWindow *arg1 = (wxWindow *) 0 ;
34613 wxRect result;
34614 void *argp1 = 0 ;
34615 int res1 = 0 ;
34616 PyObject *swig_obj[1] ;
34617
34618 if (!args) SWIG_fail;
34619 swig_obj[0] = args;
34620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34621 if (!SWIG_IsOK(res1)) {
34622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34623 }
34624 arg1 = reinterpret_cast< wxWindow * >(argp1);
34625 {
34626 PyThreadState* __tstate = wxPyBeginAllowThreads();
34627 result = ((wxWindow const *)arg1)->GetClientRect();
34628 wxPyEndAllowThreads(__tstate);
34629 if (PyErr_Occurred()) SWIG_fail;
34630 }
34631 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34632 return resultobj;
34633 fail:
34634 return NULL;
34635 }
34636
34637
34638 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34639 PyObject *resultobj = 0;
34640 wxWindow *arg1 = (wxWindow *) 0 ;
34641 wxSize result;
34642 void *argp1 = 0 ;
34643 int res1 = 0 ;
34644 PyObject *swig_obj[1] ;
34645
34646 if (!args) SWIG_fail;
34647 swig_obj[0] = args;
34648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34649 if (!SWIG_IsOK(res1)) {
34650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34651 }
34652 arg1 = reinterpret_cast< wxWindow * >(argp1);
34653 {
34654 PyThreadState* __tstate = wxPyBeginAllowThreads();
34655 result = ((wxWindow const *)arg1)->GetBestSize();
34656 wxPyEndAllowThreads(__tstate);
34657 if (PyErr_Occurred()) SWIG_fail;
34658 }
34659 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34660 return resultobj;
34661 fail:
34662 return NULL;
34663 }
34664
34665
34666 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34667 PyObject *resultobj = 0;
34668 wxWindow *arg1 = (wxWindow *) 0 ;
34669 int *arg2 = (int *) 0 ;
34670 int *arg3 = (int *) 0 ;
34671 void *argp1 = 0 ;
34672 int res1 = 0 ;
34673 int temp2 ;
34674 int res2 = SWIG_TMPOBJ ;
34675 int temp3 ;
34676 int res3 = SWIG_TMPOBJ ;
34677 PyObject *swig_obj[1] ;
34678
34679 arg2 = &temp2;
34680 arg3 = &temp3;
34681 if (!args) SWIG_fail;
34682 swig_obj[0] = args;
34683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34684 if (!SWIG_IsOK(res1)) {
34685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34686 }
34687 arg1 = reinterpret_cast< wxWindow * >(argp1);
34688 {
34689 PyThreadState* __tstate = wxPyBeginAllowThreads();
34690 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34691 wxPyEndAllowThreads(__tstate);
34692 if (PyErr_Occurred()) SWIG_fail;
34693 }
34694 resultobj = SWIG_Py_Void();
34695 if (SWIG_IsTmpObj(res2)) {
34696 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34697 } else {
34698 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34700 }
34701 if (SWIG_IsTmpObj(res3)) {
34702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34703 } else {
34704 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34705 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34706 }
34707 return resultobj;
34708 fail:
34709 return NULL;
34710 }
34711
34712
34713 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34714 PyObject *resultobj = 0;
34715 wxWindow *arg1 = (wxWindow *) 0 ;
34716 void *argp1 = 0 ;
34717 int res1 = 0 ;
34718 PyObject *swig_obj[1] ;
34719
34720 if (!args) SWIG_fail;
34721 swig_obj[0] = args;
34722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34723 if (!SWIG_IsOK(res1)) {
34724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34725 }
34726 arg1 = reinterpret_cast< wxWindow * >(argp1);
34727 {
34728 PyThreadState* __tstate = wxPyBeginAllowThreads();
34729 (arg1)->InvalidateBestSize();
34730 wxPyEndAllowThreads(__tstate);
34731 if (PyErr_Occurred()) SWIG_fail;
34732 }
34733 resultobj = SWIG_Py_Void();
34734 return resultobj;
34735 fail:
34736 return NULL;
34737 }
34738
34739
34740 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34741 PyObject *resultobj = 0;
34742 wxWindow *arg1 = (wxWindow *) 0 ;
34743 wxSize *arg2 = 0 ;
34744 void *argp1 = 0 ;
34745 int res1 = 0 ;
34746 wxSize temp2 ;
34747 PyObject * obj0 = 0 ;
34748 PyObject * obj1 = 0 ;
34749 char * kwnames[] = {
34750 (char *) "self",(char *) "size", NULL
34751 };
34752
34753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34755 if (!SWIG_IsOK(res1)) {
34756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34757 }
34758 arg1 = reinterpret_cast< wxWindow * >(argp1);
34759 {
34760 arg2 = &temp2;
34761 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34762 }
34763 {
34764 PyThreadState* __tstate = wxPyBeginAllowThreads();
34765 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34766 wxPyEndAllowThreads(__tstate);
34767 if (PyErr_Occurred()) SWIG_fail;
34768 }
34769 resultobj = SWIG_Py_Void();
34770 return resultobj;
34771 fail:
34772 return NULL;
34773 }
34774
34775
34776 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34777 PyObject *resultobj = 0;
34778 wxWindow *arg1 = (wxWindow *) 0 ;
34779 wxSize result;
34780 void *argp1 = 0 ;
34781 int res1 = 0 ;
34782 PyObject *swig_obj[1] ;
34783
34784 if (!args) SWIG_fail;
34785 swig_obj[0] = args;
34786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34787 if (!SWIG_IsOK(res1)) {
34788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34789 }
34790 arg1 = reinterpret_cast< wxWindow * >(argp1);
34791 {
34792 PyThreadState* __tstate = wxPyBeginAllowThreads();
34793 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34794 wxPyEndAllowThreads(__tstate);
34795 if (PyErr_Occurred()) SWIG_fail;
34796 }
34797 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34798 return resultobj;
34799 fail:
34800 return NULL;
34801 }
34802
34803
34804 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34805 PyObject *resultobj = 0;
34806 wxWindow *arg1 = (wxWindow *) 0 ;
34807 int arg2 = (int) wxBOTH ;
34808 void *argp1 = 0 ;
34809 int res1 = 0 ;
34810 int val2 ;
34811 int ecode2 = 0 ;
34812 PyObject * obj0 = 0 ;
34813 PyObject * obj1 = 0 ;
34814 char * kwnames[] = {
34815 (char *) "self",(char *) "direction", NULL
34816 };
34817
34818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34820 if (!SWIG_IsOK(res1)) {
34821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34822 }
34823 arg1 = reinterpret_cast< wxWindow * >(argp1);
34824 if (obj1) {
34825 ecode2 = SWIG_AsVal_int(obj1, &val2);
34826 if (!SWIG_IsOK(ecode2)) {
34827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34828 }
34829 arg2 = static_cast< int >(val2);
34830 }
34831 {
34832 PyThreadState* __tstate = wxPyBeginAllowThreads();
34833 (arg1)->Center(arg2);
34834 wxPyEndAllowThreads(__tstate);
34835 if (PyErr_Occurred()) SWIG_fail;
34836 }
34837 resultobj = SWIG_Py_Void();
34838 return resultobj;
34839 fail:
34840 return NULL;
34841 }
34842
34843
34844 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34845 PyObject *resultobj = 0;
34846 wxWindow *arg1 = (wxWindow *) 0 ;
34847 int arg2 = (int) wxBOTH ;
34848 void *argp1 = 0 ;
34849 int res1 = 0 ;
34850 int val2 ;
34851 int ecode2 = 0 ;
34852 PyObject * obj0 = 0 ;
34853 PyObject * obj1 = 0 ;
34854 char * kwnames[] = {
34855 (char *) "self",(char *) "dir", NULL
34856 };
34857
34858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34860 if (!SWIG_IsOK(res1)) {
34861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34862 }
34863 arg1 = reinterpret_cast< wxWindow * >(argp1);
34864 if (obj1) {
34865 ecode2 = SWIG_AsVal_int(obj1, &val2);
34866 if (!SWIG_IsOK(ecode2)) {
34867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34868 }
34869 arg2 = static_cast< int >(val2);
34870 }
34871 {
34872 PyThreadState* __tstate = wxPyBeginAllowThreads();
34873 (arg1)->CenterOnParent(arg2);
34874 wxPyEndAllowThreads(__tstate);
34875 if (PyErr_Occurred()) SWIG_fail;
34876 }
34877 resultobj = SWIG_Py_Void();
34878 return resultobj;
34879 fail:
34880 return NULL;
34881 }
34882
34883
34884 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34885 PyObject *resultobj = 0;
34886 wxWindow *arg1 = (wxWindow *) 0 ;
34887 void *argp1 = 0 ;
34888 int res1 = 0 ;
34889 PyObject *swig_obj[1] ;
34890
34891 if (!args) SWIG_fail;
34892 swig_obj[0] = args;
34893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34894 if (!SWIG_IsOK(res1)) {
34895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34896 }
34897 arg1 = reinterpret_cast< wxWindow * >(argp1);
34898 {
34899 PyThreadState* __tstate = wxPyBeginAllowThreads();
34900 (arg1)->Fit();
34901 wxPyEndAllowThreads(__tstate);
34902 if (PyErr_Occurred()) SWIG_fail;
34903 }
34904 resultobj = SWIG_Py_Void();
34905 return resultobj;
34906 fail:
34907 return NULL;
34908 }
34909
34910
34911 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34912 PyObject *resultobj = 0;
34913 wxWindow *arg1 = (wxWindow *) 0 ;
34914 void *argp1 = 0 ;
34915 int res1 = 0 ;
34916 PyObject *swig_obj[1] ;
34917
34918 if (!args) SWIG_fail;
34919 swig_obj[0] = args;
34920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34921 if (!SWIG_IsOK(res1)) {
34922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34923 }
34924 arg1 = reinterpret_cast< wxWindow * >(argp1);
34925 {
34926 PyThreadState* __tstate = wxPyBeginAllowThreads();
34927 (arg1)->FitInside();
34928 wxPyEndAllowThreads(__tstate);
34929 if (PyErr_Occurred()) SWIG_fail;
34930 }
34931 resultobj = SWIG_Py_Void();
34932 return resultobj;
34933 fail:
34934 return NULL;
34935 }
34936
34937
34938 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34939 PyObject *resultobj = 0;
34940 wxWindow *arg1 = (wxWindow *) 0 ;
34941 int arg2 ;
34942 int arg3 ;
34943 int arg4 = (int) -1 ;
34944 int arg5 = (int) -1 ;
34945 int arg6 = (int) -1 ;
34946 int arg7 = (int) -1 ;
34947 void *argp1 = 0 ;
34948 int res1 = 0 ;
34949 int val2 ;
34950 int ecode2 = 0 ;
34951 int val3 ;
34952 int ecode3 = 0 ;
34953 int val4 ;
34954 int ecode4 = 0 ;
34955 int val5 ;
34956 int ecode5 = 0 ;
34957 int val6 ;
34958 int ecode6 = 0 ;
34959 int val7 ;
34960 int ecode7 = 0 ;
34961 PyObject * obj0 = 0 ;
34962 PyObject * obj1 = 0 ;
34963 PyObject * obj2 = 0 ;
34964 PyObject * obj3 = 0 ;
34965 PyObject * obj4 = 0 ;
34966 PyObject * obj5 = 0 ;
34967 PyObject * obj6 = 0 ;
34968 char * kwnames[] = {
34969 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34970 };
34971
34972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34974 if (!SWIG_IsOK(res1)) {
34975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34976 }
34977 arg1 = reinterpret_cast< wxWindow * >(argp1);
34978 ecode2 = SWIG_AsVal_int(obj1, &val2);
34979 if (!SWIG_IsOK(ecode2)) {
34980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34981 }
34982 arg2 = static_cast< int >(val2);
34983 ecode3 = SWIG_AsVal_int(obj2, &val3);
34984 if (!SWIG_IsOK(ecode3)) {
34985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34986 }
34987 arg3 = static_cast< int >(val3);
34988 if (obj3) {
34989 ecode4 = SWIG_AsVal_int(obj3, &val4);
34990 if (!SWIG_IsOK(ecode4)) {
34991 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34992 }
34993 arg4 = static_cast< int >(val4);
34994 }
34995 if (obj4) {
34996 ecode5 = SWIG_AsVal_int(obj4, &val5);
34997 if (!SWIG_IsOK(ecode5)) {
34998 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34999 }
35000 arg5 = static_cast< int >(val5);
35001 }
35002 if (obj5) {
35003 ecode6 = SWIG_AsVal_int(obj5, &val6);
35004 if (!SWIG_IsOK(ecode6)) {
35005 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
35006 }
35007 arg6 = static_cast< int >(val6);
35008 }
35009 if (obj6) {
35010 ecode7 = SWIG_AsVal_int(obj6, &val7);
35011 if (!SWIG_IsOK(ecode7)) {
35012 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
35013 }
35014 arg7 = static_cast< int >(val7);
35015 }
35016 {
35017 PyThreadState* __tstate = wxPyBeginAllowThreads();
35018 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
35019 wxPyEndAllowThreads(__tstate);
35020 if (PyErr_Occurred()) SWIG_fail;
35021 }
35022 resultobj = SWIG_Py_Void();
35023 return resultobj;
35024 fail:
35025 return NULL;
35026 }
35027
35028
35029 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35030 PyObject *resultobj = 0;
35031 wxWindow *arg1 = (wxWindow *) 0 ;
35032 wxSize *arg2 = 0 ;
35033 wxSize const &arg3_defvalue = wxDefaultSize ;
35034 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35035 wxSize const &arg4_defvalue = wxDefaultSize ;
35036 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
35037 void *argp1 = 0 ;
35038 int res1 = 0 ;
35039 wxSize temp2 ;
35040 wxSize temp3 ;
35041 wxSize temp4 ;
35042 PyObject * obj0 = 0 ;
35043 PyObject * obj1 = 0 ;
35044 PyObject * obj2 = 0 ;
35045 PyObject * obj3 = 0 ;
35046 char * kwnames[] = {
35047 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
35048 };
35049
35050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35052 if (!SWIG_IsOK(res1)) {
35053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35054 }
35055 arg1 = reinterpret_cast< wxWindow * >(argp1);
35056 {
35057 arg2 = &temp2;
35058 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35059 }
35060 if (obj2) {
35061 {
35062 arg3 = &temp3;
35063 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35064 }
35065 }
35066 if (obj3) {
35067 {
35068 arg4 = &temp4;
35069 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
35070 }
35071 }
35072 {
35073 PyThreadState* __tstate = wxPyBeginAllowThreads();
35074 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
35075 wxPyEndAllowThreads(__tstate);
35076 if (PyErr_Occurred()) SWIG_fail;
35077 }
35078 resultobj = SWIG_Py_Void();
35079 return resultobj;
35080 fail:
35081 return NULL;
35082 }
35083
35084
35085 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35086 PyObject *resultobj = 0;
35087 wxWindow *arg1 = (wxWindow *) 0 ;
35088 int arg2 ;
35089 int arg3 ;
35090 int arg4 = (int) -1 ;
35091 int arg5 = (int) -1 ;
35092 void *argp1 = 0 ;
35093 int res1 = 0 ;
35094 int val2 ;
35095 int ecode2 = 0 ;
35096 int val3 ;
35097 int ecode3 = 0 ;
35098 int val4 ;
35099 int ecode4 = 0 ;
35100 int val5 ;
35101 int ecode5 = 0 ;
35102 PyObject * obj0 = 0 ;
35103 PyObject * obj1 = 0 ;
35104 PyObject * obj2 = 0 ;
35105 PyObject * obj3 = 0 ;
35106 PyObject * obj4 = 0 ;
35107 char * kwnames[] = {
35108 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
35109 };
35110
35111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35113 if (!SWIG_IsOK(res1)) {
35114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35115 }
35116 arg1 = reinterpret_cast< wxWindow * >(argp1);
35117 ecode2 = SWIG_AsVal_int(obj1, &val2);
35118 if (!SWIG_IsOK(ecode2)) {
35119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
35120 }
35121 arg2 = static_cast< int >(val2);
35122 ecode3 = SWIG_AsVal_int(obj2, &val3);
35123 if (!SWIG_IsOK(ecode3)) {
35124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
35125 }
35126 arg3 = static_cast< int >(val3);
35127 if (obj3) {
35128 ecode4 = SWIG_AsVal_int(obj3, &val4);
35129 if (!SWIG_IsOK(ecode4)) {
35130 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35131 }
35132 arg4 = static_cast< int >(val4);
35133 }
35134 if (obj4) {
35135 ecode5 = SWIG_AsVal_int(obj4, &val5);
35136 if (!SWIG_IsOK(ecode5)) {
35137 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35138 }
35139 arg5 = static_cast< int >(val5);
35140 }
35141 {
35142 PyThreadState* __tstate = wxPyBeginAllowThreads();
35143 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35144 wxPyEndAllowThreads(__tstate);
35145 if (PyErr_Occurred()) SWIG_fail;
35146 }
35147 resultobj = SWIG_Py_Void();
35148 return resultobj;
35149 fail:
35150 return NULL;
35151 }
35152
35153
35154 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35155 PyObject *resultobj = 0;
35156 wxWindow *arg1 = (wxWindow *) 0 ;
35157 wxSize *arg2 = 0 ;
35158 wxSize const &arg3_defvalue = wxDefaultSize ;
35159 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35160 void *argp1 = 0 ;
35161 int res1 = 0 ;
35162 wxSize temp2 ;
35163 wxSize temp3 ;
35164 PyObject * obj0 = 0 ;
35165 PyObject * obj1 = 0 ;
35166 PyObject * obj2 = 0 ;
35167 char * kwnames[] = {
35168 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35169 };
35170
35171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35173 if (!SWIG_IsOK(res1)) {
35174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35175 }
35176 arg1 = reinterpret_cast< wxWindow * >(argp1);
35177 {
35178 arg2 = &temp2;
35179 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35180 }
35181 if (obj2) {
35182 {
35183 arg3 = &temp3;
35184 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35185 }
35186 }
35187 {
35188 PyThreadState* __tstate = wxPyBeginAllowThreads();
35189 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35190 wxPyEndAllowThreads(__tstate);
35191 if (PyErr_Occurred()) SWIG_fail;
35192 }
35193 resultobj = SWIG_Py_Void();
35194 return resultobj;
35195 fail:
35196 return NULL;
35197 }
35198
35199
35200 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35201 PyObject *resultobj = 0;
35202 wxWindow *arg1 = (wxWindow *) 0 ;
35203 wxSize result;
35204 void *argp1 = 0 ;
35205 int res1 = 0 ;
35206 PyObject *swig_obj[1] ;
35207
35208 if (!args) SWIG_fail;
35209 swig_obj[0] = args;
35210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35211 if (!SWIG_IsOK(res1)) {
35212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35213 }
35214 arg1 = reinterpret_cast< wxWindow * >(argp1);
35215 {
35216 PyThreadState* __tstate = wxPyBeginAllowThreads();
35217 result = ((wxWindow const *)arg1)->GetMaxSize();
35218 wxPyEndAllowThreads(__tstate);
35219 if (PyErr_Occurred()) SWIG_fail;
35220 }
35221 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35222 return resultobj;
35223 fail:
35224 return NULL;
35225 }
35226
35227
35228 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35229 PyObject *resultobj = 0;
35230 wxWindow *arg1 = (wxWindow *) 0 ;
35231 wxSize result;
35232 void *argp1 = 0 ;
35233 int res1 = 0 ;
35234 PyObject *swig_obj[1] ;
35235
35236 if (!args) SWIG_fail;
35237 swig_obj[0] = args;
35238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35239 if (!SWIG_IsOK(res1)) {
35240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35241 }
35242 arg1 = reinterpret_cast< wxWindow * >(argp1);
35243 {
35244 PyThreadState* __tstate = wxPyBeginAllowThreads();
35245 result = ((wxWindow const *)arg1)->GetMinSize();
35246 wxPyEndAllowThreads(__tstate);
35247 if (PyErr_Occurred()) SWIG_fail;
35248 }
35249 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35250 return resultobj;
35251 fail:
35252 return NULL;
35253 }
35254
35255
35256 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35257 PyObject *resultobj = 0;
35258 wxWindow *arg1 = (wxWindow *) 0 ;
35259 wxSize *arg2 = 0 ;
35260 void *argp1 = 0 ;
35261 int res1 = 0 ;
35262 wxSize temp2 ;
35263 PyObject * obj0 = 0 ;
35264 PyObject * obj1 = 0 ;
35265 char * kwnames[] = {
35266 (char *) "self",(char *) "minSize", NULL
35267 };
35268
35269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35271 if (!SWIG_IsOK(res1)) {
35272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35273 }
35274 arg1 = reinterpret_cast< wxWindow * >(argp1);
35275 {
35276 arg2 = &temp2;
35277 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35278 }
35279 {
35280 PyThreadState* __tstate = wxPyBeginAllowThreads();
35281 (arg1)->SetMinSize((wxSize const &)*arg2);
35282 wxPyEndAllowThreads(__tstate);
35283 if (PyErr_Occurred()) SWIG_fail;
35284 }
35285 resultobj = SWIG_Py_Void();
35286 return resultobj;
35287 fail:
35288 return NULL;
35289 }
35290
35291
35292 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35293 PyObject *resultobj = 0;
35294 wxWindow *arg1 = (wxWindow *) 0 ;
35295 wxSize *arg2 = 0 ;
35296 void *argp1 = 0 ;
35297 int res1 = 0 ;
35298 wxSize temp2 ;
35299 PyObject * obj0 = 0 ;
35300 PyObject * obj1 = 0 ;
35301 char * kwnames[] = {
35302 (char *) "self",(char *) "maxSize", NULL
35303 };
35304
35305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35307 if (!SWIG_IsOK(res1)) {
35308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35309 }
35310 arg1 = reinterpret_cast< wxWindow * >(argp1);
35311 {
35312 arg2 = &temp2;
35313 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35314 }
35315 {
35316 PyThreadState* __tstate = wxPyBeginAllowThreads();
35317 (arg1)->SetMaxSize((wxSize const &)*arg2);
35318 wxPyEndAllowThreads(__tstate);
35319 if (PyErr_Occurred()) SWIG_fail;
35320 }
35321 resultobj = SWIG_Py_Void();
35322 return resultobj;
35323 fail:
35324 return NULL;
35325 }
35326
35327
35328 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35329 PyObject *resultobj = 0;
35330 wxWindow *arg1 = (wxWindow *) 0 ;
35331 int result;
35332 void *argp1 = 0 ;
35333 int res1 = 0 ;
35334 PyObject *swig_obj[1] ;
35335
35336 if (!args) SWIG_fail;
35337 swig_obj[0] = args;
35338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35339 if (!SWIG_IsOK(res1)) {
35340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35341 }
35342 arg1 = reinterpret_cast< wxWindow * >(argp1);
35343 {
35344 PyThreadState* __tstate = wxPyBeginAllowThreads();
35345 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35346 wxPyEndAllowThreads(__tstate);
35347 if (PyErr_Occurred()) SWIG_fail;
35348 }
35349 resultobj = SWIG_From_int(static_cast< int >(result));
35350 return resultobj;
35351 fail:
35352 return NULL;
35353 }
35354
35355
35356 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35357 PyObject *resultobj = 0;
35358 wxWindow *arg1 = (wxWindow *) 0 ;
35359 int result;
35360 void *argp1 = 0 ;
35361 int res1 = 0 ;
35362 PyObject *swig_obj[1] ;
35363
35364 if (!args) SWIG_fail;
35365 swig_obj[0] = args;
35366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35367 if (!SWIG_IsOK(res1)) {
35368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35369 }
35370 arg1 = reinterpret_cast< wxWindow * >(argp1);
35371 {
35372 PyThreadState* __tstate = wxPyBeginAllowThreads();
35373 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35374 wxPyEndAllowThreads(__tstate);
35375 if (PyErr_Occurred()) SWIG_fail;
35376 }
35377 resultobj = SWIG_From_int(static_cast< int >(result));
35378 return resultobj;
35379 fail:
35380 return NULL;
35381 }
35382
35383
35384 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35385 PyObject *resultobj = 0;
35386 wxWindow *arg1 = (wxWindow *) 0 ;
35387 int result;
35388 void *argp1 = 0 ;
35389 int res1 = 0 ;
35390 PyObject *swig_obj[1] ;
35391
35392 if (!args) SWIG_fail;
35393 swig_obj[0] = args;
35394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35395 if (!SWIG_IsOK(res1)) {
35396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35397 }
35398 arg1 = reinterpret_cast< wxWindow * >(argp1);
35399 {
35400 PyThreadState* __tstate = wxPyBeginAllowThreads();
35401 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35402 wxPyEndAllowThreads(__tstate);
35403 if (PyErr_Occurred()) SWIG_fail;
35404 }
35405 resultobj = SWIG_From_int(static_cast< int >(result));
35406 return resultobj;
35407 fail:
35408 return NULL;
35409 }
35410
35411
35412 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35413 PyObject *resultobj = 0;
35414 wxWindow *arg1 = (wxWindow *) 0 ;
35415 int result;
35416 void *argp1 = 0 ;
35417 int res1 = 0 ;
35418 PyObject *swig_obj[1] ;
35419
35420 if (!args) SWIG_fail;
35421 swig_obj[0] = args;
35422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35423 if (!SWIG_IsOK(res1)) {
35424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35425 }
35426 arg1 = reinterpret_cast< wxWindow * >(argp1);
35427 {
35428 PyThreadState* __tstate = wxPyBeginAllowThreads();
35429 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35430 wxPyEndAllowThreads(__tstate);
35431 if (PyErr_Occurred()) SWIG_fail;
35432 }
35433 resultobj = SWIG_From_int(static_cast< int >(result));
35434 return resultobj;
35435 fail:
35436 return NULL;
35437 }
35438
35439
35440 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35441 PyObject *resultobj = 0;
35442 wxWindow *arg1 = (wxWindow *) 0 ;
35443 wxSize *arg2 = 0 ;
35444 void *argp1 = 0 ;
35445 int res1 = 0 ;
35446 wxSize temp2 ;
35447 PyObject * obj0 = 0 ;
35448 PyObject * obj1 = 0 ;
35449 char * kwnames[] = {
35450 (char *) "self",(char *) "size", NULL
35451 };
35452
35453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35455 if (!SWIG_IsOK(res1)) {
35456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35457 }
35458 arg1 = reinterpret_cast< wxWindow * >(argp1);
35459 {
35460 arg2 = &temp2;
35461 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35462 }
35463 {
35464 PyThreadState* __tstate = wxPyBeginAllowThreads();
35465 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35466 wxPyEndAllowThreads(__tstate);
35467 if (PyErr_Occurred()) SWIG_fail;
35468 }
35469 resultobj = SWIG_Py_Void();
35470 return resultobj;
35471 fail:
35472 return NULL;
35473 }
35474
35475
35476 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35477 PyObject *resultobj = 0;
35478 wxWindow *arg1 = (wxWindow *) 0 ;
35479 int arg2 ;
35480 int arg3 ;
35481 void *argp1 = 0 ;
35482 int res1 = 0 ;
35483 int val2 ;
35484 int ecode2 = 0 ;
35485 int val3 ;
35486 int ecode3 = 0 ;
35487 PyObject * obj0 = 0 ;
35488 PyObject * obj1 = 0 ;
35489 PyObject * obj2 = 0 ;
35490 char * kwnames[] = {
35491 (char *) "self",(char *) "w",(char *) "h", NULL
35492 };
35493
35494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35496 if (!SWIG_IsOK(res1)) {
35497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35498 }
35499 arg1 = reinterpret_cast< wxWindow * >(argp1);
35500 ecode2 = SWIG_AsVal_int(obj1, &val2);
35501 if (!SWIG_IsOK(ecode2)) {
35502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35503 }
35504 arg2 = static_cast< int >(val2);
35505 ecode3 = SWIG_AsVal_int(obj2, &val3);
35506 if (!SWIG_IsOK(ecode3)) {
35507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35508 }
35509 arg3 = static_cast< int >(val3);
35510 {
35511 PyThreadState* __tstate = wxPyBeginAllowThreads();
35512 (arg1)->SetVirtualSize(arg2,arg3);
35513 wxPyEndAllowThreads(__tstate);
35514 if (PyErr_Occurred()) SWIG_fail;
35515 }
35516 resultobj = SWIG_Py_Void();
35517 return resultobj;
35518 fail:
35519 return NULL;
35520 }
35521
35522
35523 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35524 PyObject *resultobj = 0;
35525 wxWindow *arg1 = (wxWindow *) 0 ;
35526 wxSize result;
35527 void *argp1 = 0 ;
35528 int res1 = 0 ;
35529 PyObject *swig_obj[1] ;
35530
35531 if (!args) SWIG_fail;
35532 swig_obj[0] = args;
35533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35534 if (!SWIG_IsOK(res1)) {
35535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35536 }
35537 arg1 = reinterpret_cast< wxWindow * >(argp1);
35538 {
35539 PyThreadState* __tstate = wxPyBeginAllowThreads();
35540 result = ((wxWindow const *)arg1)->GetVirtualSize();
35541 wxPyEndAllowThreads(__tstate);
35542 if (PyErr_Occurred()) SWIG_fail;
35543 }
35544 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35545 return resultobj;
35546 fail:
35547 return NULL;
35548 }
35549
35550
35551 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35552 PyObject *resultobj = 0;
35553 wxWindow *arg1 = (wxWindow *) 0 ;
35554 int *arg2 = (int *) 0 ;
35555 int *arg3 = (int *) 0 ;
35556 void *argp1 = 0 ;
35557 int res1 = 0 ;
35558 int temp2 ;
35559 int res2 = SWIG_TMPOBJ ;
35560 int temp3 ;
35561 int res3 = SWIG_TMPOBJ ;
35562 PyObject *swig_obj[1] ;
35563
35564 arg2 = &temp2;
35565 arg3 = &temp3;
35566 if (!args) SWIG_fail;
35567 swig_obj[0] = args;
35568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35569 if (!SWIG_IsOK(res1)) {
35570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35571 }
35572 arg1 = reinterpret_cast< wxWindow * >(argp1);
35573 {
35574 PyThreadState* __tstate = wxPyBeginAllowThreads();
35575 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35576 wxPyEndAllowThreads(__tstate);
35577 if (PyErr_Occurred()) SWIG_fail;
35578 }
35579 resultobj = SWIG_Py_Void();
35580 if (SWIG_IsTmpObj(res2)) {
35581 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35582 } else {
35583 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35584 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35585 }
35586 if (SWIG_IsTmpObj(res3)) {
35587 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35588 } else {
35589 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35590 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35591 }
35592 return resultobj;
35593 fail:
35594 return NULL;
35595 }
35596
35597
35598 SWIGINTERN PyObject *_wrap_Window_GetWindowBorderSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35599 PyObject *resultobj = 0;
35600 wxWindow *arg1 = (wxWindow *) 0 ;
35601 wxSize result;
35602 void *argp1 = 0 ;
35603 int res1 = 0 ;
35604 PyObject *swig_obj[1] ;
35605
35606 if (!args) SWIG_fail;
35607 swig_obj[0] = args;
35608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35609 if (!SWIG_IsOK(res1)) {
35610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowBorderSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35611 }
35612 arg1 = reinterpret_cast< wxWindow * >(argp1);
35613 {
35614 PyThreadState* __tstate = wxPyBeginAllowThreads();
35615 result = ((wxWindow const *)arg1)->GetWindowBorderSize();
35616 wxPyEndAllowThreads(__tstate);
35617 if (PyErr_Occurred()) SWIG_fail;
35618 }
35619 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35620 return resultobj;
35621 fail:
35622 return NULL;
35623 }
35624
35625
35626 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35627 PyObject *resultobj = 0;
35628 wxWindow *arg1 = (wxWindow *) 0 ;
35629 wxSize result;
35630 void *argp1 = 0 ;
35631 int res1 = 0 ;
35632 PyObject *swig_obj[1] ;
35633
35634 if (!args) SWIG_fail;
35635 swig_obj[0] = args;
35636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35637 if (!SWIG_IsOK(res1)) {
35638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35639 }
35640 arg1 = reinterpret_cast< wxWindow * >(argp1);
35641 {
35642 PyThreadState* __tstate = wxPyBeginAllowThreads();
35643 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35644 wxPyEndAllowThreads(__tstate);
35645 if (PyErr_Occurred()) SWIG_fail;
35646 }
35647 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35648 return resultobj;
35649 fail:
35650 return NULL;
35651 }
35652
35653
35654 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35655 PyObject *resultobj = 0;
35656 wxWindow *arg1 = (wxWindow *) 0 ;
35657 bool arg2 = (bool) true ;
35658 bool result;
35659 void *argp1 = 0 ;
35660 int res1 = 0 ;
35661 bool val2 ;
35662 int ecode2 = 0 ;
35663 PyObject * obj0 = 0 ;
35664 PyObject * obj1 = 0 ;
35665 char * kwnames[] = {
35666 (char *) "self",(char *) "show", NULL
35667 };
35668
35669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35671 if (!SWIG_IsOK(res1)) {
35672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35673 }
35674 arg1 = reinterpret_cast< wxWindow * >(argp1);
35675 if (obj1) {
35676 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35677 if (!SWIG_IsOK(ecode2)) {
35678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35679 }
35680 arg2 = static_cast< bool >(val2);
35681 }
35682 {
35683 PyThreadState* __tstate = wxPyBeginAllowThreads();
35684 result = (bool)(arg1)->Show(arg2);
35685 wxPyEndAllowThreads(__tstate);
35686 if (PyErr_Occurred()) SWIG_fail;
35687 }
35688 {
35689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35690 }
35691 return resultobj;
35692 fail:
35693 return NULL;
35694 }
35695
35696
35697 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35698 PyObject *resultobj = 0;
35699 wxWindow *arg1 = (wxWindow *) 0 ;
35700 bool result;
35701 void *argp1 = 0 ;
35702 int res1 = 0 ;
35703 PyObject *swig_obj[1] ;
35704
35705 if (!args) SWIG_fail;
35706 swig_obj[0] = args;
35707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35708 if (!SWIG_IsOK(res1)) {
35709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35710 }
35711 arg1 = reinterpret_cast< wxWindow * >(argp1);
35712 {
35713 PyThreadState* __tstate = wxPyBeginAllowThreads();
35714 result = (bool)(arg1)->Hide();
35715 wxPyEndAllowThreads(__tstate);
35716 if (PyErr_Occurred()) SWIG_fail;
35717 }
35718 {
35719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35720 }
35721 return resultobj;
35722 fail:
35723 return NULL;
35724 }
35725
35726
35727 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35728 PyObject *resultobj = 0;
35729 wxWindow *arg1 = (wxWindow *) 0 ;
35730 bool arg2 = (bool) true ;
35731 bool result;
35732 void *argp1 = 0 ;
35733 int res1 = 0 ;
35734 bool val2 ;
35735 int ecode2 = 0 ;
35736 PyObject * obj0 = 0 ;
35737 PyObject * obj1 = 0 ;
35738 char * kwnames[] = {
35739 (char *) "self",(char *) "enable", NULL
35740 };
35741
35742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35744 if (!SWIG_IsOK(res1)) {
35745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35746 }
35747 arg1 = reinterpret_cast< wxWindow * >(argp1);
35748 if (obj1) {
35749 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35750 if (!SWIG_IsOK(ecode2)) {
35751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35752 }
35753 arg2 = static_cast< bool >(val2);
35754 }
35755 {
35756 PyThreadState* __tstate = wxPyBeginAllowThreads();
35757 result = (bool)(arg1)->Enable(arg2);
35758 wxPyEndAllowThreads(__tstate);
35759 if (PyErr_Occurred()) SWIG_fail;
35760 }
35761 {
35762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35763 }
35764 return resultobj;
35765 fail:
35766 return NULL;
35767 }
35768
35769
35770 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35771 PyObject *resultobj = 0;
35772 wxWindow *arg1 = (wxWindow *) 0 ;
35773 bool result;
35774 void *argp1 = 0 ;
35775 int res1 = 0 ;
35776 PyObject *swig_obj[1] ;
35777
35778 if (!args) SWIG_fail;
35779 swig_obj[0] = args;
35780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35781 if (!SWIG_IsOK(res1)) {
35782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35783 }
35784 arg1 = reinterpret_cast< wxWindow * >(argp1);
35785 {
35786 PyThreadState* __tstate = wxPyBeginAllowThreads();
35787 result = (bool)(arg1)->Disable();
35788 wxPyEndAllowThreads(__tstate);
35789 if (PyErr_Occurred()) SWIG_fail;
35790 }
35791 {
35792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35793 }
35794 return resultobj;
35795 fail:
35796 return NULL;
35797 }
35798
35799
35800 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35801 PyObject *resultobj = 0;
35802 wxWindow *arg1 = (wxWindow *) 0 ;
35803 bool result;
35804 void *argp1 = 0 ;
35805 int res1 = 0 ;
35806 PyObject *swig_obj[1] ;
35807
35808 if (!args) SWIG_fail;
35809 swig_obj[0] = args;
35810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35811 if (!SWIG_IsOK(res1)) {
35812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35813 }
35814 arg1 = reinterpret_cast< wxWindow * >(argp1);
35815 {
35816 PyThreadState* __tstate = wxPyBeginAllowThreads();
35817 result = (bool)((wxWindow const *)arg1)->IsShown();
35818 wxPyEndAllowThreads(__tstate);
35819 if (PyErr_Occurred()) SWIG_fail;
35820 }
35821 {
35822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35823 }
35824 return resultobj;
35825 fail:
35826 return NULL;
35827 }
35828
35829
35830 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35831 PyObject *resultobj = 0;
35832 wxWindow *arg1 = (wxWindow *) 0 ;
35833 bool result;
35834 void *argp1 = 0 ;
35835 int res1 = 0 ;
35836 PyObject *swig_obj[1] ;
35837
35838 if (!args) SWIG_fail;
35839 swig_obj[0] = args;
35840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35841 if (!SWIG_IsOK(res1)) {
35842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35843 }
35844 arg1 = reinterpret_cast< wxWindow * >(argp1);
35845 {
35846 PyThreadState* __tstate = wxPyBeginAllowThreads();
35847 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35848 wxPyEndAllowThreads(__tstate);
35849 if (PyErr_Occurred()) SWIG_fail;
35850 }
35851 {
35852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35853 }
35854 return resultobj;
35855 fail:
35856 return NULL;
35857 }
35858
35859
35860 SWIGINTERN PyObject *_wrap_Window_IsThisEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35861 PyObject *resultobj = 0;
35862 wxWindow *arg1 = (wxWindow *) 0 ;
35863 bool result;
35864 void *argp1 = 0 ;
35865 int res1 = 0 ;
35866 PyObject *swig_obj[1] ;
35867
35868 if (!args) SWIG_fail;
35869 swig_obj[0] = args;
35870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35871 if (!SWIG_IsOK(res1)) {
35872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsThisEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35873 }
35874 arg1 = reinterpret_cast< wxWindow * >(argp1);
35875 {
35876 PyThreadState* __tstate = wxPyBeginAllowThreads();
35877 result = (bool)((wxWindow const *)arg1)->IsThisEnabled();
35878 wxPyEndAllowThreads(__tstate);
35879 if (PyErr_Occurred()) SWIG_fail;
35880 }
35881 {
35882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35883 }
35884 return resultobj;
35885 fail:
35886 return NULL;
35887 }
35888
35889
35890 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35891 PyObject *resultobj = 0;
35892 wxWindow *arg1 = (wxWindow *) 0 ;
35893 bool result;
35894 void *argp1 = 0 ;
35895 int res1 = 0 ;
35896 PyObject *swig_obj[1] ;
35897
35898 if (!args) SWIG_fail;
35899 swig_obj[0] = args;
35900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35901 if (!SWIG_IsOK(res1)) {
35902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35903 }
35904 arg1 = reinterpret_cast< wxWindow * >(argp1);
35905 {
35906 PyThreadState* __tstate = wxPyBeginAllowThreads();
35907 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35908 wxPyEndAllowThreads(__tstate);
35909 if (PyErr_Occurred()) SWIG_fail;
35910 }
35911 {
35912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35913 }
35914 return resultobj;
35915 fail:
35916 return NULL;
35917 }
35918
35919
35920 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35921 PyObject *resultobj = 0;
35922 wxWindow *arg1 = (wxWindow *) 0 ;
35923 long arg2 ;
35924 void *argp1 = 0 ;
35925 int res1 = 0 ;
35926 long val2 ;
35927 int ecode2 = 0 ;
35928 PyObject * obj0 = 0 ;
35929 PyObject * obj1 = 0 ;
35930 char * kwnames[] = {
35931 (char *) "self",(char *) "style", NULL
35932 };
35933
35934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35936 if (!SWIG_IsOK(res1)) {
35937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35938 }
35939 arg1 = reinterpret_cast< wxWindow * >(argp1);
35940 ecode2 = SWIG_AsVal_long(obj1, &val2);
35941 if (!SWIG_IsOK(ecode2)) {
35942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35943 }
35944 arg2 = static_cast< long >(val2);
35945 {
35946 PyThreadState* __tstate = wxPyBeginAllowThreads();
35947 (arg1)->SetWindowStyleFlag(arg2);
35948 wxPyEndAllowThreads(__tstate);
35949 if (PyErr_Occurred()) SWIG_fail;
35950 }
35951 resultobj = SWIG_Py_Void();
35952 return resultobj;
35953 fail:
35954 return NULL;
35955 }
35956
35957
35958 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35959 PyObject *resultobj = 0;
35960 wxWindow *arg1 = (wxWindow *) 0 ;
35961 long result;
35962 void *argp1 = 0 ;
35963 int res1 = 0 ;
35964 PyObject *swig_obj[1] ;
35965
35966 if (!args) SWIG_fail;
35967 swig_obj[0] = args;
35968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35969 if (!SWIG_IsOK(res1)) {
35970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35971 }
35972 arg1 = reinterpret_cast< wxWindow * >(argp1);
35973 {
35974 PyThreadState* __tstate = wxPyBeginAllowThreads();
35975 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35976 wxPyEndAllowThreads(__tstate);
35977 if (PyErr_Occurred()) SWIG_fail;
35978 }
35979 resultobj = SWIG_From_long(static_cast< long >(result));
35980 return resultobj;
35981 fail:
35982 return NULL;
35983 }
35984
35985
35986 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35987 PyObject *resultobj = 0;
35988 wxWindow *arg1 = (wxWindow *) 0 ;
35989 int arg2 ;
35990 bool result;
35991 void *argp1 = 0 ;
35992 int res1 = 0 ;
35993 int val2 ;
35994 int ecode2 = 0 ;
35995 PyObject * obj0 = 0 ;
35996 PyObject * obj1 = 0 ;
35997 char * kwnames[] = {
35998 (char *) "self",(char *) "flag", NULL
35999 };
36000
36001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
36002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36003 if (!SWIG_IsOK(res1)) {
36004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
36005 }
36006 arg1 = reinterpret_cast< wxWindow * >(argp1);
36007 ecode2 = SWIG_AsVal_int(obj1, &val2);
36008 if (!SWIG_IsOK(ecode2)) {
36009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
36010 }
36011 arg2 = static_cast< int >(val2);
36012 {
36013 PyThreadState* __tstate = wxPyBeginAllowThreads();
36014 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
36015 wxPyEndAllowThreads(__tstate);
36016 if (PyErr_Occurred()) SWIG_fail;
36017 }
36018 {
36019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36020 }
36021 return resultobj;
36022 fail:
36023 return NULL;
36024 }
36025
36026
36027 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36028 PyObject *resultobj = 0;
36029 wxWindow *arg1 = (wxWindow *) 0 ;
36030 bool result;
36031 void *argp1 = 0 ;
36032 int res1 = 0 ;
36033 PyObject *swig_obj[1] ;
36034
36035 if (!args) SWIG_fail;
36036 swig_obj[0] = args;
36037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36038 if (!SWIG_IsOK(res1)) {
36039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
36040 }
36041 arg1 = reinterpret_cast< wxWindow * >(argp1);
36042 {
36043 PyThreadState* __tstate = wxPyBeginAllowThreads();
36044 result = (bool)((wxWindow const *)arg1)->IsRetained();
36045 wxPyEndAllowThreads(__tstate);
36046 if (PyErr_Occurred()) SWIG_fail;
36047 }
36048 {
36049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36050 }
36051 return resultobj;
36052 fail:
36053 return NULL;
36054 }
36055
36056
36057 SWIGINTERN PyObject *_wrap_Window_ToggleWindowStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36058 PyObject *resultobj = 0;
36059 wxWindow *arg1 = (wxWindow *) 0 ;
36060 int arg2 ;
36061 bool result;
36062 void *argp1 = 0 ;
36063 int res1 = 0 ;
36064 int val2 ;
36065 int ecode2 = 0 ;
36066 PyObject * obj0 = 0 ;
36067 PyObject * obj1 = 0 ;
36068 char * kwnames[] = {
36069 (char *) "self",(char *) "flag", NULL
36070 };
36071
36072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ToggleWindowStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36074 if (!SWIG_IsOK(res1)) {
36075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ToggleWindowStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36076 }
36077 arg1 = reinterpret_cast< wxWindow * >(argp1);
36078 ecode2 = SWIG_AsVal_int(obj1, &val2);
36079 if (!SWIG_IsOK(ecode2)) {
36080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ToggleWindowStyle" "', expected argument " "2"" of type '" "int""'");
36081 }
36082 arg2 = static_cast< int >(val2);
36083 {
36084 PyThreadState* __tstate = wxPyBeginAllowThreads();
36085 result = (bool)(arg1)->ToggleWindowStyle(arg2);
36086 wxPyEndAllowThreads(__tstate);
36087 if (PyErr_Occurred()) SWIG_fail;
36088 }
36089 {
36090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36091 }
36092 return resultobj;
36093 fail:
36094 return NULL;
36095 }
36096
36097
36098 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36099 PyObject *resultobj = 0;
36100 wxWindow *arg1 = (wxWindow *) 0 ;
36101 long arg2 ;
36102 void *argp1 = 0 ;
36103 int res1 = 0 ;
36104 long val2 ;
36105 int ecode2 = 0 ;
36106 PyObject * obj0 = 0 ;
36107 PyObject * obj1 = 0 ;
36108 char * kwnames[] = {
36109 (char *) "self",(char *) "exStyle", NULL
36110 };
36111
36112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36114 if (!SWIG_IsOK(res1)) {
36115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36116 }
36117 arg1 = reinterpret_cast< wxWindow * >(argp1);
36118 ecode2 = SWIG_AsVal_long(obj1, &val2);
36119 if (!SWIG_IsOK(ecode2)) {
36120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
36121 }
36122 arg2 = static_cast< long >(val2);
36123 {
36124 PyThreadState* __tstate = wxPyBeginAllowThreads();
36125 (arg1)->SetExtraStyle(arg2);
36126 wxPyEndAllowThreads(__tstate);
36127 if (PyErr_Occurred()) SWIG_fail;
36128 }
36129 resultobj = SWIG_Py_Void();
36130 return resultobj;
36131 fail:
36132 return NULL;
36133 }
36134
36135
36136 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36137 PyObject *resultobj = 0;
36138 wxWindow *arg1 = (wxWindow *) 0 ;
36139 long result;
36140 void *argp1 = 0 ;
36141 int res1 = 0 ;
36142 PyObject *swig_obj[1] ;
36143
36144 if (!args) SWIG_fail;
36145 swig_obj[0] = args;
36146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36147 if (!SWIG_IsOK(res1)) {
36148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36149 }
36150 arg1 = reinterpret_cast< wxWindow * >(argp1);
36151 {
36152 PyThreadState* __tstate = wxPyBeginAllowThreads();
36153 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
36154 wxPyEndAllowThreads(__tstate);
36155 if (PyErr_Occurred()) SWIG_fail;
36156 }
36157 resultobj = SWIG_From_long(static_cast< long >(result));
36158 return resultobj;
36159 fail:
36160 return NULL;
36161 }
36162
36163
36164 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36165 PyObject *resultobj = 0;
36166 wxWindow *arg1 = (wxWindow *) 0 ;
36167 bool arg2 = (bool) true ;
36168 void *argp1 = 0 ;
36169 int res1 = 0 ;
36170 bool val2 ;
36171 int ecode2 = 0 ;
36172 PyObject * obj0 = 0 ;
36173 PyObject * obj1 = 0 ;
36174 char * kwnames[] = {
36175 (char *) "self",(char *) "modal", NULL
36176 };
36177
36178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
36179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36180 if (!SWIG_IsOK(res1)) {
36181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
36182 }
36183 arg1 = reinterpret_cast< wxWindow * >(argp1);
36184 if (obj1) {
36185 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36186 if (!SWIG_IsOK(ecode2)) {
36187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
36188 }
36189 arg2 = static_cast< bool >(val2);
36190 }
36191 {
36192 PyThreadState* __tstate = wxPyBeginAllowThreads();
36193 (arg1)->MakeModal(arg2);
36194 wxPyEndAllowThreads(__tstate);
36195 if (PyErr_Occurred()) SWIG_fail;
36196 }
36197 resultobj = SWIG_Py_Void();
36198 return resultobj;
36199 fail:
36200 return NULL;
36201 }
36202
36203
36204 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36205 PyObject *resultobj = 0;
36206 wxWindow *arg1 = (wxWindow *) 0 ;
36207 bool arg2 ;
36208 void *argp1 = 0 ;
36209 int res1 = 0 ;
36210 bool val2 ;
36211 int ecode2 = 0 ;
36212 PyObject * obj0 = 0 ;
36213 PyObject * obj1 = 0 ;
36214 char * kwnames[] = {
36215 (char *) "self",(char *) "enableTheme", NULL
36216 };
36217
36218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36220 if (!SWIG_IsOK(res1)) {
36221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36222 }
36223 arg1 = reinterpret_cast< wxWindow * >(argp1);
36224 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36225 if (!SWIG_IsOK(ecode2)) {
36226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36227 }
36228 arg2 = static_cast< bool >(val2);
36229 {
36230 PyThreadState* __tstate = wxPyBeginAllowThreads();
36231 (arg1)->SetThemeEnabled(arg2);
36232 wxPyEndAllowThreads(__tstate);
36233 if (PyErr_Occurred()) SWIG_fail;
36234 }
36235 resultobj = SWIG_Py_Void();
36236 return resultobj;
36237 fail:
36238 return NULL;
36239 }
36240
36241
36242 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36243 PyObject *resultobj = 0;
36244 wxWindow *arg1 = (wxWindow *) 0 ;
36245 bool result;
36246 void *argp1 = 0 ;
36247 int res1 = 0 ;
36248 PyObject *swig_obj[1] ;
36249
36250 if (!args) SWIG_fail;
36251 swig_obj[0] = args;
36252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36253 if (!SWIG_IsOK(res1)) {
36254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36255 }
36256 arg1 = reinterpret_cast< wxWindow * >(argp1);
36257 {
36258 PyThreadState* __tstate = wxPyBeginAllowThreads();
36259 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36260 wxPyEndAllowThreads(__tstate);
36261 if (PyErr_Occurred()) SWIG_fail;
36262 }
36263 {
36264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36265 }
36266 return resultobj;
36267 fail:
36268 return NULL;
36269 }
36270
36271
36272 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36273 PyObject *resultobj = 0;
36274 wxWindow *arg1 = (wxWindow *) 0 ;
36275 void *argp1 = 0 ;
36276 int res1 = 0 ;
36277 PyObject *swig_obj[1] ;
36278
36279 if (!args) SWIG_fail;
36280 swig_obj[0] = args;
36281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36282 if (!SWIG_IsOK(res1)) {
36283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36284 }
36285 arg1 = reinterpret_cast< wxWindow * >(argp1);
36286 {
36287 PyThreadState* __tstate = wxPyBeginAllowThreads();
36288 (arg1)->SetFocus();
36289 wxPyEndAllowThreads(__tstate);
36290 if (PyErr_Occurred()) SWIG_fail;
36291 }
36292 resultobj = SWIG_Py_Void();
36293 return resultobj;
36294 fail:
36295 return NULL;
36296 }
36297
36298
36299 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36300 PyObject *resultobj = 0;
36301 wxWindow *arg1 = (wxWindow *) 0 ;
36302 void *argp1 = 0 ;
36303 int res1 = 0 ;
36304 PyObject *swig_obj[1] ;
36305
36306 if (!args) SWIG_fail;
36307 swig_obj[0] = args;
36308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36309 if (!SWIG_IsOK(res1)) {
36310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36311 }
36312 arg1 = reinterpret_cast< wxWindow * >(argp1);
36313 {
36314 PyThreadState* __tstate = wxPyBeginAllowThreads();
36315 (arg1)->SetFocusFromKbd();
36316 wxPyEndAllowThreads(__tstate);
36317 if (PyErr_Occurred()) SWIG_fail;
36318 }
36319 resultobj = SWIG_Py_Void();
36320 return resultobj;
36321 fail:
36322 return NULL;
36323 }
36324
36325
36326 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36327 PyObject *resultobj = 0;
36328 wxWindow *result = 0 ;
36329
36330 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36331 {
36332 if (!wxPyCheckForApp()) SWIG_fail;
36333 PyThreadState* __tstate = wxPyBeginAllowThreads();
36334 result = (wxWindow *)wxWindow::FindFocus();
36335 wxPyEndAllowThreads(__tstate);
36336 if (PyErr_Occurred()) SWIG_fail;
36337 }
36338 {
36339 resultobj = wxPyMake_wxObject(result, 0);
36340 }
36341 return resultobj;
36342 fail:
36343 return NULL;
36344 }
36345
36346
36347 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36348 PyObject *resultobj = 0;
36349 wxWindow *arg1 = (wxWindow *) 0 ;
36350 bool result;
36351 void *argp1 = 0 ;
36352 int res1 = 0 ;
36353 PyObject *swig_obj[1] ;
36354
36355 if (!args) SWIG_fail;
36356 swig_obj[0] = args;
36357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36358 if (!SWIG_IsOK(res1)) {
36359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36360 }
36361 arg1 = reinterpret_cast< wxWindow * >(argp1);
36362 {
36363 PyThreadState* __tstate = wxPyBeginAllowThreads();
36364 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36365 wxPyEndAllowThreads(__tstate);
36366 if (PyErr_Occurred()) SWIG_fail;
36367 }
36368 {
36369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36370 }
36371 return resultobj;
36372 fail:
36373 return NULL;
36374 }
36375
36376
36377 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36378 PyObject *resultobj = 0;
36379 wxWindow *arg1 = (wxWindow *) 0 ;
36380 bool result;
36381 void *argp1 = 0 ;
36382 int res1 = 0 ;
36383 PyObject *swig_obj[1] ;
36384
36385 if (!args) SWIG_fail;
36386 swig_obj[0] = args;
36387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36388 if (!SWIG_IsOK(res1)) {
36389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36390 }
36391 arg1 = reinterpret_cast< wxWindow * >(argp1);
36392 {
36393 PyThreadState* __tstate = wxPyBeginAllowThreads();
36394 result = (bool)((wxWindow const *)arg1)->CanAcceptFocus();
36395 wxPyEndAllowThreads(__tstate);
36396 if (PyErr_Occurred()) SWIG_fail;
36397 }
36398 {
36399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36400 }
36401 return resultobj;
36402 fail:
36403 return NULL;
36404 }
36405
36406
36407 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36408 PyObject *resultobj = 0;
36409 wxWindow *arg1 = (wxWindow *) 0 ;
36410 bool result;
36411 void *argp1 = 0 ;
36412 int res1 = 0 ;
36413 PyObject *swig_obj[1] ;
36414
36415 if (!args) SWIG_fail;
36416 swig_obj[0] = args;
36417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36418 if (!SWIG_IsOK(res1)) {
36419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36420 }
36421 arg1 = reinterpret_cast< wxWindow * >(argp1);
36422 {
36423 PyThreadState* __tstate = wxPyBeginAllowThreads();
36424 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36425 wxPyEndAllowThreads(__tstate);
36426 if (PyErr_Occurred()) SWIG_fail;
36427 }
36428 {
36429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36430 }
36431 return resultobj;
36432 fail:
36433 return NULL;
36434 }
36435
36436
36437 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36438 PyObject *resultobj = 0;
36439 wxWindow *arg1 = (wxWindow *) 0 ;
36440 bool result;
36441 void *argp1 = 0 ;
36442 int res1 = 0 ;
36443 PyObject *swig_obj[1] ;
36444
36445 if (!args) SWIG_fail;
36446 swig_obj[0] = args;
36447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36448 if (!SWIG_IsOK(res1)) {
36449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36450 }
36451 arg1 = reinterpret_cast< wxWindow * >(argp1);
36452 {
36453 PyThreadState* __tstate = wxPyBeginAllowThreads();
36454 result = (bool)((wxWindow const *)arg1)->CanAcceptFocusFromKeyboard();
36455 wxPyEndAllowThreads(__tstate);
36456 if (PyErr_Occurred()) SWIG_fail;
36457 }
36458 {
36459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36460 }
36461 return resultobj;
36462 fail:
36463 return NULL;
36464 }
36465
36466
36467 SWIGINTERN PyObject *_wrap_Window_NavigateIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36468 PyObject *resultobj = 0;
36469 wxWindow *arg1 = (wxWindow *) 0 ;
36470 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36471 bool result;
36472 void *argp1 = 0 ;
36473 int res1 = 0 ;
36474 int val2 ;
36475 int ecode2 = 0 ;
36476 PyObject * obj0 = 0 ;
36477 PyObject * obj1 = 0 ;
36478 char * kwnames[] = {
36479 (char *) "self",(char *) "flags", NULL
36480 };
36481
36482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_NavigateIn",kwnames,&obj0,&obj1)) SWIG_fail;
36483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36484 if (!SWIG_IsOK(res1)) {
36485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_NavigateIn" "', expected argument " "1"" of type '" "wxWindow *""'");
36486 }
36487 arg1 = reinterpret_cast< wxWindow * >(argp1);
36488 if (obj1) {
36489 ecode2 = SWIG_AsVal_int(obj1, &val2);
36490 if (!SWIG_IsOK(ecode2)) {
36491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_NavigateIn" "', expected argument " "2"" of type '" "int""'");
36492 }
36493 arg2 = static_cast< int >(val2);
36494 }
36495 {
36496 PyThreadState* __tstate = wxPyBeginAllowThreads();
36497 result = (bool)(arg1)->NavigateIn(arg2);
36498 wxPyEndAllowThreads(__tstate);
36499 if (PyErr_Occurred()) SWIG_fail;
36500 }
36501 {
36502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36503 }
36504 return resultobj;
36505 fail:
36506 return NULL;
36507 }
36508
36509
36510 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36511 PyObject *resultobj = 0;
36512 wxWindow *arg1 = (wxWindow *) 0 ;
36513 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36514 bool result;
36515 void *argp1 = 0 ;
36516 int res1 = 0 ;
36517 int val2 ;
36518 int ecode2 = 0 ;
36519 PyObject * obj0 = 0 ;
36520 PyObject * obj1 = 0 ;
36521 char * kwnames[] = {
36522 (char *) "self",(char *) "flags", NULL
36523 };
36524
36525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36527 if (!SWIG_IsOK(res1)) {
36528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36529 }
36530 arg1 = reinterpret_cast< wxWindow * >(argp1);
36531 if (obj1) {
36532 ecode2 = SWIG_AsVal_int(obj1, &val2);
36533 if (!SWIG_IsOK(ecode2)) {
36534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36535 }
36536 arg2 = static_cast< int >(val2);
36537 }
36538 {
36539 PyThreadState* __tstate = wxPyBeginAllowThreads();
36540 result = (bool)(arg1)->Navigate(arg2);
36541 wxPyEndAllowThreads(__tstate);
36542 if (PyErr_Occurred()) SWIG_fail;
36543 }
36544 {
36545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36546 }
36547 return resultobj;
36548 fail:
36549 return NULL;
36550 }
36551
36552
36553 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36554 PyObject *resultobj = 0;
36555 wxWindow *arg1 = (wxWindow *) 0 ;
36556 wxWindow *arg2 = (wxWindow *) 0 ;
36557 void *argp1 = 0 ;
36558 int res1 = 0 ;
36559 void *argp2 = 0 ;
36560 int res2 = 0 ;
36561 PyObject * obj0 = 0 ;
36562 PyObject * obj1 = 0 ;
36563 char * kwnames[] = {
36564 (char *) "self",(char *) "win", NULL
36565 };
36566
36567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36569 if (!SWIG_IsOK(res1)) {
36570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36571 }
36572 arg1 = reinterpret_cast< wxWindow * >(argp1);
36573 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36574 if (!SWIG_IsOK(res2)) {
36575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36576 }
36577 arg2 = reinterpret_cast< wxWindow * >(argp2);
36578 {
36579 PyThreadState* __tstate = wxPyBeginAllowThreads();
36580 (arg1)->MoveAfterInTabOrder(arg2);
36581 wxPyEndAllowThreads(__tstate);
36582 if (PyErr_Occurred()) SWIG_fail;
36583 }
36584 resultobj = SWIG_Py_Void();
36585 return resultobj;
36586 fail:
36587 return NULL;
36588 }
36589
36590
36591 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36592 PyObject *resultobj = 0;
36593 wxWindow *arg1 = (wxWindow *) 0 ;
36594 wxWindow *arg2 = (wxWindow *) 0 ;
36595 void *argp1 = 0 ;
36596 int res1 = 0 ;
36597 void *argp2 = 0 ;
36598 int res2 = 0 ;
36599 PyObject * obj0 = 0 ;
36600 PyObject * obj1 = 0 ;
36601 char * kwnames[] = {
36602 (char *) "self",(char *) "win", NULL
36603 };
36604
36605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36607 if (!SWIG_IsOK(res1)) {
36608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36609 }
36610 arg1 = reinterpret_cast< wxWindow * >(argp1);
36611 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36612 if (!SWIG_IsOK(res2)) {
36613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36614 }
36615 arg2 = reinterpret_cast< wxWindow * >(argp2);
36616 {
36617 PyThreadState* __tstate = wxPyBeginAllowThreads();
36618 (arg1)->MoveBeforeInTabOrder(arg2);
36619 wxPyEndAllowThreads(__tstate);
36620 if (PyErr_Occurred()) SWIG_fail;
36621 }
36622 resultobj = SWIG_Py_Void();
36623 return resultobj;
36624 fail:
36625 return NULL;
36626 }
36627
36628
36629 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36630 PyObject *resultobj = 0;
36631 wxWindow *arg1 = (wxWindow *) 0 ;
36632 PyObject *result = 0 ;
36633 void *argp1 = 0 ;
36634 int res1 = 0 ;
36635 PyObject *swig_obj[1] ;
36636
36637 if (!args) SWIG_fail;
36638 swig_obj[0] = args;
36639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36640 if (!SWIG_IsOK(res1)) {
36641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36642 }
36643 arg1 = reinterpret_cast< wxWindow * >(argp1);
36644 {
36645 PyThreadState* __tstate = wxPyBeginAllowThreads();
36646 result = (PyObject *)wxWindow_GetChildren(arg1);
36647 wxPyEndAllowThreads(__tstate);
36648 if (PyErr_Occurred()) SWIG_fail;
36649 }
36650 resultobj = result;
36651 return resultobj;
36652 fail:
36653 return NULL;
36654 }
36655
36656
36657 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36658 PyObject *resultobj = 0;
36659 wxWindow *arg1 = (wxWindow *) 0 ;
36660 wxWindow *result = 0 ;
36661 void *argp1 = 0 ;
36662 int res1 = 0 ;
36663 PyObject *swig_obj[1] ;
36664
36665 if (!args) SWIG_fail;
36666 swig_obj[0] = args;
36667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36668 if (!SWIG_IsOK(res1)) {
36669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36670 }
36671 arg1 = reinterpret_cast< wxWindow * >(argp1);
36672 {
36673 PyThreadState* __tstate = wxPyBeginAllowThreads();
36674 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36675 wxPyEndAllowThreads(__tstate);
36676 if (PyErr_Occurred()) SWIG_fail;
36677 }
36678 {
36679 resultobj = wxPyMake_wxObject(result, 0);
36680 }
36681 return resultobj;
36682 fail:
36683 return NULL;
36684 }
36685
36686
36687 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36688 PyObject *resultobj = 0;
36689 wxWindow *arg1 = (wxWindow *) 0 ;
36690 wxWindow *result = 0 ;
36691 void *argp1 = 0 ;
36692 int res1 = 0 ;
36693 PyObject *swig_obj[1] ;
36694
36695 if (!args) SWIG_fail;
36696 swig_obj[0] = args;
36697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36698 if (!SWIG_IsOK(res1)) {
36699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36700 }
36701 arg1 = reinterpret_cast< wxWindow * >(argp1);
36702 {
36703 PyThreadState* __tstate = wxPyBeginAllowThreads();
36704 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36705 wxPyEndAllowThreads(__tstate);
36706 if (PyErr_Occurred()) SWIG_fail;
36707 }
36708 {
36709 resultobj = wxPyMake_wxObject(result, 0);
36710 }
36711 return resultobj;
36712 fail:
36713 return NULL;
36714 }
36715
36716
36717 SWIGINTERN PyObject *_wrap_Window_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36718 PyObject *resultobj = 0;
36719 wxWindow *arg1 = (wxWindow *) 0 ;
36720 wxWindow *result = 0 ;
36721 void *argp1 = 0 ;
36722 int res1 = 0 ;
36723 PyObject *swig_obj[1] ;
36724
36725 if (!args) SWIG_fail;
36726 swig_obj[0] = args;
36727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36728 if (!SWIG_IsOK(res1)) {
36729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
36730 }
36731 arg1 = reinterpret_cast< wxWindow * >(argp1);
36732 {
36733 PyThreadState* __tstate = wxPyBeginAllowThreads();
36734 result = (wxWindow *)wxWindow_GetTopLevelParent(arg1);
36735 wxPyEndAllowThreads(__tstate);
36736 if (PyErr_Occurred()) SWIG_fail;
36737 }
36738 {
36739 resultobj = wxPyMake_wxObject(result, 0);
36740 }
36741 return resultobj;
36742 fail:
36743 return NULL;
36744 }
36745
36746
36747 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36748 PyObject *resultobj = 0;
36749 wxWindow *arg1 = (wxWindow *) 0 ;
36750 bool result;
36751 void *argp1 = 0 ;
36752 int res1 = 0 ;
36753 PyObject *swig_obj[1] ;
36754
36755 if (!args) SWIG_fail;
36756 swig_obj[0] = args;
36757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36758 if (!SWIG_IsOK(res1)) {
36759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36760 }
36761 arg1 = reinterpret_cast< wxWindow * >(argp1);
36762 {
36763 PyThreadState* __tstate = wxPyBeginAllowThreads();
36764 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36765 wxPyEndAllowThreads(__tstate);
36766 if (PyErr_Occurred()) SWIG_fail;
36767 }
36768 {
36769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36770 }
36771 return resultobj;
36772 fail:
36773 return NULL;
36774 }
36775
36776
36777 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36778 PyObject *resultobj = 0;
36779 wxWindow *arg1 = (wxWindow *) 0 ;
36780 wxWindow *arg2 = (wxWindow *) 0 ;
36781 bool result;
36782 void *argp1 = 0 ;
36783 int res1 = 0 ;
36784 void *argp2 = 0 ;
36785 int res2 = 0 ;
36786 PyObject * obj0 = 0 ;
36787 PyObject * obj1 = 0 ;
36788 char * kwnames[] = {
36789 (char *) "self",(char *) "newParent", NULL
36790 };
36791
36792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36794 if (!SWIG_IsOK(res1)) {
36795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36796 }
36797 arg1 = reinterpret_cast< wxWindow * >(argp1);
36798 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36799 if (!SWIG_IsOK(res2)) {
36800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36801 }
36802 arg2 = reinterpret_cast< wxWindow * >(argp2);
36803 {
36804 PyThreadState* __tstate = wxPyBeginAllowThreads();
36805 result = (bool)(arg1)->Reparent(arg2);
36806 wxPyEndAllowThreads(__tstate);
36807 if (PyErr_Occurred()) SWIG_fail;
36808 }
36809 {
36810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36811 }
36812 return resultobj;
36813 fail:
36814 return NULL;
36815 }
36816
36817
36818 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36819 PyObject *resultobj = 0;
36820 wxWindow *arg1 = (wxWindow *) 0 ;
36821 wxWindow *arg2 = (wxWindow *) 0 ;
36822 void *argp1 = 0 ;
36823 int res1 = 0 ;
36824 void *argp2 = 0 ;
36825 int res2 = 0 ;
36826 PyObject * obj0 = 0 ;
36827 PyObject * obj1 = 0 ;
36828 char * kwnames[] = {
36829 (char *) "self",(char *) "child", NULL
36830 };
36831
36832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36834 if (!SWIG_IsOK(res1)) {
36835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36836 }
36837 arg1 = reinterpret_cast< wxWindow * >(argp1);
36838 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36839 if (!SWIG_IsOK(res2)) {
36840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36841 }
36842 arg2 = reinterpret_cast< wxWindow * >(argp2);
36843 {
36844 PyThreadState* __tstate = wxPyBeginAllowThreads();
36845 (arg1)->AddChild(arg2);
36846 wxPyEndAllowThreads(__tstate);
36847 if (PyErr_Occurred()) SWIG_fail;
36848 }
36849 resultobj = SWIG_Py_Void();
36850 return resultobj;
36851 fail:
36852 return NULL;
36853 }
36854
36855
36856 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36857 PyObject *resultobj = 0;
36858 wxWindow *arg1 = (wxWindow *) 0 ;
36859 wxWindow *arg2 = (wxWindow *) 0 ;
36860 void *argp1 = 0 ;
36861 int res1 = 0 ;
36862 void *argp2 = 0 ;
36863 int res2 = 0 ;
36864 PyObject * obj0 = 0 ;
36865 PyObject * obj1 = 0 ;
36866 char * kwnames[] = {
36867 (char *) "self",(char *) "child", NULL
36868 };
36869
36870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36872 if (!SWIG_IsOK(res1)) {
36873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36874 }
36875 arg1 = reinterpret_cast< wxWindow * >(argp1);
36876 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36877 if (!SWIG_IsOK(res2)) {
36878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36879 }
36880 arg2 = reinterpret_cast< wxWindow * >(argp2);
36881 {
36882 PyThreadState* __tstate = wxPyBeginAllowThreads();
36883 (arg1)->RemoveChild(arg2);
36884 wxPyEndAllowThreads(__tstate);
36885 if (PyErr_Occurred()) SWIG_fail;
36886 }
36887 resultobj = SWIG_Py_Void();
36888 return resultobj;
36889 fail:
36890 return NULL;
36891 }
36892
36893
36894 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36895 PyObject *resultobj = 0;
36896 wxWindow *arg1 = (wxWindow *) 0 ;
36897 bool arg2 ;
36898 void *argp1 = 0 ;
36899 int res1 = 0 ;
36900 bool val2 ;
36901 int ecode2 = 0 ;
36902 PyObject * obj0 = 0 ;
36903 PyObject * obj1 = 0 ;
36904 char * kwnames[] = {
36905 (char *) "self",(char *) "on", NULL
36906 };
36907
36908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36910 if (!SWIG_IsOK(res1)) {
36911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36912 }
36913 arg1 = reinterpret_cast< wxWindow * >(argp1);
36914 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36915 if (!SWIG_IsOK(ecode2)) {
36916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36917 }
36918 arg2 = static_cast< bool >(val2);
36919 {
36920 PyThreadState* __tstate = wxPyBeginAllowThreads();
36921 (arg1)->SetDoubleBuffered(arg2);
36922 wxPyEndAllowThreads(__tstate);
36923 if (PyErr_Occurred()) SWIG_fail;
36924 }
36925 resultobj = SWIG_Py_Void();
36926 return resultobj;
36927 fail:
36928 return NULL;
36929 }
36930
36931
36932 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36933 PyObject *resultobj = 0;
36934 wxWindow *arg1 = (wxWindow *) 0 ;
36935 long arg2 ;
36936 wxWindow *result = 0 ;
36937 void *argp1 = 0 ;
36938 int res1 = 0 ;
36939 long val2 ;
36940 int ecode2 = 0 ;
36941 PyObject * obj0 = 0 ;
36942 PyObject * obj1 = 0 ;
36943 char * kwnames[] = {
36944 (char *) "self",(char *) "winid", NULL
36945 };
36946
36947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36949 if (!SWIG_IsOK(res1)) {
36950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36951 }
36952 arg1 = reinterpret_cast< wxWindow * >(argp1);
36953 ecode2 = SWIG_AsVal_long(obj1, &val2);
36954 if (!SWIG_IsOK(ecode2)) {
36955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36956 }
36957 arg2 = static_cast< long >(val2);
36958 {
36959 PyThreadState* __tstate = wxPyBeginAllowThreads();
36960 result = (wxWindow *)(arg1)->FindWindow(arg2);
36961 wxPyEndAllowThreads(__tstate);
36962 if (PyErr_Occurred()) SWIG_fail;
36963 }
36964 {
36965 resultobj = wxPyMake_wxObject(result, 0);
36966 }
36967 return resultobj;
36968 fail:
36969 return NULL;
36970 }
36971
36972
36973 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36974 PyObject *resultobj = 0;
36975 wxWindow *arg1 = (wxWindow *) 0 ;
36976 wxString *arg2 = 0 ;
36977 wxWindow *result = 0 ;
36978 void *argp1 = 0 ;
36979 int res1 = 0 ;
36980 bool temp2 = false ;
36981 PyObject * obj0 = 0 ;
36982 PyObject * obj1 = 0 ;
36983 char * kwnames[] = {
36984 (char *) "self",(char *) "name", NULL
36985 };
36986
36987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36989 if (!SWIG_IsOK(res1)) {
36990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36991 }
36992 arg1 = reinterpret_cast< wxWindow * >(argp1);
36993 {
36994 arg2 = wxString_in_helper(obj1);
36995 if (arg2 == NULL) SWIG_fail;
36996 temp2 = true;
36997 }
36998 {
36999 PyThreadState* __tstate = wxPyBeginAllowThreads();
37000 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
37001 wxPyEndAllowThreads(__tstate);
37002 if (PyErr_Occurred()) SWIG_fail;
37003 }
37004 {
37005 resultobj = wxPyMake_wxObject(result, 0);
37006 }
37007 {
37008 if (temp2)
37009 delete arg2;
37010 }
37011 return resultobj;
37012 fail:
37013 {
37014 if (temp2)
37015 delete arg2;
37016 }
37017 return NULL;
37018 }
37019
37020
37021 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37022 PyObject *resultobj = 0;
37023 wxWindow *arg1 = (wxWindow *) 0 ;
37024 wxEvtHandler *result = 0 ;
37025 void *argp1 = 0 ;
37026 int res1 = 0 ;
37027 PyObject *swig_obj[1] ;
37028
37029 if (!args) SWIG_fail;
37030 swig_obj[0] = args;
37031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37032 if (!SWIG_IsOK(res1)) {
37033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
37034 }
37035 arg1 = reinterpret_cast< wxWindow * >(argp1);
37036 {
37037 PyThreadState* __tstate = wxPyBeginAllowThreads();
37038 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
37039 wxPyEndAllowThreads(__tstate);
37040 if (PyErr_Occurred()) SWIG_fail;
37041 }
37042 {
37043 resultobj = wxPyMake_wxObject(result, 0);
37044 }
37045 return resultobj;
37046 fail:
37047 return NULL;
37048 }
37049
37050
37051 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37052 PyObject *resultobj = 0;
37053 wxWindow *arg1 = (wxWindow *) 0 ;
37054 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37055 void *argp1 = 0 ;
37056 int res1 = 0 ;
37057 void *argp2 = 0 ;
37058 int res2 = 0 ;
37059 PyObject * obj0 = 0 ;
37060 PyObject * obj1 = 0 ;
37061 char * kwnames[] = {
37062 (char *) "self",(char *) "handler", NULL
37063 };
37064
37065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37067 if (!SWIG_IsOK(res1)) {
37068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37069 }
37070 arg1 = reinterpret_cast< wxWindow * >(argp1);
37071 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37072 if (!SWIG_IsOK(res2)) {
37073 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37074 }
37075 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37076 {
37077 PyThreadState* __tstate = wxPyBeginAllowThreads();
37078 (arg1)->SetEventHandler(arg2);
37079 wxPyEndAllowThreads(__tstate);
37080 if (PyErr_Occurred()) SWIG_fail;
37081 }
37082 resultobj = SWIG_Py_Void();
37083 return resultobj;
37084 fail:
37085 return NULL;
37086 }
37087
37088
37089 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37090 PyObject *resultobj = 0;
37091 wxWindow *arg1 = (wxWindow *) 0 ;
37092 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37093 void *argp1 = 0 ;
37094 int res1 = 0 ;
37095 void *argp2 = 0 ;
37096 int res2 = 0 ;
37097 PyObject * obj0 = 0 ;
37098 PyObject * obj1 = 0 ;
37099 char * kwnames[] = {
37100 (char *) "self",(char *) "handler", NULL
37101 };
37102
37103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37105 if (!SWIG_IsOK(res1)) {
37106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37107 }
37108 arg1 = reinterpret_cast< wxWindow * >(argp1);
37109 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37110 if (!SWIG_IsOK(res2)) {
37111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37112 }
37113 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37114 {
37115 PyThreadState* __tstate = wxPyBeginAllowThreads();
37116 (arg1)->PushEventHandler(arg2);
37117 wxPyEndAllowThreads(__tstate);
37118 if (PyErr_Occurred()) SWIG_fail;
37119 }
37120 resultobj = SWIG_Py_Void();
37121 return resultobj;
37122 fail:
37123 return NULL;
37124 }
37125
37126
37127 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37128 PyObject *resultobj = 0;
37129 wxWindow *arg1 = (wxWindow *) 0 ;
37130 bool arg2 = (bool) false ;
37131 wxEvtHandler *result = 0 ;
37132 void *argp1 = 0 ;
37133 int res1 = 0 ;
37134 bool val2 ;
37135 int ecode2 = 0 ;
37136 PyObject * obj0 = 0 ;
37137 PyObject * obj1 = 0 ;
37138 char * kwnames[] = {
37139 (char *) "self",(char *) "deleteHandler", NULL
37140 };
37141
37142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37144 if (!SWIG_IsOK(res1)) {
37145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37146 }
37147 arg1 = reinterpret_cast< wxWindow * >(argp1);
37148 if (obj1) {
37149 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37150 if (!SWIG_IsOK(ecode2)) {
37151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
37152 }
37153 arg2 = static_cast< bool >(val2);
37154 }
37155 {
37156 PyThreadState* __tstate = wxPyBeginAllowThreads();
37157 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
37158 wxPyEndAllowThreads(__tstate);
37159 if (PyErr_Occurred()) SWIG_fail;
37160 }
37161 {
37162 resultobj = wxPyMake_wxObject(result, 0);
37163 }
37164 return resultobj;
37165 fail:
37166 return NULL;
37167 }
37168
37169
37170 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37171 PyObject *resultobj = 0;
37172 wxWindow *arg1 = (wxWindow *) 0 ;
37173 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37174 bool result;
37175 void *argp1 = 0 ;
37176 int res1 = 0 ;
37177 void *argp2 = 0 ;
37178 int res2 = 0 ;
37179 PyObject * obj0 = 0 ;
37180 PyObject * obj1 = 0 ;
37181 char * kwnames[] = {
37182 (char *) "self",(char *) "handler", NULL
37183 };
37184
37185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37187 if (!SWIG_IsOK(res1)) {
37188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37189 }
37190 arg1 = reinterpret_cast< wxWindow * >(argp1);
37191 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37192 if (!SWIG_IsOK(res2)) {
37193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37194 }
37195 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37196 {
37197 PyThreadState* __tstate = wxPyBeginAllowThreads();
37198 result = (bool)(arg1)->RemoveEventHandler(arg2);
37199 wxPyEndAllowThreads(__tstate);
37200 if (PyErr_Occurred()) SWIG_fail;
37201 }
37202 {
37203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37204 }
37205 return resultobj;
37206 fail:
37207 return NULL;
37208 }
37209
37210
37211 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37212 PyObject *resultobj = 0;
37213 wxWindow *arg1 = (wxWindow *) 0 ;
37214 wxValidator *arg2 = 0 ;
37215 void *argp1 = 0 ;
37216 int res1 = 0 ;
37217 void *argp2 = 0 ;
37218 int res2 = 0 ;
37219 PyObject * obj0 = 0 ;
37220 PyObject * obj1 = 0 ;
37221 char * kwnames[] = {
37222 (char *) "self",(char *) "validator", NULL
37223 };
37224
37225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
37226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37227 if (!SWIG_IsOK(res1)) {
37228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37229 }
37230 arg1 = reinterpret_cast< wxWindow * >(argp1);
37231 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
37232 if (!SWIG_IsOK(res2)) {
37233 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37234 }
37235 if (!argp2) {
37236 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37237 }
37238 arg2 = reinterpret_cast< wxValidator * >(argp2);
37239 {
37240 PyThreadState* __tstate = wxPyBeginAllowThreads();
37241 (arg1)->SetValidator((wxValidator const &)*arg2);
37242 wxPyEndAllowThreads(__tstate);
37243 if (PyErr_Occurred()) SWIG_fail;
37244 }
37245 resultobj = SWIG_Py_Void();
37246 return resultobj;
37247 fail:
37248 return NULL;
37249 }
37250
37251
37252 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37253 PyObject *resultobj = 0;
37254 wxWindow *arg1 = (wxWindow *) 0 ;
37255 wxValidator *result = 0 ;
37256 void *argp1 = 0 ;
37257 int res1 = 0 ;
37258 PyObject *swig_obj[1] ;
37259
37260 if (!args) SWIG_fail;
37261 swig_obj[0] = args;
37262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37263 if (!SWIG_IsOK(res1)) {
37264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37265 }
37266 arg1 = reinterpret_cast< wxWindow * >(argp1);
37267 {
37268 PyThreadState* __tstate = wxPyBeginAllowThreads();
37269 result = (wxValidator *)(arg1)->GetValidator();
37270 wxPyEndAllowThreads(__tstate);
37271 if (PyErr_Occurred()) SWIG_fail;
37272 }
37273 {
37274 resultobj = wxPyMake_wxObject(result, (bool)0);
37275 }
37276 return resultobj;
37277 fail:
37278 return NULL;
37279 }
37280
37281
37282 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37283 PyObject *resultobj = 0;
37284 wxWindow *arg1 = (wxWindow *) 0 ;
37285 bool result;
37286 void *argp1 = 0 ;
37287 int res1 = 0 ;
37288 PyObject *swig_obj[1] ;
37289
37290 if (!args) SWIG_fail;
37291 swig_obj[0] = args;
37292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37293 if (!SWIG_IsOK(res1)) {
37294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
37295 }
37296 arg1 = reinterpret_cast< wxWindow * >(argp1);
37297 {
37298 PyThreadState* __tstate = wxPyBeginAllowThreads();
37299 result = (bool)(arg1)->Validate();
37300 wxPyEndAllowThreads(__tstate);
37301 if (PyErr_Occurred()) SWIG_fail;
37302 }
37303 {
37304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37305 }
37306 return resultobj;
37307 fail:
37308 return NULL;
37309 }
37310
37311
37312 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37313 PyObject *resultobj = 0;
37314 wxWindow *arg1 = (wxWindow *) 0 ;
37315 bool result;
37316 void *argp1 = 0 ;
37317 int res1 = 0 ;
37318 PyObject *swig_obj[1] ;
37319
37320 if (!args) SWIG_fail;
37321 swig_obj[0] = args;
37322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37323 if (!SWIG_IsOK(res1)) {
37324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37325 }
37326 arg1 = reinterpret_cast< wxWindow * >(argp1);
37327 {
37328 PyThreadState* __tstate = wxPyBeginAllowThreads();
37329 result = (bool)(arg1)->TransferDataToWindow();
37330 wxPyEndAllowThreads(__tstate);
37331 if (PyErr_Occurred()) SWIG_fail;
37332 }
37333 {
37334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37335 }
37336 return resultobj;
37337 fail:
37338 return NULL;
37339 }
37340
37341
37342 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37343 PyObject *resultobj = 0;
37344 wxWindow *arg1 = (wxWindow *) 0 ;
37345 bool result;
37346 void *argp1 = 0 ;
37347 int res1 = 0 ;
37348 PyObject *swig_obj[1] ;
37349
37350 if (!args) SWIG_fail;
37351 swig_obj[0] = args;
37352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37353 if (!SWIG_IsOK(res1)) {
37354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37355 }
37356 arg1 = reinterpret_cast< wxWindow * >(argp1);
37357 {
37358 PyThreadState* __tstate = wxPyBeginAllowThreads();
37359 result = (bool)(arg1)->TransferDataFromWindow();
37360 wxPyEndAllowThreads(__tstate);
37361 if (PyErr_Occurred()) SWIG_fail;
37362 }
37363 {
37364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37365 }
37366 return resultobj;
37367 fail:
37368 return NULL;
37369 }
37370
37371
37372 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37373 PyObject *resultobj = 0;
37374 wxWindow *arg1 = (wxWindow *) 0 ;
37375 void *argp1 = 0 ;
37376 int res1 = 0 ;
37377 PyObject *swig_obj[1] ;
37378
37379 if (!args) SWIG_fail;
37380 swig_obj[0] = args;
37381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37382 if (!SWIG_IsOK(res1)) {
37383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37384 }
37385 arg1 = reinterpret_cast< wxWindow * >(argp1);
37386 {
37387 PyThreadState* __tstate = wxPyBeginAllowThreads();
37388 (arg1)->InitDialog();
37389 wxPyEndAllowThreads(__tstate);
37390 if (PyErr_Occurred()) SWIG_fail;
37391 }
37392 resultobj = SWIG_Py_Void();
37393 return resultobj;
37394 fail:
37395 return NULL;
37396 }
37397
37398
37399 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37400 PyObject *resultobj = 0;
37401 wxWindow *arg1 = (wxWindow *) 0 ;
37402 wxAcceleratorTable *arg2 = 0 ;
37403 void *argp1 = 0 ;
37404 int res1 = 0 ;
37405 void *argp2 = 0 ;
37406 int res2 = 0 ;
37407 PyObject * obj0 = 0 ;
37408 PyObject * obj1 = 0 ;
37409 char * kwnames[] = {
37410 (char *) "self",(char *) "accel", NULL
37411 };
37412
37413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37415 if (!SWIG_IsOK(res1)) {
37416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37417 }
37418 arg1 = reinterpret_cast< wxWindow * >(argp1);
37419 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37420 if (!SWIG_IsOK(res2)) {
37421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37422 }
37423 if (!argp2) {
37424 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37425 }
37426 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37427 {
37428 PyThreadState* __tstate = wxPyBeginAllowThreads();
37429 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37430 wxPyEndAllowThreads(__tstate);
37431 if (PyErr_Occurred()) SWIG_fail;
37432 }
37433 resultobj = SWIG_Py_Void();
37434 return resultobj;
37435 fail:
37436 return NULL;
37437 }
37438
37439
37440 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37441 PyObject *resultobj = 0;
37442 wxWindow *arg1 = (wxWindow *) 0 ;
37443 wxAcceleratorTable *result = 0 ;
37444 void *argp1 = 0 ;
37445 int res1 = 0 ;
37446 PyObject *swig_obj[1] ;
37447
37448 if (!args) SWIG_fail;
37449 swig_obj[0] = args;
37450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37451 if (!SWIG_IsOK(res1)) {
37452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37453 }
37454 arg1 = reinterpret_cast< wxWindow * >(argp1);
37455 {
37456 PyThreadState* __tstate = wxPyBeginAllowThreads();
37457 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37458 wxPyEndAllowThreads(__tstate);
37459 if (PyErr_Occurred()) SWIG_fail;
37460 }
37461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37462 return resultobj;
37463 fail:
37464 return NULL;
37465 }
37466
37467
37468 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37469 PyObject *resultobj = 0;
37470 wxWindow *arg1 = (wxWindow *) 0 ;
37471 int arg2 ;
37472 int arg3 ;
37473 int arg4 ;
37474 bool result;
37475 void *argp1 = 0 ;
37476 int res1 = 0 ;
37477 int val2 ;
37478 int ecode2 = 0 ;
37479 int val3 ;
37480 int ecode3 = 0 ;
37481 int val4 ;
37482 int ecode4 = 0 ;
37483 PyObject * obj0 = 0 ;
37484 PyObject * obj1 = 0 ;
37485 PyObject * obj2 = 0 ;
37486 PyObject * obj3 = 0 ;
37487 char * kwnames[] = {
37488 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37489 };
37490
37491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37493 if (!SWIG_IsOK(res1)) {
37494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37495 }
37496 arg1 = reinterpret_cast< wxWindow * >(argp1);
37497 ecode2 = SWIG_AsVal_int(obj1, &val2);
37498 if (!SWIG_IsOK(ecode2)) {
37499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37500 }
37501 arg2 = static_cast< int >(val2);
37502 ecode3 = SWIG_AsVal_int(obj2, &val3);
37503 if (!SWIG_IsOK(ecode3)) {
37504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37505 }
37506 arg3 = static_cast< int >(val3);
37507 ecode4 = SWIG_AsVal_int(obj3, &val4);
37508 if (!SWIG_IsOK(ecode4)) {
37509 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37510 }
37511 arg4 = static_cast< int >(val4);
37512 {
37513 PyThreadState* __tstate = wxPyBeginAllowThreads();
37514 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37515 wxPyEndAllowThreads(__tstate);
37516 if (PyErr_Occurred()) SWIG_fail;
37517 }
37518 {
37519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37520 }
37521 return resultobj;
37522 fail:
37523 return NULL;
37524 }
37525
37526
37527 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37528 PyObject *resultobj = 0;
37529 wxWindow *arg1 = (wxWindow *) 0 ;
37530 int arg2 ;
37531 bool result;
37532 void *argp1 = 0 ;
37533 int res1 = 0 ;
37534 int val2 ;
37535 int ecode2 = 0 ;
37536 PyObject * obj0 = 0 ;
37537 PyObject * obj1 = 0 ;
37538 char * kwnames[] = {
37539 (char *) "self",(char *) "hotkeyId", NULL
37540 };
37541
37542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37544 if (!SWIG_IsOK(res1)) {
37545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37546 }
37547 arg1 = reinterpret_cast< wxWindow * >(argp1);
37548 ecode2 = SWIG_AsVal_int(obj1, &val2);
37549 if (!SWIG_IsOK(ecode2)) {
37550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37551 }
37552 arg2 = static_cast< int >(val2);
37553 {
37554 PyThreadState* __tstate = wxPyBeginAllowThreads();
37555 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37556 wxPyEndAllowThreads(__tstate);
37557 if (PyErr_Occurred()) SWIG_fail;
37558 }
37559 {
37560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37561 }
37562 return resultobj;
37563 fail:
37564 return NULL;
37565 }
37566
37567
37568 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37569 PyObject *resultobj = 0;
37570 wxWindow *arg1 = (wxWindow *) 0 ;
37571 wxPoint *arg2 = 0 ;
37572 wxPoint result;
37573 void *argp1 = 0 ;
37574 int res1 = 0 ;
37575 wxPoint temp2 ;
37576 PyObject * obj0 = 0 ;
37577 PyObject * obj1 = 0 ;
37578 char * kwnames[] = {
37579 (char *) "self",(char *) "pt", NULL
37580 };
37581
37582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37584 if (!SWIG_IsOK(res1)) {
37585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37586 }
37587 arg1 = reinterpret_cast< wxWindow * >(argp1);
37588 {
37589 arg2 = &temp2;
37590 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37591 }
37592 {
37593 PyThreadState* __tstate = wxPyBeginAllowThreads();
37594 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37595 wxPyEndAllowThreads(__tstate);
37596 if (PyErr_Occurred()) SWIG_fail;
37597 }
37598 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37599 return resultobj;
37600 fail:
37601 return NULL;
37602 }
37603
37604
37605 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37606 PyObject *resultobj = 0;
37607 wxWindow *arg1 = (wxWindow *) 0 ;
37608 wxSize *arg2 = 0 ;
37609 wxSize result;
37610 void *argp1 = 0 ;
37611 int res1 = 0 ;
37612 wxSize temp2 ;
37613 PyObject * obj0 = 0 ;
37614 PyObject * obj1 = 0 ;
37615 char * kwnames[] = {
37616 (char *) "self",(char *) "sz", NULL
37617 };
37618
37619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37621 if (!SWIG_IsOK(res1)) {
37622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37623 }
37624 arg1 = reinterpret_cast< wxWindow * >(argp1);
37625 {
37626 arg2 = &temp2;
37627 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37628 }
37629 {
37630 PyThreadState* __tstate = wxPyBeginAllowThreads();
37631 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37632 wxPyEndAllowThreads(__tstate);
37633 if (PyErr_Occurred()) SWIG_fail;
37634 }
37635 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37636 return resultobj;
37637 fail:
37638 return NULL;
37639 }
37640
37641
37642 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37643 PyObject *resultobj = 0;
37644 wxWindow *arg1 = (wxWindow *) 0 ;
37645 wxPoint *arg2 = 0 ;
37646 wxPoint result;
37647 void *argp1 = 0 ;
37648 int res1 = 0 ;
37649 wxPoint temp2 ;
37650 PyObject * obj0 = 0 ;
37651 PyObject * obj1 = 0 ;
37652 char * kwnames[] = {
37653 (char *) "self",(char *) "pt", NULL
37654 };
37655
37656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37658 if (!SWIG_IsOK(res1)) {
37659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37660 }
37661 arg1 = reinterpret_cast< wxWindow * >(argp1);
37662 {
37663 arg2 = &temp2;
37664 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37665 }
37666 {
37667 PyThreadState* __tstate = wxPyBeginAllowThreads();
37668 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37669 wxPyEndAllowThreads(__tstate);
37670 if (PyErr_Occurred()) SWIG_fail;
37671 }
37672 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37673 return resultobj;
37674 fail:
37675 return NULL;
37676 }
37677
37678
37679 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37680 PyObject *resultobj = 0;
37681 wxWindow *arg1 = (wxWindow *) 0 ;
37682 wxSize *arg2 = 0 ;
37683 wxSize result;
37684 void *argp1 = 0 ;
37685 int res1 = 0 ;
37686 wxSize temp2 ;
37687 PyObject * obj0 = 0 ;
37688 PyObject * obj1 = 0 ;
37689 char * kwnames[] = {
37690 (char *) "self",(char *) "sz", NULL
37691 };
37692
37693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37695 if (!SWIG_IsOK(res1)) {
37696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37697 }
37698 arg1 = reinterpret_cast< wxWindow * >(argp1);
37699 {
37700 arg2 = &temp2;
37701 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37702 }
37703 {
37704 PyThreadState* __tstate = wxPyBeginAllowThreads();
37705 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37706 wxPyEndAllowThreads(__tstate);
37707 if (PyErr_Occurred()) SWIG_fail;
37708 }
37709 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37710 return resultobj;
37711 fail:
37712 return NULL;
37713 }
37714
37715
37716 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37717 PyObject *resultobj = 0;
37718 wxWindow *arg1 = (wxWindow *) 0 ;
37719 wxPoint *arg2 = 0 ;
37720 wxPoint result;
37721 void *argp1 = 0 ;
37722 int res1 = 0 ;
37723 wxPoint temp2 ;
37724 PyObject * obj0 = 0 ;
37725 PyObject * obj1 = 0 ;
37726 char * kwnames[] = {
37727 (char *) "self",(char *) "pt", NULL
37728 };
37729
37730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37732 if (!SWIG_IsOK(res1)) {
37733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37734 }
37735 arg1 = reinterpret_cast< wxWindow * >(argp1);
37736 {
37737 arg2 = &temp2;
37738 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37739 }
37740 {
37741 PyThreadState* __tstate = wxPyBeginAllowThreads();
37742 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37743 wxPyEndAllowThreads(__tstate);
37744 if (PyErr_Occurred()) SWIG_fail;
37745 }
37746 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37747 return resultobj;
37748 fail:
37749 return NULL;
37750 }
37751
37752
37753 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37754 PyObject *resultobj = 0;
37755 wxWindow *arg1 = (wxWindow *) 0 ;
37756 wxSize *arg2 = 0 ;
37757 wxSize result;
37758 void *argp1 = 0 ;
37759 int res1 = 0 ;
37760 wxSize temp2 ;
37761 PyObject * obj0 = 0 ;
37762 PyObject * obj1 = 0 ;
37763 char * kwnames[] = {
37764 (char *) "self",(char *) "sz", NULL
37765 };
37766
37767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37769 if (!SWIG_IsOK(res1)) {
37770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37771 }
37772 arg1 = reinterpret_cast< wxWindow * >(argp1);
37773 {
37774 arg2 = &temp2;
37775 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37776 }
37777 {
37778 PyThreadState* __tstate = wxPyBeginAllowThreads();
37779 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37780 wxPyEndAllowThreads(__tstate);
37781 if (PyErr_Occurred()) SWIG_fail;
37782 }
37783 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37784 return resultobj;
37785 fail:
37786 return NULL;
37787 }
37788
37789
37790 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37791 PyObject *resultobj = 0;
37792 wxWindow *arg1 = (wxWindow *) 0 ;
37793 int arg2 ;
37794 int arg3 ;
37795 void *argp1 = 0 ;
37796 int res1 = 0 ;
37797 int val2 ;
37798 int ecode2 = 0 ;
37799 int val3 ;
37800 int ecode3 = 0 ;
37801 PyObject * obj0 = 0 ;
37802 PyObject * obj1 = 0 ;
37803 PyObject * obj2 = 0 ;
37804 char * kwnames[] = {
37805 (char *) "self",(char *) "x",(char *) "y", NULL
37806 };
37807
37808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37810 if (!SWIG_IsOK(res1)) {
37811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37812 }
37813 arg1 = reinterpret_cast< wxWindow * >(argp1);
37814 ecode2 = SWIG_AsVal_int(obj1, &val2);
37815 if (!SWIG_IsOK(ecode2)) {
37816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37817 }
37818 arg2 = static_cast< int >(val2);
37819 ecode3 = SWIG_AsVal_int(obj2, &val3);
37820 if (!SWIG_IsOK(ecode3)) {
37821 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37822 }
37823 arg3 = static_cast< int >(val3);
37824 {
37825 PyThreadState* __tstate = wxPyBeginAllowThreads();
37826 (arg1)->WarpPointer(arg2,arg3);
37827 wxPyEndAllowThreads(__tstate);
37828 if (PyErr_Occurred()) SWIG_fail;
37829 }
37830 resultobj = SWIG_Py_Void();
37831 return resultobj;
37832 fail:
37833 return NULL;
37834 }
37835
37836
37837 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37838 PyObject *resultobj = 0;
37839 wxWindow *arg1 = (wxWindow *) 0 ;
37840 void *argp1 = 0 ;
37841 int res1 = 0 ;
37842 PyObject *swig_obj[1] ;
37843
37844 if (!args) SWIG_fail;
37845 swig_obj[0] = args;
37846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37847 if (!SWIG_IsOK(res1)) {
37848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37849 }
37850 arg1 = reinterpret_cast< wxWindow * >(argp1);
37851 {
37852 PyThreadState* __tstate = wxPyBeginAllowThreads();
37853 (arg1)->CaptureMouse();
37854 wxPyEndAllowThreads(__tstate);
37855 if (PyErr_Occurred()) SWIG_fail;
37856 }
37857 resultobj = SWIG_Py_Void();
37858 return resultobj;
37859 fail:
37860 return NULL;
37861 }
37862
37863
37864 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37865 PyObject *resultobj = 0;
37866 wxWindow *arg1 = (wxWindow *) 0 ;
37867 void *argp1 = 0 ;
37868 int res1 = 0 ;
37869 PyObject *swig_obj[1] ;
37870
37871 if (!args) SWIG_fail;
37872 swig_obj[0] = args;
37873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37874 if (!SWIG_IsOK(res1)) {
37875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37876 }
37877 arg1 = reinterpret_cast< wxWindow * >(argp1);
37878 {
37879 PyThreadState* __tstate = wxPyBeginAllowThreads();
37880 (arg1)->ReleaseMouse();
37881 wxPyEndAllowThreads(__tstate);
37882 if (PyErr_Occurred()) SWIG_fail;
37883 }
37884 resultobj = SWIG_Py_Void();
37885 return resultobj;
37886 fail:
37887 return NULL;
37888 }
37889
37890
37891 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37892 PyObject *resultobj = 0;
37893 wxWindow *result = 0 ;
37894
37895 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37896 {
37897 if (!wxPyCheckForApp()) SWIG_fail;
37898 PyThreadState* __tstate = wxPyBeginAllowThreads();
37899 result = (wxWindow *)wxWindow::GetCapture();
37900 wxPyEndAllowThreads(__tstate);
37901 if (PyErr_Occurred()) SWIG_fail;
37902 }
37903 {
37904 resultobj = wxPyMake_wxObject(result, 0);
37905 }
37906 return resultobj;
37907 fail:
37908 return NULL;
37909 }
37910
37911
37912 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37913 PyObject *resultobj = 0;
37914 wxWindow *arg1 = (wxWindow *) 0 ;
37915 bool result;
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_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37925 }
37926 arg1 = reinterpret_cast< wxWindow * >(argp1);
37927 {
37928 PyThreadState* __tstate = wxPyBeginAllowThreads();
37929 result = (bool)((wxWindow const *)arg1)->HasCapture();
37930 wxPyEndAllowThreads(__tstate);
37931 if (PyErr_Occurred()) SWIG_fail;
37932 }
37933 {
37934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37935 }
37936 return resultobj;
37937 fail:
37938 return NULL;
37939 }
37940
37941
37942 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37943 PyObject *resultobj = 0;
37944 wxWindow *arg1 = (wxWindow *) 0 ;
37945 bool arg2 = (bool) true ;
37946 wxRect *arg3 = (wxRect *) NULL ;
37947 void *argp1 = 0 ;
37948 int res1 = 0 ;
37949 bool val2 ;
37950 int ecode2 = 0 ;
37951 void *argp3 = 0 ;
37952 int res3 = 0 ;
37953 PyObject * obj0 = 0 ;
37954 PyObject * obj1 = 0 ;
37955 PyObject * obj2 = 0 ;
37956 char * kwnames[] = {
37957 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37958 };
37959
37960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37962 if (!SWIG_IsOK(res1)) {
37963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37964 }
37965 arg1 = reinterpret_cast< wxWindow * >(argp1);
37966 if (obj1) {
37967 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37968 if (!SWIG_IsOK(ecode2)) {
37969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37970 }
37971 arg2 = static_cast< bool >(val2);
37972 }
37973 if (obj2) {
37974 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37975 if (!SWIG_IsOK(res3)) {
37976 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37977 }
37978 arg3 = reinterpret_cast< wxRect * >(argp3);
37979 }
37980 {
37981 PyThreadState* __tstate = wxPyBeginAllowThreads();
37982 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37983 wxPyEndAllowThreads(__tstate);
37984 if (PyErr_Occurred()) SWIG_fail;
37985 }
37986 resultobj = SWIG_Py_Void();
37987 return resultobj;
37988 fail:
37989 return NULL;
37990 }
37991
37992
37993 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37994 PyObject *resultobj = 0;
37995 wxWindow *arg1 = (wxWindow *) 0 ;
37996 wxRect *arg2 = 0 ;
37997 bool arg3 = (bool) true ;
37998 void *argp1 = 0 ;
37999 int res1 = 0 ;
38000 wxRect temp2 ;
38001 bool val3 ;
38002 int ecode3 = 0 ;
38003 PyObject * obj0 = 0 ;
38004 PyObject * obj1 = 0 ;
38005 PyObject * obj2 = 0 ;
38006 char * kwnames[] = {
38007 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
38008 };
38009
38010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38012 if (!SWIG_IsOK(res1)) {
38013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
38014 }
38015 arg1 = reinterpret_cast< wxWindow * >(argp1);
38016 {
38017 arg2 = &temp2;
38018 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38019 }
38020 if (obj2) {
38021 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38022 if (!SWIG_IsOK(ecode3)) {
38023 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
38024 }
38025 arg3 = static_cast< bool >(val3);
38026 }
38027 {
38028 PyThreadState* __tstate = wxPyBeginAllowThreads();
38029 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
38030 wxPyEndAllowThreads(__tstate);
38031 if (PyErr_Occurred()) SWIG_fail;
38032 }
38033 resultobj = SWIG_Py_Void();
38034 return resultobj;
38035 fail:
38036 return NULL;
38037 }
38038
38039
38040 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38041 PyObject *resultobj = 0;
38042 wxWindow *arg1 = (wxWindow *) 0 ;
38043 void *argp1 = 0 ;
38044 int res1 = 0 ;
38045 PyObject *swig_obj[1] ;
38046
38047 if (!args) SWIG_fail;
38048 swig_obj[0] = args;
38049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38050 if (!SWIG_IsOK(res1)) {
38051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
38052 }
38053 arg1 = reinterpret_cast< wxWindow * >(argp1);
38054 {
38055 PyThreadState* __tstate = wxPyBeginAllowThreads();
38056 (arg1)->Update();
38057 wxPyEndAllowThreads(__tstate);
38058 if (PyErr_Occurred()) SWIG_fail;
38059 }
38060 resultobj = SWIG_Py_Void();
38061 return resultobj;
38062 fail:
38063 return NULL;
38064 }
38065
38066
38067 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38068 PyObject *resultobj = 0;
38069 wxWindow *arg1 = (wxWindow *) 0 ;
38070 void *argp1 = 0 ;
38071 int res1 = 0 ;
38072 PyObject *swig_obj[1] ;
38073
38074 if (!args) SWIG_fail;
38075 swig_obj[0] = args;
38076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38077 if (!SWIG_IsOK(res1)) {
38078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38079 }
38080 arg1 = reinterpret_cast< wxWindow * >(argp1);
38081 {
38082 PyThreadState* __tstate = wxPyBeginAllowThreads();
38083 (arg1)->ClearBackground();
38084 wxPyEndAllowThreads(__tstate);
38085 if (PyErr_Occurred()) SWIG_fail;
38086 }
38087 resultobj = SWIG_Py_Void();
38088 return resultobj;
38089 fail:
38090 return NULL;
38091 }
38092
38093
38094 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38095 PyObject *resultobj = 0;
38096 wxWindow *arg1 = (wxWindow *) 0 ;
38097 void *argp1 = 0 ;
38098 int res1 = 0 ;
38099 PyObject *swig_obj[1] ;
38100
38101 if (!args) SWIG_fail;
38102 swig_obj[0] = args;
38103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38104 if (!SWIG_IsOK(res1)) {
38105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
38106 }
38107 arg1 = reinterpret_cast< wxWindow * >(argp1);
38108 {
38109 PyThreadState* __tstate = wxPyBeginAllowThreads();
38110 (arg1)->Freeze();
38111 wxPyEndAllowThreads(__tstate);
38112 if (PyErr_Occurred()) SWIG_fail;
38113 }
38114 resultobj = SWIG_Py_Void();
38115 return resultobj;
38116 fail:
38117 return NULL;
38118 }
38119
38120
38121 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38122 PyObject *resultobj = 0;
38123 wxWindow *arg1 = (wxWindow *) 0 ;
38124 bool result;
38125 void *argp1 = 0 ;
38126 int res1 = 0 ;
38127 PyObject *swig_obj[1] ;
38128
38129 if (!args) SWIG_fail;
38130 swig_obj[0] = args;
38131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38132 if (!SWIG_IsOK(res1)) {
38133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
38134 }
38135 arg1 = reinterpret_cast< wxWindow * >(argp1);
38136 {
38137 PyThreadState* __tstate = wxPyBeginAllowThreads();
38138 result = (bool)((wxWindow const *)arg1)->IsFrozen();
38139 wxPyEndAllowThreads(__tstate);
38140 if (PyErr_Occurred()) SWIG_fail;
38141 }
38142 {
38143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38144 }
38145 return resultobj;
38146 fail:
38147 return NULL;
38148 }
38149
38150
38151 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38152 PyObject *resultobj = 0;
38153 wxWindow *arg1 = (wxWindow *) 0 ;
38154 void *argp1 = 0 ;
38155 int res1 = 0 ;
38156 PyObject *swig_obj[1] ;
38157
38158 if (!args) SWIG_fail;
38159 swig_obj[0] = args;
38160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38161 if (!SWIG_IsOK(res1)) {
38162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
38163 }
38164 arg1 = reinterpret_cast< wxWindow * >(argp1);
38165 {
38166 PyThreadState* __tstate = wxPyBeginAllowThreads();
38167 (arg1)->Thaw();
38168 wxPyEndAllowThreads(__tstate);
38169 if (PyErr_Occurred()) SWIG_fail;
38170 }
38171 resultobj = SWIG_Py_Void();
38172 return resultobj;
38173 fail:
38174 return NULL;
38175 }
38176
38177
38178 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38179 PyObject *resultobj = 0;
38180 wxWindow *arg1 = (wxWindow *) 0 ;
38181 wxDC *arg2 = 0 ;
38182 void *argp1 = 0 ;
38183 int res1 = 0 ;
38184 void *argp2 = 0 ;
38185 int res2 = 0 ;
38186 PyObject * obj0 = 0 ;
38187 PyObject * obj1 = 0 ;
38188 char * kwnames[] = {
38189 (char *) "self",(char *) "dc", NULL
38190 };
38191
38192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
38193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38194 if (!SWIG_IsOK(res1)) {
38195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
38196 }
38197 arg1 = reinterpret_cast< wxWindow * >(argp1);
38198 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
38199 if (!SWIG_IsOK(res2)) {
38200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38201 }
38202 if (!argp2) {
38203 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38204 }
38205 arg2 = reinterpret_cast< wxDC * >(argp2);
38206 {
38207 PyThreadState* __tstate = wxPyBeginAllowThreads();
38208 (arg1)->PrepareDC(*arg2);
38209 wxPyEndAllowThreads(__tstate);
38210 if (PyErr_Occurred()) SWIG_fail;
38211 }
38212 resultobj = SWIG_Py_Void();
38213 return resultobj;
38214 fail:
38215 return NULL;
38216 }
38217
38218
38219 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38220 PyObject *resultobj = 0;
38221 wxWindow *arg1 = (wxWindow *) 0 ;
38222 bool result;
38223 void *argp1 = 0 ;
38224 int res1 = 0 ;
38225 PyObject *swig_obj[1] ;
38226
38227 if (!args) SWIG_fail;
38228 swig_obj[0] = args;
38229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38230 if (!SWIG_IsOK(res1)) {
38231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
38232 }
38233 arg1 = reinterpret_cast< wxWindow * >(argp1);
38234 {
38235 PyThreadState* __tstate = wxPyBeginAllowThreads();
38236 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
38237 wxPyEndAllowThreads(__tstate);
38238 if (PyErr_Occurred()) SWIG_fail;
38239 }
38240 {
38241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38242 }
38243 return resultobj;
38244 fail:
38245 return NULL;
38246 }
38247
38248
38249 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38250 PyObject *resultobj = 0;
38251 wxWindow *arg1 = (wxWindow *) 0 ;
38252 wxRegion *result = 0 ;
38253 void *argp1 = 0 ;
38254 int res1 = 0 ;
38255 PyObject *swig_obj[1] ;
38256
38257 if (!args) SWIG_fail;
38258 swig_obj[0] = args;
38259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38260 if (!SWIG_IsOK(res1)) {
38261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
38262 }
38263 arg1 = reinterpret_cast< wxWindow * >(argp1);
38264 {
38265 PyThreadState* __tstate = wxPyBeginAllowThreads();
38266 {
38267 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
38268 result = (wxRegion *) &_result_ref;
38269 }
38270 wxPyEndAllowThreads(__tstate);
38271 if (PyErr_Occurred()) SWIG_fail;
38272 }
38273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
38274 return resultobj;
38275 fail:
38276 return NULL;
38277 }
38278
38279
38280 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38281 PyObject *resultobj = 0;
38282 wxWindow *arg1 = (wxWindow *) 0 ;
38283 wxRect result;
38284 void *argp1 = 0 ;
38285 int res1 = 0 ;
38286 PyObject *swig_obj[1] ;
38287
38288 if (!args) SWIG_fail;
38289 swig_obj[0] = args;
38290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38291 if (!SWIG_IsOK(res1)) {
38292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38293 }
38294 arg1 = reinterpret_cast< wxWindow * >(argp1);
38295 {
38296 PyThreadState* __tstate = wxPyBeginAllowThreads();
38297 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
38298 wxPyEndAllowThreads(__tstate);
38299 if (PyErr_Occurred()) SWIG_fail;
38300 }
38301 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
38302 return resultobj;
38303 fail:
38304 return NULL;
38305 }
38306
38307
38308 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38309 PyObject *resultobj = 0;
38310 wxWindow *arg1 = (wxWindow *) 0 ;
38311 int arg2 ;
38312 int arg3 ;
38313 int arg4 = (int) 1 ;
38314 int arg5 = (int) 1 ;
38315 bool result;
38316 void *argp1 = 0 ;
38317 int res1 = 0 ;
38318 int val2 ;
38319 int ecode2 = 0 ;
38320 int val3 ;
38321 int ecode3 = 0 ;
38322 int val4 ;
38323 int ecode4 = 0 ;
38324 int val5 ;
38325 int ecode5 = 0 ;
38326 PyObject * obj0 = 0 ;
38327 PyObject * obj1 = 0 ;
38328 PyObject * obj2 = 0 ;
38329 PyObject * obj3 = 0 ;
38330 PyObject * obj4 = 0 ;
38331 char * kwnames[] = {
38332 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
38333 };
38334
38335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38337 if (!SWIG_IsOK(res1)) {
38338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
38339 }
38340 arg1 = reinterpret_cast< wxWindow * >(argp1);
38341 ecode2 = SWIG_AsVal_int(obj1, &val2);
38342 if (!SWIG_IsOK(ecode2)) {
38343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38344 }
38345 arg2 = static_cast< int >(val2);
38346 ecode3 = SWIG_AsVal_int(obj2, &val3);
38347 if (!SWIG_IsOK(ecode3)) {
38348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38349 }
38350 arg3 = static_cast< int >(val3);
38351 if (obj3) {
38352 ecode4 = SWIG_AsVal_int(obj3, &val4);
38353 if (!SWIG_IsOK(ecode4)) {
38354 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38355 }
38356 arg4 = static_cast< int >(val4);
38357 }
38358 if (obj4) {
38359 ecode5 = SWIG_AsVal_int(obj4, &val5);
38360 if (!SWIG_IsOK(ecode5)) {
38361 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38362 }
38363 arg5 = static_cast< int >(val5);
38364 }
38365 {
38366 PyThreadState* __tstate = wxPyBeginAllowThreads();
38367 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38368 wxPyEndAllowThreads(__tstate);
38369 if (PyErr_Occurred()) SWIG_fail;
38370 }
38371 {
38372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38373 }
38374 return resultobj;
38375 fail:
38376 return NULL;
38377 }
38378
38379
38380 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38381 PyObject *resultobj = 0;
38382 wxWindow *arg1 = (wxWindow *) 0 ;
38383 wxPoint *arg2 = 0 ;
38384 bool result;
38385 void *argp1 = 0 ;
38386 int res1 = 0 ;
38387 wxPoint temp2 ;
38388 PyObject * obj0 = 0 ;
38389 PyObject * obj1 = 0 ;
38390 char * kwnames[] = {
38391 (char *) "self",(char *) "pt", NULL
38392 };
38393
38394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38396 if (!SWIG_IsOK(res1)) {
38397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38398 }
38399 arg1 = reinterpret_cast< wxWindow * >(argp1);
38400 {
38401 arg2 = &temp2;
38402 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38403 }
38404 {
38405 PyThreadState* __tstate = wxPyBeginAllowThreads();
38406 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38407 wxPyEndAllowThreads(__tstate);
38408 if (PyErr_Occurred()) SWIG_fail;
38409 }
38410 {
38411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38412 }
38413 return resultobj;
38414 fail:
38415 return NULL;
38416 }
38417
38418
38419 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38420 PyObject *resultobj = 0;
38421 wxWindow *arg1 = (wxWindow *) 0 ;
38422 wxRect *arg2 = 0 ;
38423 bool result;
38424 void *argp1 = 0 ;
38425 int res1 = 0 ;
38426 wxRect temp2 ;
38427 PyObject * obj0 = 0 ;
38428 PyObject * obj1 = 0 ;
38429 char * kwnames[] = {
38430 (char *) "self",(char *) "rect", NULL
38431 };
38432
38433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38435 if (!SWIG_IsOK(res1)) {
38436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38437 }
38438 arg1 = reinterpret_cast< wxWindow * >(argp1);
38439 {
38440 arg2 = &temp2;
38441 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38442 }
38443 {
38444 PyThreadState* __tstate = wxPyBeginAllowThreads();
38445 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38446 wxPyEndAllowThreads(__tstate);
38447 if (PyErr_Occurred()) SWIG_fail;
38448 }
38449 {
38450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38451 }
38452 return resultobj;
38453 fail:
38454 return NULL;
38455 }
38456
38457
38458 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38459 PyObject *resultobj = 0;
38460 wxWindow *arg1 = (wxWindow *) 0 ;
38461 SwigValueWrapper<wxVisualAttributes > result;
38462 void *argp1 = 0 ;
38463 int res1 = 0 ;
38464 PyObject *swig_obj[1] ;
38465
38466 if (!args) SWIG_fail;
38467 swig_obj[0] = args;
38468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38469 if (!SWIG_IsOK(res1)) {
38470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38471 }
38472 arg1 = reinterpret_cast< wxWindow * >(argp1);
38473 {
38474 PyThreadState* __tstate = wxPyBeginAllowThreads();
38475 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38476 wxPyEndAllowThreads(__tstate);
38477 if (PyErr_Occurred()) SWIG_fail;
38478 }
38479 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38480 return resultobj;
38481 fail:
38482 return NULL;
38483 }
38484
38485
38486 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38487 PyObject *resultobj = 0;
38488 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38489 SwigValueWrapper<wxVisualAttributes > result;
38490 int val1 ;
38491 int ecode1 = 0 ;
38492 PyObject * obj0 = 0 ;
38493 char * kwnames[] = {
38494 (char *) "variant", NULL
38495 };
38496
38497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38498 if (obj0) {
38499 ecode1 = SWIG_AsVal_int(obj0, &val1);
38500 if (!SWIG_IsOK(ecode1)) {
38501 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38502 }
38503 arg1 = static_cast< wxWindowVariant >(val1);
38504 }
38505 {
38506 if (!wxPyCheckForApp()) SWIG_fail;
38507 PyThreadState* __tstate = wxPyBeginAllowThreads();
38508 result = wxWindow::GetClassDefaultAttributes(arg1);
38509 wxPyEndAllowThreads(__tstate);
38510 if (PyErr_Occurred()) SWIG_fail;
38511 }
38512 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38513 return resultobj;
38514 fail:
38515 return NULL;
38516 }
38517
38518
38519 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38520 PyObject *resultobj = 0;
38521 wxWindow *arg1 = (wxWindow *) 0 ;
38522 wxColour *arg2 = 0 ;
38523 bool result;
38524 void *argp1 = 0 ;
38525 int res1 = 0 ;
38526 wxColour temp2 ;
38527 PyObject * obj0 = 0 ;
38528 PyObject * obj1 = 0 ;
38529 char * kwnames[] = {
38530 (char *) "self",(char *) "colour", NULL
38531 };
38532
38533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38535 if (!SWIG_IsOK(res1)) {
38536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38537 }
38538 arg1 = reinterpret_cast< wxWindow * >(argp1);
38539 {
38540 arg2 = &temp2;
38541 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38542 }
38543 {
38544 PyThreadState* __tstate = wxPyBeginAllowThreads();
38545 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38546 wxPyEndAllowThreads(__tstate);
38547 if (PyErr_Occurred()) SWIG_fail;
38548 }
38549 {
38550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38551 }
38552 return resultobj;
38553 fail:
38554 return NULL;
38555 }
38556
38557
38558 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38559 PyObject *resultobj = 0;
38560 wxWindow *arg1 = (wxWindow *) 0 ;
38561 wxColour *arg2 = 0 ;
38562 void *argp1 = 0 ;
38563 int res1 = 0 ;
38564 wxColour temp2 ;
38565 PyObject * obj0 = 0 ;
38566 PyObject * obj1 = 0 ;
38567 char * kwnames[] = {
38568 (char *) "self",(char *) "colour", NULL
38569 };
38570
38571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38573 if (!SWIG_IsOK(res1)) {
38574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38575 }
38576 arg1 = reinterpret_cast< wxWindow * >(argp1);
38577 {
38578 arg2 = &temp2;
38579 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38580 }
38581 {
38582 PyThreadState* __tstate = wxPyBeginAllowThreads();
38583 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38584 wxPyEndAllowThreads(__tstate);
38585 if (PyErr_Occurred()) SWIG_fail;
38586 }
38587 resultobj = SWIG_Py_Void();
38588 return resultobj;
38589 fail:
38590 return NULL;
38591 }
38592
38593
38594 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38595 PyObject *resultobj = 0;
38596 wxWindow *arg1 = (wxWindow *) 0 ;
38597 wxColour *arg2 = 0 ;
38598 bool result;
38599 void *argp1 = 0 ;
38600 int res1 = 0 ;
38601 wxColour temp2 ;
38602 PyObject * obj0 = 0 ;
38603 PyObject * obj1 = 0 ;
38604 char * kwnames[] = {
38605 (char *) "self",(char *) "colour", NULL
38606 };
38607
38608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38610 if (!SWIG_IsOK(res1)) {
38611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38612 }
38613 arg1 = reinterpret_cast< wxWindow * >(argp1);
38614 {
38615 arg2 = &temp2;
38616 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38617 }
38618 {
38619 PyThreadState* __tstate = wxPyBeginAllowThreads();
38620 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38621 wxPyEndAllowThreads(__tstate);
38622 if (PyErr_Occurred()) SWIG_fail;
38623 }
38624 {
38625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38626 }
38627 return resultobj;
38628 fail:
38629 return NULL;
38630 }
38631
38632
38633 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38634 PyObject *resultobj = 0;
38635 wxWindow *arg1 = (wxWindow *) 0 ;
38636 wxColour *arg2 = 0 ;
38637 void *argp1 = 0 ;
38638 int res1 = 0 ;
38639 wxColour temp2 ;
38640 PyObject * obj0 = 0 ;
38641 PyObject * obj1 = 0 ;
38642 char * kwnames[] = {
38643 (char *) "self",(char *) "colour", NULL
38644 };
38645
38646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38648 if (!SWIG_IsOK(res1)) {
38649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38650 }
38651 arg1 = reinterpret_cast< wxWindow * >(argp1);
38652 {
38653 arg2 = &temp2;
38654 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38655 }
38656 {
38657 PyThreadState* __tstate = wxPyBeginAllowThreads();
38658 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38659 wxPyEndAllowThreads(__tstate);
38660 if (PyErr_Occurred()) SWIG_fail;
38661 }
38662 resultobj = SWIG_Py_Void();
38663 return resultobj;
38664 fail:
38665 return NULL;
38666 }
38667
38668
38669 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38670 PyObject *resultobj = 0;
38671 wxWindow *arg1 = (wxWindow *) 0 ;
38672 wxColour result;
38673 void *argp1 = 0 ;
38674 int res1 = 0 ;
38675 PyObject *swig_obj[1] ;
38676
38677 if (!args) SWIG_fail;
38678 swig_obj[0] = args;
38679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38680 if (!SWIG_IsOK(res1)) {
38681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38682 }
38683 arg1 = reinterpret_cast< wxWindow * >(argp1);
38684 {
38685 PyThreadState* __tstate = wxPyBeginAllowThreads();
38686 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38687 wxPyEndAllowThreads(__tstate);
38688 if (PyErr_Occurred()) SWIG_fail;
38689 }
38690 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38691 return resultobj;
38692 fail:
38693 return NULL;
38694 }
38695
38696
38697 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38698 PyObject *resultobj = 0;
38699 wxWindow *arg1 = (wxWindow *) 0 ;
38700 wxColour result;
38701 void *argp1 = 0 ;
38702 int res1 = 0 ;
38703 PyObject *swig_obj[1] ;
38704
38705 if (!args) SWIG_fail;
38706 swig_obj[0] = args;
38707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38708 if (!SWIG_IsOK(res1)) {
38709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38710 }
38711 arg1 = reinterpret_cast< wxWindow * >(argp1);
38712 {
38713 PyThreadState* __tstate = wxPyBeginAllowThreads();
38714 result = ((wxWindow const *)arg1)->GetForegroundColour();
38715 wxPyEndAllowThreads(__tstate);
38716 if (PyErr_Occurred()) SWIG_fail;
38717 }
38718 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38719 return resultobj;
38720 fail:
38721 return NULL;
38722 }
38723
38724
38725 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38726 PyObject *resultobj = 0;
38727 wxWindow *arg1 = (wxWindow *) 0 ;
38728 bool result;
38729 void *argp1 = 0 ;
38730 int res1 = 0 ;
38731 PyObject *swig_obj[1] ;
38732
38733 if (!args) SWIG_fail;
38734 swig_obj[0] = args;
38735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38736 if (!SWIG_IsOK(res1)) {
38737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38738 }
38739 arg1 = reinterpret_cast< wxWindow * >(argp1);
38740 {
38741 PyThreadState* __tstate = wxPyBeginAllowThreads();
38742 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38743 wxPyEndAllowThreads(__tstate);
38744 if (PyErr_Occurred()) SWIG_fail;
38745 }
38746 {
38747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38748 }
38749 return resultobj;
38750 fail:
38751 return NULL;
38752 }
38753
38754
38755 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38756 PyObject *resultobj = 0;
38757 wxWindow *arg1 = (wxWindow *) 0 ;
38758 bool result;
38759 void *argp1 = 0 ;
38760 int res1 = 0 ;
38761 PyObject *swig_obj[1] ;
38762
38763 if (!args) SWIG_fail;
38764 swig_obj[0] = args;
38765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38766 if (!SWIG_IsOK(res1)) {
38767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38768 }
38769 arg1 = reinterpret_cast< wxWindow * >(argp1);
38770 {
38771 PyThreadState* __tstate = wxPyBeginAllowThreads();
38772 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38773 wxPyEndAllowThreads(__tstate);
38774 if (PyErr_Occurred()) SWIG_fail;
38775 }
38776 {
38777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38778 }
38779 return resultobj;
38780 fail:
38781 return NULL;
38782 }
38783
38784
38785 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38786 PyObject *resultobj = 0;
38787 wxWindow *arg1 = (wxWindow *) 0 ;
38788 wxBackgroundStyle arg2 ;
38789 bool result;
38790 void *argp1 = 0 ;
38791 int res1 = 0 ;
38792 int val2 ;
38793 int ecode2 = 0 ;
38794 PyObject * obj0 = 0 ;
38795 PyObject * obj1 = 0 ;
38796 char * kwnames[] = {
38797 (char *) "self",(char *) "style", NULL
38798 };
38799
38800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38802 if (!SWIG_IsOK(res1)) {
38803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38804 }
38805 arg1 = reinterpret_cast< wxWindow * >(argp1);
38806 ecode2 = SWIG_AsVal_int(obj1, &val2);
38807 if (!SWIG_IsOK(ecode2)) {
38808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38809 }
38810 arg2 = static_cast< wxBackgroundStyle >(val2);
38811 {
38812 PyThreadState* __tstate = wxPyBeginAllowThreads();
38813 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38814 wxPyEndAllowThreads(__tstate);
38815 if (PyErr_Occurred()) SWIG_fail;
38816 }
38817 {
38818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38819 }
38820 return resultobj;
38821 fail:
38822 return NULL;
38823 }
38824
38825
38826 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38827 PyObject *resultobj = 0;
38828 wxWindow *arg1 = (wxWindow *) 0 ;
38829 wxBackgroundStyle result;
38830 void *argp1 = 0 ;
38831 int res1 = 0 ;
38832 PyObject *swig_obj[1] ;
38833
38834 if (!args) SWIG_fail;
38835 swig_obj[0] = args;
38836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38837 if (!SWIG_IsOK(res1)) {
38838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38839 }
38840 arg1 = reinterpret_cast< wxWindow * >(argp1);
38841 {
38842 PyThreadState* __tstate = wxPyBeginAllowThreads();
38843 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38844 wxPyEndAllowThreads(__tstate);
38845 if (PyErr_Occurred()) SWIG_fail;
38846 }
38847 resultobj = SWIG_From_int(static_cast< int >(result));
38848 return resultobj;
38849 fail:
38850 return NULL;
38851 }
38852
38853
38854 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38855 PyObject *resultobj = 0;
38856 wxWindow *arg1 = (wxWindow *) 0 ;
38857 bool result;
38858 void *argp1 = 0 ;
38859 int res1 = 0 ;
38860 PyObject *swig_obj[1] ;
38861
38862 if (!args) SWIG_fail;
38863 swig_obj[0] = args;
38864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38865 if (!SWIG_IsOK(res1)) {
38866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38867 }
38868 arg1 = reinterpret_cast< wxWindow * >(argp1);
38869 {
38870 PyThreadState* __tstate = wxPyBeginAllowThreads();
38871 result = (bool)(arg1)->HasTransparentBackground();
38872 wxPyEndAllowThreads(__tstate);
38873 if (PyErr_Occurred()) SWIG_fail;
38874 }
38875 {
38876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38877 }
38878 return resultobj;
38879 fail:
38880 return NULL;
38881 }
38882
38883
38884 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38885 PyObject *resultobj = 0;
38886 wxWindow *arg1 = (wxWindow *) 0 ;
38887 wxCursor *arg2 = 0 ;
38888 bool result;
38889 void *argp1 = 0 ;
38890 int res1 = 0 ;
38891 void *argp2 = 0 ;
38892 int res2 = 0 ;
38893 PyObject * obj0 = 0 ;
38894 PyObject * obj1 = 0 ;
38895 char * kwnames[] = {
38896 (char *) "self",(char *) "cursor", NULL
38897 };
38898
38899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38901 if (!SWIG_IsOK(res1)) {
38902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38903 }
38904 arg1 = reinterpret_cast< wxWindow * >(argp1);
38905 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38906 if (!SWIG_IsOK(res2)) {
38907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38908 }
38909 if (!argp2) {
38910 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38911 }
38912 arg2 = reinterpret_cast< wxCursor * >(argp2);
38913 {
38914 PyThreadState* __tstate = wxPyBeginAllowThreads();
38915 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38916 wxPyEndAllowThreads(__tstate);
38917 if (PyErr_Occurred()) SWIG_fail;
38918 }
38919 {
38920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38921 }
38922 return resultobj;
38923 fail:
38924 return NULL;
38925 }
38926
38927
38928 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38929 PyObject *resultobj = 0;
38930 wxWindow *arg1 = (wxWindow *) 0 ;
38931 wxCursor result;
38932 void *argp1 = 0 ;
38933 int res1 = 0 ;
38934 PyObject *swig_obj[1] ;
38935
38936 if (!args) SWIG_fail;
38937 swig_obj[0] = args;
38938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38939 if (!SWIG_IsOK(res1)) {
38940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38941 }
38942 arg1 = reinterpret_cast< wxWindow * >(argp1);
38943 {
38944 PyThreadState* __tstate = wxPyBeginAllowThreads();
38945 result = (arg1)->GetCursor();
38946 wxPyEndAllowThreads(__tstate);
38947 if (PyErr_Occurred()) SWIG_fail;
38948 }
38949 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38950 return resultobj;
38951 fail:
38952 return NULL;
38953 }
38954
38955
38956 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38957 PyObject *resultobj = 0;
38958 wxWindow *arg1 = (wxWindow *) 0 ;
38959 wxFont *arg2 = 0 ;
38960 bool result;
38961 void *argp1 = 0 ;
38962 int res1 = 0 ;
38963 void *argp2 = 0 ;
38964 int res2 = 0 ;
38965 PyObject * obj0 = 0 ;
38966 PyObject * obj1 = 0 ;
38967 char * kwnames[] = {
38968 (char *) "self",(char *) "font", NULL
38969 };
38970
38971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38973 if (!SWIG_IsOK(res1)) {
38974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38975 }
38976 arg1 = reinterpret_cast< wxWindow * >(argp1);
38977 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38978 if (!SWIG_IsOK(res2)) {
38979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38980 }
38981 if (!argp2) {
38982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38983 }
38984 arg2 = reinterpret_cast< wxFont * >(argp2);
38985 {
38986 PyThreadState* __tstate = wxPyBeginAllowThreads();
38987 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38988 wxPyEndAllowThreads(__tstate);
38989 if (PyErr_Occurred()) SWIG_fail;
38990 }
38991 {
38992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38993 }
38994 return resultobj;
38995 fail:
38996 return NULL;
38997 }
38998
38999
39000 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39001 PyObject *resultobj = 0;
39002 wxWindow *arg1 = (wxWindow *) 0 ;
39003 wxFont *arg2 = 0 ;
39004 void *argp1 = 0 ;
39005 int res1 = 0 ;
39006 void *argp2 = 0 ;
39007 int res2 = 0 ;
39008 PyObject * obj0 = 0 ;
39009 PyObject * obj1 = 0 ;
39010 char * kwnames[] = {
39011 (char *) "self",(char *) "font", NULL
39012 };
39013
39014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
39015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39016 if (!SWIG_IsOK(res1)) {
39017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39018 }
39019 arg1 = reinterpret_cast< wxWindow * >(argp1);
39020 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
39021 if (!SWIG_IsOK(res2)) {
39022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39023 }
39024 if (!argp2) {
39025 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39026 }
39027 arg2 = reinterpret_cast< wxFont * >(argp2);
39028 {
39029 PyThreadState* __tstate = wxPyBeginAllowThreads();
39030 (arg1)->SetOwnFont((wxFont const &)*arg2);
39031 wxPyEndAllowThreads(__tstate);
39032 if (PyErr_Occurred()) SWIG_fail;
39033 }
39034 resultobj = SWIG_Py_Void();
39035 return resultobj;
39036 fail:
39037 return NULL;
39038 }
39039
39040
39041 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39042 PyObject *resultobj = 0;
39043 wxWindow *arg1 = (wxWindow *) 0 ;
39044 wxFont result;
39045 void *argp1 = 0 ;
39046 int res1 = 0 ;
39047 PyObject *swig_obj[1] ;
39048
39049 if (!args) SWIG_fail;
39050 swig_obj[0] = args;
39051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39052 if (!SWIG_IsOK(res1)) {
39053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39054 }
39055 arg1 = reinterpret_cast< wxWindow * >(argp1);
39056 {
39057 PyThreadState* __tstate = wxPyBeginAllowThreads();
39058 result = (arg1)->GetFont();
39059 wxPyEndAllowThreads(__tstate);
39060 if (PyErr_Occurred()) SWIG_fail;
39061 }
39062 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
39063 return resultobj;
39064 fail:
39065 return NULL;
39066 }
39067
39068
39069 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39070 PyObject *resultobj = 0;
39071 wxWindow *arg1 = (wxWindow *) 0 ;
39072 wxCaret *arg2 = (wxCaret *) 0 ;
39073 void *argp1 = 0 ;
39074 int res1 = 0 ;
39075 int res2 = 0 ;
39076 PyObject * obj0 = 0 ;
39077 PyObject * obj1 = 0 ;
39078 char * kwnames[] = {
39079 (char *) "self",(char *) "caret", NULL
39080 };
39081
39082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
39083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39084 if (!SWIG_IsOK(res1)) {
39085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
39086 }
39087 arg1 = reinterpret_cast< wxWindow * >(argp1);
39088 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
39089 if (!SWIG_IsOK(res2)) {
39090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
39091 }
39092 {
39093 PyThreadState* __tstate = wxPyBeginAllowThreads();
39094 (arg1)->SetCaret(arg2);
39095 wxPyEndAllowThreads(__tstate);
39096 if (PyErr_Occurred()) SWIG_fail;
39097 }
39098 resultobj = SWIG_Py_Void();
39099 return resultobj;
39100 fail:
39101 return NULL;
39102 }
39103
39104
39105 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39106 PyObject *resultobj = 0;
39107 wxWindow *arg1 = (wxWindow *) 0 ;
39108 wxCaret *result = 0 ;
39109 void *argp1 = 0 ;
39110 int res1 = 0 ;
39111 PyObject *swig_obj[1] ;
39112
39113 if (!args) SWIG_fail;
39114 swig_obj[0] = args;
39115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39116 if (!SWIG_IsOK(res1)) {
39117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
39118 }
39119 arg1 = reinterpret_cast< wxWindow * >(argp1);
39120 {
39121 PyThreadState* __tstate = wxPyBeginAllowThreads();
39122 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
39123 wxPyEndAllowThreads(__tstate);
39124 if (PyErr_Occurred()) SWIG_fail;
39125 }
39126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
39127 return resultobj;
39128 fail:
39129 return NULL;
39130 }
39131
39132
39133 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39134 PyObject *resultobj = 0;
39135 wxWindow *arg1 = (wxWindow *) 0 ;
39136 int result;
39137 void *argp1 = 0 ;
39138 int res1 = 0 ;
39139 PyObject *swig_obj[1] ;
39140
39141 if (!args) SWIG_fail;
39142 swig_obj[0] = args;
39143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39144 if (!SWIG_IsOK(res1)) {
39145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
39146 }
39147 arg1 = reinterpret_cast< wxWindow * >(argp1);
39148 {
39149 PyThreadState* __tstate = wxPyBeginAllowThreads();
39150 result = (int)((wxWindow const *)arg1)->GetCharHeight();
39151 wxPyEndAllowThreads(__tstate);
39152 if (PyErr_Occurred()) SWIG_fail;
39153 }
39154 resultobj = SWIG_From_int(static_cast< int >(result));
39155 return resultobj;
39156 fail:
39157 return NULL;
39158 }
39159
39160
39161 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39162 PyObject *resultobj = 0;
39163 wxWindow *arg1 = (wxWindow *) 0 ;
39164 int result;
39165 void *argp1 = 0 ;
39166 int res1 = 0 ;
39167 PyObject *swig_obj[1] ;
39168
39169 if (!args) SWIG_fail;
39170 swig_obj[0] = args;
39171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39172 if (!SWIG_IsOK(res1)) {
39173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
39174 }
39175 arg1 = reinterpret_cast< wxWindow * >(argp1);
39176 {
39177 PyThreadState* __tstate = wxPyBeginAllowThreads();
39178 result = (int)((wxWindow const *)arg1)->GetCharWidth();
39179 wxPyEndAllowThreads(__tstate);
39180 if (PyErr_Occurred()) SWIG_fail;
39181 }
39182 resultobj = SWIG_From_int(static_cast< int >(result));
39183 return resultobj;
39184 fail:
39185 return NULL;
39186 }
39187
39188
39189 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39190 PyObject *resultobj = 0;
39191 wxWindow *arg1 = (wxWindow *) 0 ;
39192 wxString *arg2 = 0 ;
39193 int *arg3 = (int *) 0 ;
39194 int *arg4 = (int *) 0 ;
39195 void *argp1 = 0 ;
39196 int res1 = 0 ;
39197 bool temp2 = false ;
39198 int temp3 ;
39199 int res3 = SWIG_TMPOBJ ;
39200 int temp4 ;
39201 int res4 = SWIG_TMPOBJ ;
39202 PyObject * obj0 = 0 ;
39203 PyObject * obj1 = 0 ;
39204 char * kwnames[] = {
39205 (char *) "self",(char *) "string", NULL
39206 };
39207
39208 arg3 = &temp3;
39209 arg4 = &temp4;
39210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
39211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39212 if (!SWIG_IsOK(res1)) {
39213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39214 }
39215 arg1 = reinterpret_cast< wxWindow * >(argp1);
39216 {
39217 arg2 = wxString_in_helper(obj1);
39218 if (arg2 == NULL) SWIG_fail;
39219 temp2 = true;
39220 }
39221 {
39222 PyThreadState* __tstate = wxPyBeginAllowThreads();
39223 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
39224 wxPyEndAllowThreads(__tstate);
39225 if (PyErr_Occurred()) SWIG_fail;
39226 }
39227 resultobj = SWIG_Py_Void();
39228 if (SWIG_IsTmpObj(res3)) {
39229 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39230 } else {
39231 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39232 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39233 }
39234 if (SWIG_IsTmpObj(res4)) {
39235 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39236 } else {
39237 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39238 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39239 }
39240 {
39241 if (temp2)
39242 delete arg2;
39243 }
39244 return resultobj;
39245 fail:
39246 {
39247 if (temp2)
39248 delete arg2;
39249 }
39250 return NULL;
39251 }
39252
39253
39254 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39255 PyObject *resultobj = 0;
39256 wxWindow *arg1 = (wxWindow *) 0 ;
39257 wxString *arg2 = 0 ;
39258 int *arg3 = (int *) 0 ;
39259 int *arg4 = (int *) 0 ;
39260 int *arg5 = (int *) 0 ;
39261 int *arg6 = (int *) 0 ;
39262 wxFont *arg7 = (wxFont *) NULL ;
39263 void *argp1 = 0 ;
39264 int res1 = 0 ;
39265 bool temp2 = false ;
39266 int temp3 ;
39267 int res3 = SWIG_TMPOBJ ;
39268 int temp4 ;
39269 int res4 = SWIG_TMPOBJ ;
39270 int temp5 ;
39271 int res5 = SWIG_TMPOBJ ;
39272 int temp6 ;
39273 int res6 = SWIG_TMPOBJ ;
39274 void *argp7 = 0 ;
39275 int res7 = 0 ;
39276 PyObject * obj0 = 0 ;
39277 PyObject * obj1 = 0 ;
39278 PyObject * obj2 = 0 ;
39279 char * kwnames[] = {
39280 (char *) "self",(char *) "string",(char *) "font", NULL
39281 };
39282
39283 arg3 = &temp3;
39284 arg4 = &temp4;
39285 arg5 = &temp5;
39286 arg6 = &temp6;
39287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39289 if (!SWIG_IsOK(res1)) {
39290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39291 }
39292 arg1 = reinterpret_cast< wxWindow * >(argp1);
39293 {
39294 arg2 = wxString_in_helper(obj1);
39295 if (arg2 == NULL) SWIG_fail;
39296 temp2 = true;
39297 }
39298 if (obj2) {
39299 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
39300 if (!SWIG_IsOK(res7)) {
39301 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
39302 }
39303 arg7 = reinterpret_cast< wxFont * >(argp7);
39304 }
39305 {
39306 PyThreadState* __tstate = wxPyBeginAllowThreads();
39307 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
39308 wxPyEndAllowThreads(__tstate);
39309 if (PyErr_Occurred()) SWIG_fail;
39310 }
39311 resultobj = SWIG_Py_Void();
39312 if (SWIG_IsTmpObj(res3)) {
39313 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39314 } else {
39315 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39316 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39317 }
39318 if (SWIG_IsTmpObj(res4)) {
39319 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39320 } else {
39321 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39322 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39323 }
39324 if (SWIG_IsTmpObj(res5)) {
39325 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
39326 } else {
39327 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39328 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
39329 }
39330 if (SWIG_IsTmpObj(res6)) {
39331 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
39332 } else {
39333 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39334 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
39335 }
39336 {
39337 if (temp2)
39338 delete arg2;
39339 }
39340 return resultobj;
39341 fail:
39342 {
39343 if (temp2)
39344 delete arg2;
39345 }
39346 return NULL;
39347 }
39348
39349
39350 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39351 PyObject *resultobj = 0;
39352 wxWindow *arg1 = (wxWindow *) 0 ;
39353 int *arg2 = (int *) 0 ;
39354 int *arg3 = (int *) 0 ;
39355 void *argp1 = 0 ;
39356 int res1 = 0 ;
39357 int temp2 ;
39358 int res2 = 0 ;
39359 int temp3 ;
39360 int res3 = 0 ;
39361 PyObject * obj0 = 0 ;
39362 PyObject * obj1 = 0 ;
39363 PyObject * obj2 = 0 ;
39364 char * kwnames[] = {
39365 (char *) "self",(char *) "x",(char *) "y", NULL
39366 };
39367
39368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39370 if (!SWIG_IsOK(res1)) {
39371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39372 }
39373 arg1 = reinterpret_cast< wxWindow * >(argp1);
39374 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39375 int val;
39376 int ecode = SWIG_AsVal_int(obj1, &val);
39377 if (!SWIG_IsOK(ecode)) {
39378 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39379 }
39380 temp2 = static_cast< int >(val);
39381 arg2 = &temp2;
39382 res2 = SWIG_AddTmpMask(ecode);
39383 }
39384 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39385 int val;
39386 int ecode = SWIG_AsVal_int(obj2, &val);
39387 if (!SWIG_IsOK(ecode)) {
39388 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39389 }
39390 temp3 = static_cast< int >(val);
39391 arg3 = &temp3;
39392 res3 = SWIG_AddTmpMask(ecode);
39393 }
39394 {
39395 PyThreadState* __tstate = wxPyBeginAllowThreads();
39396 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39397 wxPyEndAllowThreads(__tstate);
39398 if (PyErr_Occurred()) SWIG_fail;
39399 }
39400 resultobj = SWIG_Py_Void();
39401 if (SWIG_IsTmpObj(res2)) {
39402 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39403 } else {
39404 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39405 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39406 }
39407 if (SWIG_IsTmpObj(res3)) {
39408 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39409 } else {
39410 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39411 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39412 }
39413 return resultobj;
39414 fail:
39415 return NULL;
39416 }
39417
39418
39419 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39420 PyObject *resultobj = 0;
39421 wxWindow *arg1 = (wxWindow *) 0 ;
39422 int *arg2 = (int *) 0 ;
39423 int *arg3 = (int *) 0 ;
39424 void *argp1 = 0 ;
39425 int res1 = 0 ;
39426 int temp2 ;
39427 int res2 = 0 ;
39428 int temp3 ;
39429 int res3 = 0 ;
39430 PyObject * obj0 = 0 ;
39431 PyObject * obj1 = 0 ;
39432 PyObject * obj2 = 0 ;
39433 char * kwnames[] = {
39434 (char *) "self",(char *) "x",(char *) "y", NULL
39435 };
39436
39437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39439 if (!SWIG_IsOK(res1)) {
39440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39441 }
39442 arg1 = reinterpret_cast< wxWindow * >(argp1);
39443 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39444 int val;
39445 int ecode = SWIG_AsVal_int(obj1, &val);
39446 if (!SWIG_IsOK(ecode)) {
39447 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39448 }
39449 temp2 = static_cast< int >(val);
39450 arg2 = &temp2;
39451 res2 = SWIG_AddTmpMask(ecode);
39452 }
39453 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39454 int val;
39455 int ecode = SWIG_AsVal_int(obj2, &val);
39456 if (!SWIG_IsOK(ecode)) {
39457 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39458 }
39459 temp3 = static_cast< int >(val);
39460 arg3 = &temp3;
39461 res3 = SWIG_AddTmpMask(ecode);
39462 }
39463 {
39464 PyThreadState* __tstate = wxPyBeginAllowThreads();
39465 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39466 wxPyEndAllowThreads(__tstate);
39467 if (PyErr_Occurred()) SWIG_fail;
39468 }
39469 resultobj = SWIG_Py_Void();
39470 if (SWIG_IsTmpObj(res2)) {
39471 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39472 } else {
39473 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39474 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39475 }
39476 if (SWIG_IsTmpObj(res3)) {
39477 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39478 } else {
39479 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39480 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39481 }
39482 return resultobj;
39483 fail:
39484 return NULL;
39485 }
39486
39487
39488 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39489 PyObject *resultobj = 0;
39490 wxWindow *arg1 = (wxWindow *) 0 ;
39491 wxPoint *arg2 = 0 ;
39492 wxPoint result;
39493 void *argp1 = 0 ;
39494 int res1 = 0 ;
39495 wxPoint temp2 ;
39496 PyObject * obj0 = 0 ;
39497 PyObject * obj1 = 0 ;
39498 char * kwnames[] = {
39499 (char *) "self",(char *) "pt", NULL
39500 };
39501
39502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39504 if (!SWIG_IsOK(res1)) {
39505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39506 }
39507 arg1 = reinterpret_cast< wxWindow * >(argp1);
39508 {
39509 arg2 = &temp2;
39510 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39511 }
39512 {
39513 PyThreadState* __tstate = wxPyBeginAllowThreads();
39514 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39515 wxPyEndAllowThreads(__tstate);
39516 if (PyErr_Occurred()) SWIG_fail;
39517 }
39518 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39519 return resultobj;
39520 fail:
39521 return NULL;
39522 }
39523
39524
39525 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39526 PyObject *resultobj = 0;
39527 wxWindow *arg1 = (wxWindow *) 0 ;
39528 wxPoint *arg2 = 0 ;
39529 wxPoint result;
39530 void *argp1 = 0 ;
39531 int res1 = 0 ;
39532 wxPoint temp2 ;
39533 PyObject * obj0 = 0 ;
39534 PyObject * obj1 = 0 ;
39535 char * kwnames[] = {
39536 (char *) "self",(char *) "pt", NULL
39537 };
39538
39539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39541 if (!SWIG_IsOK(res1)) {
39542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39543 }
39544 arg1 = reinterpret_cast< wxWindow * >(argp1);
39545 {
39546 arg2 = &temp2;
39547 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39548 }
39549 {
39550 PyThreadState* __tstate = wxPyBeginAllowThreads();
39551 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39552 wxPyEndAllowThreads(__tstate);
39553 if (PyErr_Occurred()) SWIG_fail;
39554 }
39555 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39556 return resultobj;
39557 fail:
39558 return NULL;
39559 }
39560
39561
39562 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39563 PyObject *resultobj = 0;
39564 wxWindow *arg1 = (wxWindow *) 0 ;
39565 int arg2 ;
39566 int arg3 ;
39567 wxHitTest result;
39568 void *argp1 = 0 ;
39569 int res1 = 0 ;
39570 int val2 ;
39571 int ecode2 = 0 ;
39572 int val3 ;
39573 int ecode3 = 0 ;
39574 PyObject * obj0 = 0 ;
39575 PyObject * obj1 = 0 ;
39576 PyObject * obj2 = 0 ;
39577 char * kwnames[] = {
39578 (char *) "self",(char *) "x",(char *) "y", NULL
39579 };
39580
39581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39583 if (!SWIG_IsOK(res1)) {
39584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39585 }
39586 arg1 = reinterpret_cast< wxWindow * >(argp1);
39587 ecode2 = SWIG_AsVal_int(obj1, &val2);
39588 if (!SWIG_IsOK(ecode2)) {
39589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39590 }
39591 arg2 = static_cast< int >(val2);
39592 ecode3 = SWIG_AsVal_int(obj2, &val3);
39593 if (!SWIG_IsOK(ecode3)) {
39594 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39595 }
39596 arg3 = static_cast< int >(val3);
39597 {
39598 PyThreadState* __tstate = wxPyBeginAllowThreads();
39599 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39600 wxPyEndAllowThreads(__tstate);
39601 if (PyErr_Occurred()) SWIG_fail;
39602 }
39603 resultobj = SWIG_From_int(static_cast< int >(result));
39604 return resultobj;
39605 fail:
39606 return NULL;
39607 }
39608
39609
39610 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39611 PyObject *resultobj = 0;
39612 wxWindow *arg1 = (wxWindow *) 0 ;
39613 wxPoint *arg2 = 0 ;
39614 wxHitTest result;
39615 void *argp1 = 0 ;
39616 int res1 = 0 ;
39617 wxPoint temp2 ;
39618 PyObject * obj0 = 0 ;
39619 PyObject * obj1 = 0 ;
39620 char * kwnames[] = {
39621 (char *) "self",(char *) "pt", NULL
39622 };
39623
39624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39626 if (!SWIG_IsOK(res1)) {
39627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39628 }
39629 arg1 = reinterpret_cast< wxWindow * >(argp1);
39630 {
39631 arg2 = &temp2;
39632 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39633 }
39634 {
39635 PyThreadState* __tstate = wxPyBeginAllowThreads();
39636 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39637 wxPyEndAllowThreads(__tstate);
39638 if (PyErr_Occurred()) SWIG_fail;
39639 }
39640 resultobj = SWIG_From_int(static_cast< int >(result));
39641 return resultobj;
39642 fail:
39643 return NULL;
39644 }
39645
39646
39647 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39648 PyObject *resultobj = 0;
39649 wxWindow *arg1 = (wxWindow *) 0 ;
39650 long arg2 ;
39651 wxBorder result;
39652 void *argp1 = 0 ;
39653 int res1 = 0 ;
39654 long val2 ;
39655 int ecode2 = 0 ;
39656
39657 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39659 if (!SWIG_IsOK(res1)) {
39660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39661 }
39662 arg1 = reinterpret_cast< wxWindow * >(argp1);
39663 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39664 if (!SWIG_IsOK(ecode2)) {
39665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39666 }
39667 arg2 = static_cast< long >(val2);
39668 {
39669 PyThreadState* __tstate = wxPyBeginAllowThreads();
39670 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39671 wxPyEndAllowThreads(__tstate);
39672 if (PyErr_Occurred()) SWIG_fail;
39673 }
39674 resultobj = SWIG_From_int(static_cast< int >(result));
39675 return resultobj;
39676 fail:
39677 return NULL;
39678 }
39679
39680
39681 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39682 PyObject *resultobj = 0;
39683 wxWindow *arg1 = (wxWindow *) 0 ;
39684 wxBorder result;
39685 void *argp1 = 0 ;
39686 int res1 = 0 ;
39687
39688 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39690 if (!SWIG_IsOK(res1)) {
39691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39692 }
39693 arg1 = reinterpret_cast< wxWindow * >(argp1);
39694 {
39695 PyThreadState* __tstate = wxPyBeginAllowThreads();
39696 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39697 wxPyEndAllowThreads(__tstate);
39698 if (PyErr_Occurred()) SWIG_fail;
39699 }
39700 resultobj = SWIG_From_int(static_cast< int >(result));
39701 return resultobj;
39702 fail:
39703 return NULL;
39704 }
39705
39706
39707 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39708 int argc;
39709 PyObject *argv[3];
39710
39711 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39712 --argc;
39713 if (argc == 1) {
39714 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39715 }
39716 if (argc == 2) {
39717 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39718 }
39719
39720 fail:
39721 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39722 return NULL;
39723 }
39724
39725
39726 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39727 PyObject *resultobj = 0;
39728 wxWindow *arg1 = (wxWindow *) 0 ;
39729 long arg2 = (long) wxUPDATE_UI_NONE ;
39730 void *argp1 = 0 ;
39731 int res1 = 0 ;
39732 long val2 ;
39733 int ecode2 = 0 ;
39734 PyObject * obj0 = 0 ;
39735 PyObject * obj1 = 0 ;
39736 char * kwnames[] = {
39737 (char *) "self",(char *) "flags", NULL
39738 };
39739
39740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39742 if (!SWIG_IsOK(res1)) {
39743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39744 }
39745 arg1 = reinterpret_cast< wxWindow * >(argp1);
39746 if (obj1) {
39747 ecode2 = SWIG_AsVal_long(obj1, &val2);
39748 if (!SWIG_IsOK(ecode2)) {
39749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39750 }
39751 arg2 = static_cast< long >(val2);
39752 }
39753 {
39754 PyThreadState* __tstate = wxPyBeginAllowThreads();
39755 (arg1)->UpdateWindowUI(arg2);
39756 wxPyEndAllowThreads(__tstate);
39757 if (PyErr_Occurred()) SWIG_fail;
39758 }
39759 resultobj = SWIG_Py_Void();
39760 return resultobj;
39761 fail:
39762 return NULL;
39763 }
39764
39765
39766 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39767 PyObject *resultobj = 0;
39768 wxWindow *arg1 = (wxWindow *) 0 ;
39769 wxMenu *arg2 = (wxMenu *) 0 ;
39770 int arg3 = (int) -1 ;
39771 int arg4 = (int) -1 ;
39772 bool result;
39773 void *argp1 = 0 ;
39774 int res1 = 0 ;
39775 void *argp2 = 0 ;
39776 int res2 = 0 ;
39777 int val3 ;
39778 int ecode3 = 0 ;
39779 int val4 ;
39780 int ecode4 = 0 ;
39781 PyObject * obj0 = 0 ;
39782 PyObject * obj1 = 0 ;
39783 PyObject * obj2 = 0 ;
39784 PyObject * obj3 = 0 ;
39785 char * kwnames[] = {
39786 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39787 };
39788
39789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39791 if (!SWIG_IsOK(res1)) {
39792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39793 }
39794 arg1 = reinterpret_cast< wxWindow * >(argp1);
39795 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39796 if (!SWIG_IsOK(res2)) {
39797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39798 }
39799 arg2 = reinterpret_cast< wxMenu * >(argp2);
39800 if (obj2) {
39801 ecode3 = SWIG_AsVal_int(obj2, &val3);
39802 if (!SWIG_IsOK(ecode3)) {
39803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39804 }
39805 arg3 = static_cast< int >(val3);
39806 }
39807 if (obj3) {
39808 ecode4 = SWIG_AsVal_int(obj3, &val4);
39809 if (!SWIG_IsOK(ecode4)) {
39810 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39811 }
39812 arg4 = static_cast< int >(val4);
39813 }
39814 {
39815 PyThreadState* __tstate = wxPyBeginAllowThreads();
39816 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39817 wxPyEndAllowThreads(__tstate);
39818 if (PyErr_Occurred()) SWIG_fail;
39819 }
39820 {
39821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39822 }
39823 return resultobj;
39824 fail:
39825 return NULL;
39826 }
39827
39828
39829 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39830 PyObject *resultobj = 0;
39831 wxWindow *arg1 = (wxWindow *) 0 ;
39832 wxMenu *arg2 = (wxMenu *) 0 ;
39833 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39834 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39835 bool result;
39836 void *argp1 = 0 ;
39837 int res1 = 0 ;
39838 void *argp2 = 0 ;
39839 int res2 = 0 ;
39840 wxPoint temp3 ;
39841 PyObject * obj0 = 0 ;
39842 PyObject * obj1 = 0 ;
39843 PyObject * obj2 = 0 ;
39844 char * kwnames[] = {
39845 (char *) "self",(char *) "menu",(char *) "pos", NULL
39846 };
39847
39848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39850 if (!SWIG_IsOK(res1)) {
39851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39852 }
39853 arg1 = reinterpret_cast< wxWindow * >(argp1);
39854 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39855 if (!SWIG_IsOK(res2)) {
39856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39857 }
39858 arg2 = reinterpret_cast< wxMenu * >(argp2);
39859 if (obj2) {
39860 {
39861 arg3 = &temp3;
39862 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39863 }
39864 }
39865 {
39866 PyThreadState* __tstate = wxPyBeginAllowThreads();
39867 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39868 wxPyEndAllowThreads(__tstate);
39869 if (PyErr_Occurred()) SWIG_fail;
39870 }
39871 {
39872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39873 }
39874 return resultobj;
39875 fail:
39876 return NULL;
39877 }
39878
39879
39880 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39881 PyObject *resultobj = 0;
39882 wxWindow *arg1 = (wxWindow *) 0 ;
39883 bool result;
39884 void *argp1 = 0 ;
39885 int res1 = 0 ;
39886 PyObject *swig_obj[1] ;
39887
39888 if (!args) SWIG_fail;
39889 swig_obj[0] = args;
39890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39891 if (!SWIG_IsOK(res1)) {
39892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39893 }
39894 arg1 = reinterpret_cast< wxWindow * >(argp1);
39895 {
39896 PyThreadState* __tstate = wxPyBeginAllowThreads();
39897 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39898 wxPyEndAllowThreads(__tstate);
39899 if (PyErr_Occurred()) SWIG_fail;
39900 }
39901 {
39902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39903 }
39904 return resultobj;
39905 fail:
39906 return NULL;
39907 }
39908
39909
39910 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39911 PyObject *resultobj = 0;
39912 wxWindow *arg1 = (wxWindow *) 0 ;
39913 long result;
39914 void *argp1 = 0 ;
39915 int res1 = 0 ;
39916 PyObject *swig_obj[1] ;
39917
39918 if (!args) SWIG_fail;
39919 swig_obj[0] = args;
39920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39921 if (!SWIG_IsOK(res1)) {
39922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39923 }
39924 arg1 = reinterpret_cast< wxWindow * >(argp1);
39925 {
39926 PyThreadState* __tstate = wxPyBeginAllowThreads();
39927 result = (long)wxWindow_GetHandle(arg1);
39928 wxPyEndAllowThreads(__tstate);
39929 if (PyErr_Occurred()) SWIG_fail;
39930 }
39931 resultobj = SWIG_From_long(static_cast< long >(result));
39932 return resultobj;
39933 fail:
39934 return NULL;
39935 }
39936
39937
39938 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39939 PyObject *resultobj = 0;
39940 wxWindow *arg1 = (wxWindow *) 0 ;
39941 long arg2 ;
39942 void *argp1 = 0 ;
39943 int res1 = 0 ;
39944 long val2 ;
39945 int ecode2 = 0 ;
39946 PyObject * obj0 = 0 ;
39947 PyObject * obj1 = 0 ;
39948 char * kwnames[] = {
39949 (char *) "self",(char *) "handle", NULL
39950 };
39951
39952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39954 if (!SWIG_IsOK(res1)) {
39955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39956 }
39957 arg1 = reinterpret_cast< wxWindow * >(argp1);
39958 ecode2 = SWIG_AsVal_long(obj1, &val2);
39959 if (!SWIG_IsOK(ecode2)) {
39960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39961 }
39962 arg2 = static_cast< long >(val2);
39963 {
39964 PyThreadState* __tstate = wxPyBeginAllowThreads();
39965 wxWindow_AssociateHandle(arg1,arg2);
39966 wxPyEndAllowThreads(__tstate);
39967 if (PyErr_Occurred()) SWIG_fail;
39968 }
39969 resultobj = SWIG_Py_Void();
39970 return resultobj;
39971 fail:
39972 return NULL;
39973 }
39974
39975
39976 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39977 PyObject *resultobj = 0;
39978 wxWindow *arg1 = (wxWindow *) 0 ;
39979 void *argp1 = 0 ;
39980 int res1 = 0 ;
39981 PyObject *swig_obj[1] ;
39982
39983 if (!args) SWIG_fail;
39984 swig_obj[0] = args;
39985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39986 if (!SWIG_IsOK(res1)) {
39987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39988 }
39989 arg1 = reinterpret_cast< wxWindow * >(argp1);
39990 {
39991 PyThreadState* __tstate = wxPyBeginAllowThreads();
39992 (arg1)->DissociateHandle();
39993 wxPyEndAllowThreads(__tstate);
39994 if (PyErr_Occurred()) SWIG_fail;
39995 }
39996 resultobj = SWIG_Py_Void();
39997 return resultobj;
39998 fail:
39999 return NULL;
40000 }
40001
40002
40003 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40004 PyObject *resultobj = 0;
40005 wxWindow *arg1 = (wxWindow *) 0 ;
40006 int arg2 ;
40007 bool result;
40008 void *argp1 = 0 ;
40009 int res1 = 0 ;
40010 int val2 ;
40011 int ecode2 = 0 ;
40012 PyObject * obj0 = 0 ;
40013 PyObject * obj1 = 0 ;
40014 char * kwnames[] = {
40015 (char *) "self",(char *) "orient", NULL
40016 };
40017
40018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
40019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40020 if (!SWIG_IsOK(res1)) {
40021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
40022 }
40023 arg1 = reinterpret_cast< wxWindow * >(argp1);
40024 ecode2 = SWIG_AsVal_int(obj1, &val2);
40025 if (!SWIG_IsOK(ecode2)) {
40026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
40027 }
40028 arg2 = static_cast< int >(val2);
40029 {
40030 PyThreadState* __tstate = wxPyBeginAllowThreads();
40031 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
40032 wxPyEndAllowThreads(__tstate);
40033 if (PyErr_Occurred()) SWIG_fail;
40034 }
40035 {
40036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40037 }
40038 return resultobj;
40039 fail:
40040 return NULL;
40041 }
40042
40043
40044 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40045 PyObject *resultobj = 0;
40046 wxWindow *arg1 = (wxWindow *) 0 ;
40047 int arg2 ;
40048 int arg3 ;
40049 int arg4 ;
40050 int arg5 ;
40051 bool arg6 = (bool) true ;
40052 void *argp1 = 0 ;
40053 int res1 = 0 ;
40054 int val2 ;
40055 int ecode2 = 0 ;
40056 int val3 ;
40057 int ecode3 = 0 ;
40058 int val4 ;
40059 int ecode4 = 0 ;
40060 int val5 ;
40061 int ecode5 = 0 ;
40062 bool val6 ;
40063 int ecode6 = 0 ;
40064 PyObject * obj0 = 0 ;
40065 PyObject * obj1 = 0 ;
40066 PyObject * obj2 = 0 ;
40067 PyObject * obj3 = 0 ;
40068 PyObject * obj4 = 0 ;
40069 PyObject * obj5 = 0 ;
40070 char * kwnames[] = {
40071 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
40072 };
40073
40074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40076 if (!SWIG_IsOK(res1)) {
40077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
40078 }
40079 arg1 = reinterpret_cast< wxWindow * >(argp1);
40080 ecode2 = SWIG_AsVal_int(obj1, &val2);
40081 if (!SWIG_IsOK(ecode2)) {
40082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
40083 }
40084 arg2 = static_cast< int >(val2);
40085 ecode3 = SWIG_AsVal_int(obj2, &val3);
40086 if (!SWIG_IsOK(ecode3)) {
40087 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
40088 }
40089 arg3 = static_cast< int >(val3);
40090 ecode4 = SWIG_AsVal_int(obj3, &val4);
40091 if (!SWIG_IsOK(ecode4)) {
40092 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
40093 }
40094 arg4 = static_cast< int >(val4);
40095 ecode5 = SWIG_AsVal_int(obj4, &val5);
40096 if (!SWIG_IsOK(ecode5)) {
40097 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
40098 }
40099 arg5 = static_cast< int >(val5);
40100 if (obj5) {
40101 ecode6 = SWIG_AsVal_bool(obj5, &val6);
40102 if (!SWIG_IsOK(ecode6)) {
40103 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
40104 }
40105 arg6 = static_cast< bool >(val6);
40106 }
40107 {
40108 PyThreadState* __tstate = wxPyBeginAllowThreads();
40109 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
40110 wxPyEndAllowThreads(__tstate);
40111 if (PyErr_Occurred()) SWIG_fail;
40112 }
40113 resultobj = SWIG_Py_Void();
40114 return resultobj;
40115 fail:
40116 return NULL;
40117 }
40118
40119
40120 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40121 PyObject *resultobj = 0;
40122 wxWindow *arg1 = (wxWindow *) 0 ;
40123 int arg2 ;
40124 int arg3 ;
40125 bool arg4 = (bool) true ;
40126 void *argp1 = 0 ;
40127 int res1 = 0 ;
40128 int val2 ;
40129 int ecode2 = 0 ;
40130 int val3 ;
40131 int ecode3 = 0 ;
40132 bool val4 ;
40133 int ecode4 = 0 ;
40134 PyObject * obj0 = 0 ;
40135 PyObject * obj1 = 0 ;
40136 PyObject * obj2 = 0 ;
40137 PyObject * obj3 = 0 ;
40138 char * kwnames[] = {
40139 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
40140 };
40141
40142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40144 if (!SWIG_IsOK(res1)) {
40145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
40146 }
40147 arg1 = reinterpret_cast< wxWindow * >(argp1);
40148 ecode2 = SWIG_AsVal_int(obj1, &val2);
40149 if (!SWIG_IsOK(ecode2)) {
40150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
40151 }
40152 arg2 = static_cast< int >(val2);
40153 ecode3 = SWIG_AsVal_int(obj2, &val3);
40154 if (!SWIG_IsOK(ecode3)) {
40155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
40156 }
40157 arg3 = static_cast< int >(val3);
40158 if (obj3) {
40159 ecode4 = SWIG_AsVal_bool(obj3, &val4);
40160 if (!SWIG_IsOK(ecode4)) {
40161 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
40162 }
40163 arg4 = static_cast< bool >(val4);
40164 }
40165 {
40166 PyThreadState* __tstate = wxPyBeginAllowThreads();
40167 (arg1)->SetScrollPos(arg2,arg3,arg4);
40168 wxPyEndAllowThreads(__tstate);
40169 if (PyErr_Occurred()) SWIG_fail;
40170 }
40171 resultobj = SWIG_Py_Void();
40172 return resultobj;
40173 fail:
40174 return NULL;
40175 }
40176
40177
40178 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40179 PyObject *resultobj = 0;
40180 wxWindow *arg1 = (wxWindow *) 0 ;
40181 int arg2 ;
40182 int result;
40183 void *argp1 = 0 ;
40184 int res1 = 0 ;
40185 int val2 ;
40186 int ecode2 = 0 ;
40187 PyObject * obj0 = 0 ;
40188 PyObject * obj1 = 0 ;
40189 char * kwnames[] = {
40190 (char *) "self",(char *) "orientation", NULL
40191 };
40192
40193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
40194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40195 if (!SWIG_IsOK(res1)) {
40196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
40197 }
40198 arg1 = reinterpret_cast< wxWindow * >(argp1);
40199 ecode2 = SWIG_AsVal_int(obj1, &val2);
40200 if (!SWIG_IsOK(ecode2)) {
40201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
40202 }
40203 arg2 = static_cast< int >(val2);
40204 {
40205 PyThreadState* __tstate = wxPyBeginAllowThreads();
40206 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
40207 wxPyEndAllowThreads(__tstate);
40208 if (PyErr_Occurred()) SWIG_fail;
40209 }
40210 resultobj = SWIG_From_int(static_cast< int >(result));
40211 return resultobj;
40212 fail:
40213 return NULL;
40214 }
40215
40216
40217 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40218 PyObject *resultobj = 0;
40219 wxWindow *arg1 = (wxWindow *) 0 ;
40220 int arg2 ;
40221 int result;
40222 void *argp1 = 0 ;
40223 int res1 = 0 ;
40224 int val2 ;
40225 int ecode2 = 0 ;
40226 PyObject * obj0 = 0 ;
40227 PyObject * obj1 = 0 ;
40228 char * kwnames[] = {
40229 (char *) "self",(char *) "orientation", NULL
40230 };
40231
40232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
40233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40234 if (!SWIG_IsOK(res1)) {
40235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
40236 }
40237 arg1 = reinterpret_cast< wxWindow * >(argp1);
40238 ecode2 = SWIG_AsVal_int(obj1, &val2);
40239 if (!SWIG_IsOK(ecode2)) {
40240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
40241 }
40242 arg2 = static_cast< int >(val2);
40243 {
40244 PyThreadState* __tstate = wxPyBeginAllowThreads();
40245 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
40246 wxPyEndAllowThreads(__tstate);
40247 if (PyErr_Occurred()) SWIG_fail;
40248 }
40249 resultobj = SWIG_From_int(static_cast< int >(result));
40250 return resultobj;
40251 fail:
40252 return NULL;
40253 }
40254
40255
40256 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40257 PyObject *resultobj = 0;
40258 wxWindow *arg1 = (wxWindow *) 0 ;
40259 int arg2 ;
40260 int result;
40261 void *argp1 = 0 ;
40262 int res1 = 0 ;
40263 int val2 ;
40264 int ecode2 = 0 ;
40265 PyObject * obj0 = 0 ;
40266 PyObject * obj1 = 0 ;
40267 char * kwnames[] = {
40268 (char *) "self",(char *) "orientation", NULL
40269 };
40270
40271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
40272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40273 if (!SWIG_IsOK(res1)) {
40274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
40275 }
40276 arg1 = reinterpret_cast< wxWindow * >(argp1);
40277 ecode2 = SWIG_AsVal_int(obj1, &val2);
40278 if (!SWIG_IsOK(ecode2)) {
40279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
40280 }
40281 arg2 = static_cast< int >(val2);
40282 {
40283 PyThreadState* __tstate = wxPyBeginAllowThreads();
40284 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
40285 wxPyEndAllowThreads(__tstate);
40286 if (PyErr_Occurred()) SWIG_fail;
40287 }
40288 resultobj = SWIG_From_int(static_cast< int >(result));
40289 return resultobj;
40290 fail:
40291 return NULL;
40292 }
40293
40294
40295 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40296 PyObject *resultobj = 0;
40297 wxWindow *arg1 = (wxWindow *) 0 ;
40298 int arg2 ;
40299 int arg3 ;
40300 wxRect *arg4 = (wxRect *) NULL ;
40301 void *argp1 = 0 ;
40302 int res1 = 0 ;
40303 int val2 ;
40304 int ecode2 = 0 ;
40305 int val3 ;
40306 int ecode3 = 0 ;
40307 void *argp4 = 0 ;
40308 int res4 = 0 ;
40309 PyObject * obj0 = 0 ;
40310 PyObject * obj1 = 0 ;
40311 PyObject * obj2 = 0 ;
40312 PyObject * obj3 = 0 ;
40313 char * kwnames[] = {
40314 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
40315 };
40316
40317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40319 if (!SWIG_IsOK(res1)) {
40320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
40321 }
40322 arg1 = reinterpret_cast< wxWindow * >(argp1);
40323 ecode2 = SWIG_AsVal_int(obj1, &val2);
40324 if (!SWIG_IsOK(ecode2)) {
40325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40326 }
40327 arg2 = static_cast< int >(val2);
40328 ecode3 = SWIG_AsVal_int(obj2, &val3);
40329 if (!SWIG_IsOK(ecode3)) {
40330 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40331 }
40332 arg3 = static_cast< int >(val3);
40333 if (obj3) {
40334 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40335 if (!SWIG_IsOK(res4)) {
40336 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40337 }
40338 arg4 = reinterpret_cast< wxRect * >(argp4);
40339 }
40340 {
40341 PyThreadState* __tstate = wxPyBeginAllowThreads();
40342 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40343 wxPyEndAllowThreads(__tstate);
40344 if (PyErr_Occurred()) SWIG_fail;
40345 }
40346 resultobj = SWIG_Py_Void();
40347 return resultobj;
40348 fail:
40349 return NULL;
40350 }
40351
40352
40353 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40354 PyObject *resultobj = 0;
40355 wxWindow *arg1 = (wxWindow *) 0 ;
40356 int arg2 ;
40357 bool result;
40358 void *argp1 = 0 ;
40359 int res1 = 0 ;
40360 int val2 ;
40361 int ecode2 = 0 ;
40362 PyObject * obj0 = 0 ;
40363 PyObject * obj1 = 0 ;
40364 char * kwnames[] = {
40365 (char *) "self",(char *) "lines", NULL
40366 };
40367
40368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40370 if (!SWIG_IsOK(res1)) {
40371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40372 }
40373 arg1 = reinterpret_cast< wxWindow * >(argp1);
40374 ecode2 = SWIG_AsVal_int(obj1, &val2);
40375 if (!SWIG_IsOK(ecode2)) {
40376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40377 }
40378 arg2 = static_cast< int >(val2);
40379 {
40380 PyThreadState* __tstate = wxPyBeginAllowThreads();
40381 result = (bool)(arg1)->ScrollLines(arg2);
40382 wxPyEndAllowThreads(__tstate);
40383 if (PyErr_Occurred()) SWIG_fail;
40384 }
40385 {
40386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40387 }
40388 return resultobj;
40389 fail:
40390 return NULL;
40391 }
40392
40393
40394 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40395 PyObject *resultobj = 0;
40396 wxWindow *arg1 = (wxWindow *) 0 ;
40397 int arg2 ;
40398 bool result;
40399 void *argp1 = 0 ;
40400 int res1 = 0 ;
40401 int val2 ;
40402 int ecode2 = 0 ;
40403 PyObject * obj0 = 0 ;
40404 PyObject * obj1 = 0 ;
40405 char * kwnames[] = {
40406 (char *) "self",(char *) "pages", NULL
40407 };
40408
40409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40411 if (!SWIG_IsOK(res1)) {
40412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40413 }
40414 arg1 = reinterpret_cast< wxWindow * >(argp1);
40415 ecode2 = SWIG_AsVal_int(obj1, &val2);
40416 if (!SWIG_IsOK(ecode2)) {
40417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40418 }
40419 arg2 = static_cast< int >(val2);
40420 {
40421 PyThreadState* __tstate = wxPyBeginAllowThreads();
40422 result = (bool)(arg1)->ScrollPages(arg2);
40423 wxPyEndAllowThreads(__tstate);
40424 if (PyErr_Occurred()) SWIG_fail;
40425 }
40426 {
40427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40428 }
40429 return resultobj;
40430 fail:
40431 return NULL;
40432 }
40433
40434
40435 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40436 PyObject *resultobj = 0;
40437 wxWindow *arg1 = (wxWindow *) 0 ;
40438 bool result;
40439 void *argp1 = 0 ;
40440 int res1 = 0 ;
40441 PyObject *swig_obj[1] ;
40442
40443 if (!args) SWIG_fail;
40444 swig_obj[0] = args;
40445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40446 if (!SWIG_IsOK(res1)) {
40447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40448 }
40449 arg1 = reinterpret_cast< wxWindow * >(argp1);
40450 {
40451 PyThreadState* __tstate = wxPyBeginAllowThreads();
40452 result = (bool)(arg1)->LineUp();
40453 wxPyEndAllowThreads(__tstate);
40454 if (PyErr_Occurred()) SWIG_fail;
40455 }
40456 {
40457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40458 }
40459 return resultobj;
40460 fail:
40461 return NULL;
40462 }
40463
40464
40465 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40466 PyObject *resultobj = 0;
40467 wxWindow *arg1 = (wxWindow *) 0 ;
40468 bool result;
40469 void *argp1 = 0 ;
40470 int res1 = 0 ;
40471 PyObject *swig_obj[1] ;
40472
40473 if (!args) SWIG_fail;
40474 swig_obj[0] = args;
40475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40476 if (!SWIG_IsOK(res1)) {
40477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40478 }
40479 arg1 = reinterpret_cast< wxWindow * >(argp1);
40480 {
40481 PyThreadState* __tstate = wxPyBeginAllowThreads();
40482 result = (bool)(arg1)->LineDown();
40483 wxPyEndAllowThreads(__tstate);
40484 if (PyErr_Occurred()) SWIG_fail;
40485 }
40486 {
40487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40488 }
40489 return resultobj;
40490 fail:
40491 return NULL;
40492 }
40493
40494
40495 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40496 PyObject *resultobj = 0;
40497 wxWindow *arg1 = (wxWindow *) 0 ;
40498 bool result;
40499 void *argp1 = 0 ;
40500 int res1 = 0 ;
40501 PyObject *swig_obj[1] ;
40502
40503 if (!args) SWIG_fail;
40504 swig_obj[0] = args;
40505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40506 if (!SWIG_IsOK(res1)) {
40507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40508 }
40509 arg1 = reinterpret_cast< wxWindow * >(argp1);
40510 {
40511 PyThreadState* __tstate = wxPyBeginAllowThreads();
40512 result = (bool)(arg1)->PageUp();
40513 wxPyEndAllowThreads(__tstate);
40514 if (PyErr_Occurred()) SWIG_fail;
40515 }
40516 {
40517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40518 }
40519 return resultobj;
40520 fail:
40521 return NULL;
40522 }
40523
40524
40525 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40526 PyObject *resultobj = 0;
40527 wxWindow *arg1 = (wxWindow *) 0 ;
40528 bool result;
40529 void *argp1 = 0 ;
40530 int res1 = 0 ;
40531 PyObject *swig_obj[1] ;
40532
40533 if (!args) SWIG_fail;
40534 swig_obj[0] = args;
40535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40536 if (!SWIG_IsOK(res1)) {
40537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40538 }
40539 arg1 = reinterpret_cast< wxWindow * >(argp1);
40540 {
40541 PyThreadState* __tstate = wxPyBeginAllowThreads();
40542 result = (bool)(arg1)->PageDown();
40543 wxPyEndAllowThreads(__tstate);
40544 if (PyErr_Occurred()) SWIG_fail;
40545 }
40546 {
40547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40548 }
40549 return resultobj;
40550 fail:
40551 return NULL;
40552 }
40553
40554
40555 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40556 PyObject *resultobj = 0;
40557 wxWindow *arg1 = (wxWindow *) 0 ;
40558 wxString *arg2 = 0 ;
40559 void *argp1 = 0 ;
40560 int res1 = 0 ;
40561 bool temp2 = false ;
40562 PyObject * obj0 = 0 ;
40563 PyObject * obj1 = 0 ;
40564 char * kwnames[] = {
40565 (char *) "self",(char *) "text", NULL
40566 };
40567
40568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40570 if (!SWIG_IsOK(res1)) {
40571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40572 }
40573 arg1 = reinterpret_cast< wxWindow * >(argp1);
40574 {
40575 arg2 = wxString_in_helper(obj1);
40576 if (arg2 == NULL) SWIG_fail;
40577 temp2 = true;
40578 }
40579 {
40580 PyThreadState* __tstate = wxPyBeginAllowThreads();
40581 (arg1)->SetHelpText((wxString const &)*arg2);
40582 wxPyEndAllowThreads(__tstate);
40583 if (PyErr_Occurred()) SWIG_fail;
40584 }
40585 resultobj = SWIG_Py_Void();
40586 {
40587 if (temp2)
40588 delete arg2;
40589 }
40590 return resultobj;
40591 fail:
40592 {
40593 if (temp2)
40594 delete arg2;
40595 }
40596 return NULL;
40597 }
40598
40599
40600 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40601 PyObject *resultobj = 0;
40602 wxWindow *arg1 = (wxWindow *) 0 ;
40603 wxString *arg2 = 0 ;
40604 void *argp1 = 0 ;
40605 int res1 = 0 ;
40606 bool temp2 = false ;
40607 PyObject * obj0 = 0 ;
40608 PyObject * obj1 = 0 ;
40609 char * kwnames[] = {
40610 (char *) "self",(char *) "text", NULL
40611 };
40612
40613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40615 if (!SWIG_IsOK(res1)) {
40616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40617 }
40618 arg1 = reinterpret_cast< wxWindow * >(argp1);
40619 {
40620 arg2 = wxString_in_helper(obj1);
40621 if (arg2 == NULL) SWIG_fail;
40622 temp2 = true;
40623 }
40624 {
40625 PyThreadState* __tstate = wxPyBeginAllowThreads();
40626 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40627 wxPyEndAllowThreads(__tstate);
40628 if (PyErr_Occurred()) SWIG_fail;
40629 }
40630 resultobj = SWIG_Py_Void();
40631 {
40632 if (temp2)
40633 delete arg2;
40634 }
40635 return resultobj;
40636 fail:
40637 {
40638 if (temp2)
40639 delete arg2;
40640 }
40641 return NULL;
40642 }
40643
40644
40645 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40646 PyObject *resultobj = 0;
40647 wxWindow *arg1 = (wxWindow *) 0 ;
40648 wxPoint *arg2 = 0 ;
40649 wxHelpEvent::Origin arg3 ;
40650 wxString result;
40651 void *argp1 = 0 ;
40652 int res1 = 0 ;
40653 wxPoint temp2 ;
40654 void *argp3 ;
40655 int res3 = 0 ;
40656 PyObject * obj0 = 0 ;
40657 PyObject * obj1 = 0 ;
40658 PyObject * obj2 = 0 ;
40659 char * kwnames[] = {
40660 (char *) "self",(char *) "pt",(char *) "origin", NULL
40661 };
40662
40663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40665 if (!SWIG_IsOK(res1)) {
40666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40667 }
40668 arg1 = reinterpret_cast< wxWindow * >(argp1);
40669 {
40670 arg2 = &temp2;
40671 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40672 }
40673 {
40674 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40675 if (!SWIG_IsOK(res3)) {
40676 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40677 }
40678 if (!argp3) {
40679 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40680 } else {
40681 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40682 arg3 = *temp;
40683 if (SWIG_IsNewObj(res3)) delete temp;
40684 }
40685 }
40686 {
40687 PyThreadState* __tstate = wxPyBeginAllowThreads();
40688 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40689 wxPyEndAllowThreads(__tstate);
40690 if (PyErr_Occurred()) SWIG_fail;
40691 }
40692 {
40693 #if wxUSE_UNICODE
40694 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40695 #else
40696 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40697 #endif
40698 }
40699 return resultobj;
40700 fail:
40701 return NULL;
40702 }
40703
40704
40705 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40706 PyObject *resultobj = 0;
40707 wxWindow *arg1 = (wxWindow *) 0 ;
40708 wxString result;
40709 void *argp1 = 0 ;
40710 int res1 = 0 ;
40711 PyObject *swig_obj[1] ;
40712
40713 if (!args) SWIG_fail;
40714 swig_obj[0] = args;
40715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40716 if (!SWIG_IsOK(res1)) {
40717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40718 }
40719 arg1 = reinterpret_cast< wxWindow * >(argp1);
40720 {
40721 PyThreadState* __tstate = wxPyBeginAllowThreads();
40722 result = ((wxWindow const *)arg1)->GetHelpText();
40723 wxPyEndAllowThreads(__tstate);
40724 if (PyErr_Occurred()) SWIG_fail;
40725 }
40726 {
40727 #if wxUSE_UNICODE
40728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40729 #else
40730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40731 #endif
40732 }
40733 return resultobj;
40734 fail:
40735 return NULL;
40736 }
40737
40738
40739 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40740 PyObject *resultobj = 0;
40741 wxWindow *arg1 = (wxWindow *) 0 ;
40742 wxString *arg2 = 0 ;
40743 void *argp1 = 0 ;
40744 int res1 = 0 ;
40745 bool temp2 = false ;
40746 PyObject * obj0 = 0 ;
40747 PyObject * obj1 = 0 ;
40748 char * kwnames[] = {
40749 (char *) "self",(char *) "tip", NULL
40750 };
40751
40752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40754 if (!SWIG_IsOK(res1)) {
40755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40756 }
40757 arg1 = reinterpret_cast< wxWindow * >(argp1);
40758 {
40759 arg2 = wxString_in_helper(obj1);
40760 if (arg2 == NULL) SWIG_fail;
40761 temp2 = true;
40762 }
40763 {
40764 PyThreadState* __tstate = wxPyBeginAllowThreads();
40765 (arg1)->SetToolTip((wxString const &)*arg2);
40766 wxPyEndAllowThreads(__tstate);
40767 if (PyErr_Occurred()) SWIG_fail;
40768 }
40769 resultobj = SWIG_Py_Void();
40770 {
40771 if (temp2)
40772 delete arg2;
40773 }
40774 return resultobj;
40775 fail:
40776 {
40777 if (temp2)
40778 delete arg2;
40779 }
40780 return NULL;
40781 }
40782
40783
40784 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40785 PyObject *resultobj = 0;
40786 wxWindow *arg1 = (wxWindow *) 0 ;
40787 wxToolTip *arg2 = (wxToolTip *) 0 ;
40788 void *argp1 = 0 ;
40789 int res1 = 0 ;
40790 int res2 = 0 ;
40791 PyObject * obj0 = 0 ;
40792 PyObject * obj1 = 0 ;
40793 char * kwnames[] = {
40794 (char *) "self",(char *) "tip", NULL
40795 };
40796
40797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40799 if (!SWIG_IsOK(res1)) {
40800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40801 }
40802 arg1 = reinterpret_cast< wxWindow * >(argp1);
40803 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40804 if (!SWIG_IsOK(res2)) {
40805 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40806 }
40807 {
40808 PyThreadState* __tstate = wxPyBeginAllowThreads();
40809 (arg1)->SetToolTip(arg2);
40810 wxPyEndAllowThreads(__tstate);
40811 if (PyErr_Occurred()) SWIG_fail;
40812 }
40813 resultobj = SWIG_Py_Void();
40814 return resultobj;
40815 fail:
40816 return NULL;
40817 }
40818
40819
40820 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40821 PyObject *resultobj = 0;
40822 wxWindow *arg1 = (wxWindow *) 0 ;
40823 wxToolTip *result = 0 ;
40824 void *argp1 = 0 ;
40825 int res1 = 0 ;
40826 PyObject *swig_obj[1] ;
40827
40828 if (!args) SWIG_fail;
40829 swig_obj[0] = args;
40830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40831 if (!SWIG_IsOK(res1)) {
40832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40833 }
40834 arg1 = reinterpret_cast< wxWindow * >(argp1);
40835 {
40836 PyThreadState* __tstate = wxPyBeginAllowThreads();
40837 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40838 wxPyEndAllowThreads(__tstate);
40839 if (PyErr_Occurred()) SWIG_fail;
40840 }
40841 {
40842 resultobj = wxPyMake_wxObject(result, (bool)0);
40843 }
40844 return resultobj;
40845 fail:
40846 return NULL;
40847 }
40848
40849
40850 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40851 PyObject *resultobj = 0;
40852 wxWindow *arg1 = (wxWindow *) 0 ;
40853 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40854 void *argp1 = 0 ;
40855 int res1 = 0 ;
40856 int res2 = 0 ;
40857 PyObject * obj0 = 0 ;
40858 PyObject * obj1 = 0 ;
40859 char * kwnames[] = {
40860 (char *) "self",(char *) "dropTarget", NULL
40861 };
40862
40863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40865 if (!SWIG_IsOK(res1)) {
40866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40867 }
40868 arg1 = reinterpret_cast< wxWindow * >(argp1);
40869 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40870 if (!SWIG_IsOK(res2)) {
40871 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40872 }
40873 {
40874 PyThreadState* __tstate = wxPyBeginAllowThreads();
40875 (arg1)->SetDropTarget(arg2);
40876 wxPyEndAllowThreads(__tstate);
40877 if (PyErr_Occurred()) SWIG_fail;
40878 }
40879 resultobj = SWIG_Py_Void();
40880 return resultobj;
40881 fail:
40882 return NULL;
40883 }
40884
40885
40886 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40887 PyObject *resultobj = 0;
40888 wxWindow *arg1 = (wxWindow *) 0 ;
40889 wxPyDropTarget *result = 0 ;
40890 void *argp1 = 0 ;
40891 int res1 = 0 ;
40892 PyObject *swig_obj[1] ;
40893
40894 if (!args) SWIG_fail;
40895 swig_obj[0] = args;
40896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40897 if (!SWIG_IsOK(res1)) {
40898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40899 }
40900 arg1 = reinterpret_cast< wxWindow * >(argp1);
40901 {
40902 PyThreadState* __tstate = wxPyBeginAllowThreads();
40903 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40904 wxPyEndAllowThreads(__tstate);
40905 if (PyErr_Occurred()) SWIG_fail;
40906 }
40907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40908 return resultobj;
40909 fail:
40910 return NULL;
40911 }
40912
40913
40914 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40915 PyObject *resultobj = 0;
40916 wxWindow *arg1 = (wxWindow *) 0 ;
40917 bool arg2 ;
40918 void *argp1 = 0 ;
40919 int res1 = 0 ;
40920 bool val2 ;
40921 int ecode2 = 0 ;
40922 PyObject * obj0 = 0 ;
40923 PyObject * obj1 = 0 ;
40924 char * kwnames[] = {
40925 (char *) "self",(char *) "accept", NULL
40926 };
40927
40928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40930 if (!SWIG_IsOK(res1)) {
40931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40932 }
40933 arg1 = reinterpret_cast< wxWindow * >(argp1);
40934 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40935 if (!SWIG_IsOK(ecode2)) {
40936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40937 }
40938 arg2 = static_cast< bool >(val2);
40939 {
40940 PyThreadState* __tstate = wxPyBeginAllowThreads();
40941 wxWindow_DragAcceptFiles(arg1,arg2);
40942 wxPyEndAllowThreads(__tstate);
40943 if (PyErr_Occurred()) SWIG_fail;
40944 }
40945 resultobj = SWIG_Py_Void();
40946 return resultobj;
40947 fail:
40948 return NULL;
40949 }
40950
40951
40952 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40953 PyObject *resultobj = 0;
40954 wxWindow *arg1 = (wxWindow *) 0 ;
40955 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40956 void *argp1 = 0 ;
40957 int res1 = 0 ;
40958 int res2 = 0 ;
40959 PyObject * obj0 = 0 ;
40960 PyObject * obj1 = 0 ;
40961 char * kwnames[] = {
40962 (char *) "self",(char *) "constraints", NULL
40963 };
40964
40965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40967 if (!SWIG_IsOK(res1)) {
40968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40969 }
40970 arg1 = reinterpret_cast< wxWindow * >(argp1);
40971 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40972 if (!SWIG_IsOK(res2)) {
40973 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40974 }
40975 {
40976 PyThreadState* __tstate = wxPyBeginAllowThreads();
40977 (arg1)->SetConstraints(arg2);
40978 wxPyEndAllowThreads(__tstate);
40979 if (PyErr_Occurred()) SWIG_fail;
40980 }
40981 resultobj = SWIG_Py_Void();
40982 return resultobj;
40983 fail:
40984 return NULL;
40985 }
40986
40987
40988 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40989 PyObject *resultobj = 0;
40990 wxWindow *arg1 = (wxWindow *) 0 ;
40991 wxLayoutConstraints *result = 0 ;
40992 void *argp1 = 0 ;
40993 int res1 = 0 ;
40994 PyObject *swig_obj[1] ;
40995
40996 if (!args) SWIG_fail;
40997 swig_obj[0] = args;
40998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40999 if (!SWIG_IsOK(res1)) {
41000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
41001 }
41002 arg1 = reinterpret_cast< wxWindow * >(argp1);
41003 {
41004 PyThreadState* __tstate = wxPyBeginAllowThreads();
41005 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
41006 wxPyEndAllowThreads(__tstate);
41007 if (PyErr_Occurred()) SWIG_fail;
41008 }
41009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
41010 return resultobj;
41011 fail:
41012 return NULL;
41013 }
41014
41015
41016 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41017 PyObject *resultobj = 0;
41018 wxWindow *arg1 = (wxWindow *) 0 ;
41019 bool arg2 ;
41020 void *argp1 = 0 ;
41021 int res1 = 0 ;
41022 bool val2 ;
41023 int ecode2 = 0 ;
41024 PyObject * obj0 = 0 ;
41025 PyObject * obj1 = 0 ;
41026 char * kwnames[] = {
41027 (char *) "self",(char *) "autoLayout", NULL
41028 };
41029
41030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
41031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41032 if (!SWIG_IsOK(res1)) {
41033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
41034 }
41035 arg1 = reinterpret_cast< wxWindow * >(argp1);
41036 ecode2 = SWIG_AsVal_bool(obj1, &val2);
41037 if (!SWIG_IsOK(ecode2)) {
41038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
41039 }
41040 arg2 = static_cast< bool >(val2);
41041 {
41042 PyThreadState* __tstate = wxPyBeginAllowThreads();
41043 (arg1)->SetAutoLayout(arg2);
41044 wxPyEndAllowThreads(__tstate);
41045 if (PyErr_Occurred()) SWIG_fail;
41046 }
41047 resultobj = SWIG_Py_Void();
41048 return resultobj;
41049 fail:
41050 return NULL;
41051 }
41052
41053
41054 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41055 PyObject *resultobj = 0;
41056 wxWindow *arg1 = (wxWindow *) 0 ;
41057 bool result;
41058 void *argp1 = 0 ;
41059 int res1 = 0 ;
41060 PyObject *swig_obj[1] ;
41061
41062 if (!args) SWIG_fail;
41063 swig_obj[0] = args;
41064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41065 if (!SWIG_IsOK(res1)) {
41066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
41067 }
41068 arg1 = reinterpret_cast< wxWindow * >(argp1);
41069 {
41070 PyThreadState* __tstate = wxPyBeginAllowThreads();
41071 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
41072 wxPyEndAllowThreads(__tstate);
41073 if (PyErr_Occurred()) SWIG_fail;
41074 }
41075 {
41076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41077 }
41078 return resultobj;
41079 fail:
41080 return NULL;
41081 }
41082
41083
41084 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41085 PyObject *resultobj = 0;
41086 wxWindow *arg1 = (wxWindow *) 0 ;
41087 bool result;
41088 void *argp1 = 0 ;
41089 int res1 = 0 ;
41090 PyObject *swig_obj[1] ;
41091
41092 if (!args) SWIG_fail;
41093 swig_obj[0] = args;
41094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41095 if (!SWIG_IsOK(res1)) {
41096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
41097 }
41098 arg1 = reinterpret_cast< wxWindow * >(argp1);
41099 {
41100 PyThreadState* __tstate = wxPyBeginAllowThreads();
41101 result = (bool)(arg1)->Layout();
41102 wxPyEndAllowThreads(__tstate);
41103 if (PyErr_Occurred()) SWIG_fail;
41104 }
41105 {
41106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41107 }
41108 return resultobj;
41109 fail:
41110 return NULL;
41111 }
41112
41113
41114 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41115 PyObject *resultobj = 0;
41116 wxWindow *arg1 = (wxWindow *) 0 ;
41117 wxSizer *arg2 = (wxSizer *) 0 ;
41118 bool arg3 = (bool) true ;
41119 void *argp1 = 0 ;
41120 int res1 = 0 ;
41121 int res2 = 0 ;
41122 bool val3 ;
41123 int ecode3 = 0 ;
41124 PyObject * obj0 = 0 ;
41125 PyObject * obj1 = 0 ;
41126 PyObject * obj2 = 0 ;
41127 char * kwnames[] = {
41128 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41129 };
41130
41131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41133 if (!SWIG_IsOK(res1)) {
41134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41135 }
41136 arg1 = reinterpret_cast< wxWindow * >(argp1);
41137 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41138 if (!SWIG_IsOK(res2)) {
41139 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41140 }
41141 if (obj2) {
41142 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41143 if (!SWIG_IsOK(ecode3)) {
41144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
41145 }
41146 arg3 = static_cast< bool >(val3);
41147 }
41148 {
41149 PyThreadState* __tstate = wxPyBeginAllowThreads();
41150 (arg1)->SetSizer(arg2,arg3);
41151 wxPyEndAllowThreads(__tstate);
41152 if (PyErr_Occurred()) SWIG_fail;
41153 }
41154 resultobj = SWIG_Py_Void();
41155 return resultobj;
41156 fail:
41157 return NULL;
41158 }
41159
41160
41161 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41162 PyObject *resultobj = 0;
41163 wxWindow *arg1 = (wxWindow *) 0 ;
41164 wxSizer *arg2 = (wxSizer *) 0 ;
41165 bool arg3 = (bool) true ;
41166 void *argp1 = 0 ;
41167 int res1 = 0 ;
41168 int res2 = 0 ;
41169 bool val3 ;
41170 int ecode3 = 0 ;
41171 PyObject * obj0 = 0 ;
41172 PyObject * obj1 = 0 ;
41173 PyObject * obj2 = 0 ;
41174 char * kwnames[] = {
41175 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41176 };
41177
41178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41180 if (!SWIG_IsOK(res1)) {
41181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
41182 }
41183 arg1 = reinterpret_cast< wxWindow * >(argp1);
41184 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41185 if (!SWIG_IsOK(res2)) {
41186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
41187 }
41188 if (obj2) {
41189 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41190 if (!SWIG_IsOK(ecode3)) {
41191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
41192 }
41193 arg3 = static_cast< bool >(val3);
41194 }
41195 {
41196 PyThreadState* __tstate = wxPyBeginAllowThreads();
41197 (arg1)->SetSizerAndFit(arg2,arg3);
41198 wxPyEndAllowThreads(__tstate);
41199 if (PyErr_Occurred()) SWIG_fail;
41200 }
41201 resultobj = SWIG_Py_Void();
41202 return resultobj;
41203 fail:
41204 return NULL;
41205 }
41206
41207
41208 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41209 PyObject *resultobj = 0;
41210 wxWindow *arg1 = (wxWindow *) 0 ;
41211 wxSizer *result = 0 ;
41212 void *argp1 = 0 ;
41213 int res1 = 0 ;
41214 PyObject *swig_obj[1] ;
41215
41216 if (!args) SWIG_fail;
41217 swig_obj[0] = args;
41218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41219 if (!SWIG_IsOK(res1)) {
41220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41221 }
41222 arg1 = reinterpret_cast< wxWindow * >(argp1);
41223 {
41224 PyThreadState* __tstate = wxPyBeginAllowThreads();
41225 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
41226 wxPyEndAllowThreads(__tstate);
41227 if (PyErr_Occurred()) SWIG_fail;
41228 }
41229 {
41230 resultobj = wxPyMake_wxObject(result, (bool)0);
41231 }
41232 return resultobj;
41233 fail:
41234 return NULL;
41235 }
41236
41237
41238 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41239 PyObject *resultobj = 0;
41240 wxWindow *arg1 = (wxWindow *) 0 ;
41241 wxSizer *arg2 = (wxSizer *) 0 ;
41242 void *argp1 = 0 ;
41243 int res1 = 0 ;
41244 void *argp2 = 0 ;
41245 int res2 = 0 ;
41246 PyObject * obj0 = 0 ;
41247 PyObject * obj1 = 0 ;
41248 char * kwnames[] = {
41249 (char *) "self",(char *) "sizer", NULL
41250 };
41251
41252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
41253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41254 if (!SWIG_IsOK(res1)) {
41255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41256 }
41257 arg1 = reinterpret_cast< wxWindow * >(argp1);
41258 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
41259 if (!SWIG_IsOK(res2)) {
41260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41261 }
41262 arg2 = reinterpret_cast< wxSizer * >(argp2);
41263 {
41264 PyThreadState* __tstate = wxPyBeginAllowThreads();
41265 (arg1)->SetContainingSizer(arg2);
41266 wxPyEndAllowThreads(__tstate);
41267 if (PyErr_Occurred()) SWIG_fail;
41268 }
41269 resultobj = SWIG_Py_Void();
41270 return resultobj;
41271 fail:
41272 return NULL;
41273 }
41274
41275
41276 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41277 PyObject *resultobj = 0;
41278 wxWindow *arg1 = (wxWindow *) 0 ;
41279 wxSizer *result = 0 ;
41280 void *argp1 = 0 ;
41281 int res1 = 0 ;
41282 PyObject *swig_obj[1] ;
41283
41284 if (!args) SWIG_fail;
41285 swig_obj[0] = args;
41286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41287 if (!SWIG_IsOK(res1)) {
41288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41289 }
41290 arg1 = reinterpret_cast< wxWindow * >(argp1);
41291 {
41292 PyThreadState* __tstate = wxPyBeginAllowThreads();
41293 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
41294 wxPyEndAllowThreads(__tstate);
41295 if (PyErr_Occurred()) SWIG_fail;
41296 }
41297 {
41298 resultobj = wxPyMake_wxObject(result, (bool)0);
41299 }
41300 return resultobj;
41301 fail:
41302 return NULL;
41303 }
41304
41305
41306 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41307 PyObject *resultobj = 0;
41308 wxWindow *arg1 = (wxWindow *) 0 ;
41309 void *argp1 = 0 ;
41310 int res1 = 0 ;
41311 PyObject *swig_obj[1] ;
41312
41313 if (!args) SWIG_fail;
41314 swig_obj[0] = args;
41315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41316 if (!SWIG_IsOK(res1)) {
41317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
41318 }
41319 arg1 = reinterpret_cast< wxWindow * >(argp1);
41320 {
41321 PyThreadState* __tstate = wxPyBeginAllowThreads();
41322 (arg1)->InheritAttributes();
41323 wxPyEndAllowThreads(__tstate);
41324 if (PyErr_Occurred()) SWIG_fail;
41325 }
41326 resultobj = SWIG_Py_Void();
41327 return resultobj;
41328 fail:
41329 return NULL;
41330 }
41331
41332
41333 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41334 PyObject *resultobj = 0;
41335 wxWindow *arg1 = (wxWindow *) 0 ;
41336 bool result;
41337 void *argp1 = 0 ;
41338 int res1 = 0 ;
41339 PyObject *swig_obj[1] ;
41340
41341 if (!args) SWIG_fail;
41342 swig_obj[0] = args;
41343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41344 if (!SWIG_IsOK(res1)) {
41345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41346 }
41347 arg1 = reinterpret_cast< wxWindow * >(argp1);
41348 {
41349 PyThreadState* __tstate = wxPyBeginAllowThreads();
41350 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41351 wxPyEndAllowThreads(__tstate);
41352 if (PyErr_Occurred()) SWIG_fail;
41353 }
41354 {
41355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41356 }
41357 return resultobj;
41358 fail:
41359 return NULL;
41360 }
41361
41362
41363 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41364 PyObject *resultobj = 0;
41365 wxWindow *arg1 = (wxWindow *) 0 ;
41366 bool result;
41367 void *argp1 = 0 ;
41368 int res1 = 0 ;
41369 PyObject *swig_obj[1] ;
41370
41371 if (!args) SWIG_fail;
41372 swig_obj[0] = args;
41373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41374 if (!SWIG_IsOK(res1)) {
41375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41376 }
41377 arg1 = reinterpret_cast< wxWindow * >(argp1);
41378 {
41379 PyThreadState* __tstate = wxPyBeginAllowThreads();
41380 result = (bool)(arg1)->CanSetTransparent();
41381 wxPyEndAllowThreads(__tstate);
41382 if (PyErr_Occurred()) SWIG_fail;
41383 }
41384 {
41385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41386 }
41387 return resultobj;
41388 fail:
41389 return NULL;
41390 }
41391
41392
41393 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41394 PyObject *resultobj = 0;
41395 wxWindow *arg1 = (wxWindow *) 0 ;
41396 byte arg2 ;
41397 bool result;
41398 void *argp1 = 0 ;
41399 int res1 = 0 ;
41400 unsigned char val2 ;
41401 int ecode2 = 0 ;
41402 PyObject * obj0 = 0 ;
41403 PyObject * obj1 = 0 ;
41404 char * kwnames[] = {
41405 (char *) "self",(char *) "alpha", NULL
41406 };
41407
41408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41410 if (!SWIG_IsOK(res1)) {
41411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41412 }
41413 arg1 = reinterpret_cast< wxWindow * >(argp1);
41414 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41415 if (!SWIG_IsOK(ecode2)) {
41416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41417 }
41418 arg2 = static_cast< byte >(val2);
41419 {
41420 PyThreadState* __tstate = wxPyBeginAllowThreads();
41421 result = (bool)(arg1)->SetTransparent(arg2);
41422 wxPyEndAllowThreads(__tstate);
41423 if (PyErr_Occurred()) SWIG_fail;
41424 }
41425 {
41426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41427 }
41428 return resultobj;
41429 fail:
41430 return NULL;
41431 }
41432
41433
41434 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41435 PyObject *obj;
41436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41437 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41438 return SWIG_Py_Void();
41439 }
41440
41441 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41442 return SWIG_Python_InitShadowInstance(args);
41443 }
41444
41445 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41446 PyObject *resultobj = 0;
41447 long arg1 ;
41448 wxWindow *arg2 = (wxWindow *) NULL ;
41449 wxWindow *result = 0 ;
41450 long val1 ;
41451 int ecode1 = 0 ;
41452 void *argp2 = 0 ;
41453 int res2 = 0 ;
41454 PyObject * obj0 = 0 ;
41455 PyObject * obj1 = 0 ;
41456 char * kwnames[] = {
41457 (char *) "id",(char *) "parent", NULL
41458 };
41459
41460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41461 ecode1 = SWIG_AsVal_long(obj0, &val1);
41462 if (!SWIG_IsOK(ecode1)) {
41463 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41464 }
41465 arg1 = static_cast< long >(val1);
41466 if (obj1) {
41467 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41468 if (!SWIG_IsOK(res2)) {
41469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41470 }
41471 arg2 = reinterpret_cast< wxWindow * >(argp2);
41472 }
41473 {
41474 if (!wxPyCheckForApp()) SWIG_fail;
41475 PyThreadState* __tstate = wxPyBeginAllowThreads();
41476 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41477 wxPyEndAllowThreads(__tstate);
41478 if (PyErr_Occurred()) SWIG_fail;
41479 }
41480 {
41481 resultobj = wxPyMake_wxObject(result, 0);
41482 }
41483 return resultobj;
41484 fail:
41485 return NULL;
41486 }
41487
41488
41489 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41490 PyObject *resultobj = 0;
41491 wxString *arg1 = 0 ;
41492 wxWindow *arg2 = (wxWindow *) NULL ;
41493 wxWindow *result = 0 ;
41494 bool temp1 = false ;
41495 void *argp2 = 0 ;
41496 int res2 = 0 ;
41497 PyObject * obj0 = 0 ;
41498 PyObject * obj1 = 0 ;
41499 char * kwnames[] = {
41500 (char *) "name",(char *) "parent", NULL
41501 };
41502
41503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41504 {
41505 arg1 = wxString_in_helper(obj0);
41506 if (arg1 == NULL) SWIG_fail;
41507 temp1 = true;
41508 }
41509 if (obj1) {
41510 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41511 if (!SWIG_IsOK(res2)) {
41512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41513 }
41514 arg2 = reinterpret_cast< wxWindow * >(argp2);
41515 }
41516 {
41517 if (!wxPyCheckForApp()) SWIG_fail;
41518 PyThreadState* __tstate = wxPyBeginAllowThreads();
41519 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41520 wxPyEndAllowThreads(__tstate);
41521 if (PyErr_Occurred()) SWIG_fail;
41522 }
41523 {
41524 resultobj = wxPyMake_wxObject(result, 0);
41525 }
41526 {
41527 if (temp1)
41528 delete arg1;
41529 }
41530 return resultobj;
41531 fail:
41532 {
41533 if (temp1)
41534 delete arg1;
41535 }
41536 return NULL;
41537 }
41538
41539
41540 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41541 PyObject *resultobj = 0;
41542 wxString *arg1 = 0 ;
41543 wxWindow *arg2 = (wxWindow *) NULL ;
41544 wxWindow *result = 0 ;
41545 bool temp1 = false ;
41546 void *argp2 = 0 ;
41547 int res2 = 0 ;
41548 PyObject * obj0 = 0 ;
41549 PyObject * obj1 = 0 ;
41550 char * kwnames[] = {
41551 (char *) "label",(char *) "parent", NULL
41552 };
41553
41554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41555 {
41556 arg1 = wxString_in_helper(obj0);
41557 if (arg1 == NULL) SWIG_fail;
41558 temp1 = true;
41559 }
41560 if (obj1) {
41561 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41562 if (!SWIG_IsOK(res2)) {
41563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41564 }
41565 arg2 = reinterpret_cast< wxWindow * >(argp2);
41566 }
41567 {
41568 if (!wxPyCheckForApp()) SWIG_fail;
41569 PyThreadState* __tstate = wxPyBeginAllowThreads();
41570 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41571 wxPyEndAllowThreads(__tstate);
41572 if (PyErr_Occurred()) SWIG_fail;
41573 }
41574 {
41575 resultobj = wxPyMake_wxObject(result, 0);
41576 }
41577 {
41578 if (temp1)
41579 delete arg1;
41580 }
41581 return resultobj;
41582 fail:
41583 {
41584 if (temp1)
41585 delete arg1;
41586 }
41587 return NULL;
41588 }
41589
41590
41591 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41592 PyObject *resultobj = 0;
41593 wxWindow *arg1 = (wxWindow *) 0 ;
41594 unsigned long arg2 ;
41595 wxWindow *result = 0 ;
41596 void *argp1 = 0 ;
41597 int res1 = 0 ;
41598 unsigned long val2 ;
41599 int ecode2 = 0 ;
41600 PyObject * obj0 = 0 ;
41601 PyObject * obj1 = 0 ;
41602 char * kwnames[] = {
41603 (char *) "parent",(char *) "_hWnd", NULL
41604 };
41605
41606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41608 if (!SWIG_IsOK(res1)) {
41609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41610 }
41611 arg1 = reinterpret_cast< wxWindow * >(argp1);
41612 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41613 if (!SWIG_IsOK(ecode2)) {
41614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41615 }
41616 arg2 = static_cast< unsigned long >(val2);
41617 {
41618 if (!wxPyCheckForApp()) SWIG_fail;
41619 PyThreadState* __tstate = wxPyBeginAllowThreads();
41620 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41621 wxPyEndAllowThreads(__tstate);
41622 if (PyErr_Occurred()) SWIG_fail;
41623 }
41624 {
41625 resultobj = wxPyMake_wxObject(result, 0);
41626 }
41627 return resultobj;
41628 fail:
41629 return NULL;
41630 }
41631
41632
41633 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41634 PyObject *resultobj = 0;
41635 PyObject *result = 0 ;
41636
41637 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41638 {
41639 PyThreadState* __tstate = wxPyBeginAllowThreads();
41640 result = (PyObject *)GetTopLevelWindows();
41641 wxPyEndAllowThreads(__tstate);
41642 if (PyErr_Occurred()) SWIG_fail;
41643 }
41644 resultobj = result;
41645 return resultobj;
41646 fail:
41647 return NULL;
41648 }
41649
41650
41651 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41652 PyObject *resultobj = 0;
41653 wxValidator *result = 0 ;
41654
41655 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41656 {
41657 PyThreadState* __tstate = wxPyBeginAllowThreads();
41658 result = (wxValidator *)new wxValidator();
41659 wxPyEndAllowThreads(__tstate);
41660 if (PyErr_Occurred()) SWIG_fail;
41661 }
41662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41663 return resultobj;
41664 fail:
41665 return NULL;
41666 }
41667
41668
41669 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41670 PyObject *resultobj = 0;
41671 wxValidator *arg1 = (wxValidator *) 0 ;
41672 wxValidator *result = 0 ;
41673 void *argp1 = 0 ;
41674 int res1 = 0 ;
41675 PyObject *swig_obj[1] ;
41676
41677 if (!args) SWIG_fail;
41678 swig_obj[0] = args;
41679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41680 if (!SWIG_IsOK(res1)) {
41681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41682 }
41683 arg1 = reinterpret_cast< wxValidator * >(argp1);
41684 {
41685 PyThreadState* __tstate = wxPyBeginAllowThreads();
41686 result = (wxValidator *)(arg1)->Clone();
41687 wxPyEndAllowThreads(__tstate);
41688 if (PyErr_Occurred()) SWIG_fail;
41689 }
41690 {
41691 resultobj = wxPyMake_wxObject(result, 0);
41692 }
41693 return resultobj;
41694 fail:
41695 return NULL;
41696 }
41697
41698
41699 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41700 PyObject *resultobj = 0;
41701 wxValidator *arg1 = (wxValidator *) 0 ;
41702 wxWindow *arg2 = (wxWindow *) 0 ;
41703 bool result;
41704 void *argp1 = 0 ;
41705 int res1 = 0 ;
41706 void *argp2 = 0 ;
41707 int res2 = 0 ;
41708 PyObject * obj0 = 0 ;
41709 PyObject * obj1 = 0 ;
41710 char * kwnames[] = {
41711 (char *) "self",(char *) "parent", NULL
41712 };
41713
41714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41716 if (!SWIG_IsOK(res1)) {
41717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41718 }
41719 arg1 = reinterpret_cast< wxValidator * >(argp1);
41720 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41721 if (!SWIG_IsOK(res2)) {
41722 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41723 }
41724 arg2 = reinterpret_cast< wxWindow * >(argp2);
41725 {
41726 PyThreadState* __tstate = wxPyBeginAllowThreads();
41727 result = (bool)(arg1)->Validate(arg2);
41728 wxPyEndAllowThreads(__tstate);
41729 if (PyErr_Occurred()) SWIG_fail;
41730 }
41731 {
41732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41733 }
41734 return resultobj;
41735 fail:
41736 return NULL;
41737 }
41738
41739
41740 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41741 PyObject *resultobj = 0;
41742 wxValidator *arg1 = (wxValidator *) 0 ;
41743 bool result;
41744 void *argp1 = 0 ;
41745 int res1 = 0 ;
41746 PyObject *swig_obj[1] ;
41747
41748 if (!args) SWIG_fail;
41749 swig_obj[0] = args;
41750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41751 if (!SWIG_IsOK(res1)) {
41752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41753 }
41754 arg1 = reinterpret_cast< wxValidator * >(argp1);
41755 {
41756 PyThreadState* __tstate = wxPyBeginAllowThreads();
41757 result = (bool)(arg1)->TransferToWindow();
41758 wxPyEndAllowThreads(__tstate);
41759 if (PyErr_Occurred()) SWIG_fail;
41760 }
41761 {
41762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41763 }
41764 return resultobj;
41765 fail:
41766 return NULL;
41767 }
41768
41769
41770 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41771 PyObject *resultobj = 0;
41772 wxValidator *arg1 = (wxValidator *) 0 ;
41773 bool result;
41774 void *argp1 = 0 ;
41775 int res1 = 0 ;
41776 PyObject *swig_obj[1] ;
41777
41778 if (!args) SWIG_fail;
41779 swig_obj[0] = args;
41780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41781 if (!SWIG_IsOK(res1)) {
41782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41783 }
41784 arg1 = reinterpret_cast< wxValidator * >(argp1);
41785 {
41786 PyThreadState* __tstate = wxPyBeginAllowThreads();
41787 result = (bool)(arg1)->TransferFromWindow();
41788 wxPyEndAllowThreads(__tstate);
41789 if (PyErr_Occurred()) SWIG_fail;
41790 }
41791 {
41792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41793 }
41794 return resultobj;
41795 fail:
41796 return NULL;
41797 }
41798
41799
41800 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41801 PyObject *resultobj = 0;
41802 wxValidator *arg1 = (wxValidator *) 0 ;
41803 wxWindow *result = 0 ;
41804 void *argp1 = 0 ;
41805 int res1 = 0 ;
41806 PyObject *swig_obj[1] ;
41807
41808 if (!args) SWIG_fail;
41809 swig_obj[0] = args;
41810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41811 if (!SWIG_IsOK(res1)) {
41812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41813 }
41814 arg1 = reinterpret_cast< wxValidator * >(argp1);
41815 {
41816 PyThreadState* __tstate = wxPyBeginAllowThreads();
41817 result = (wxWindow *)(arg1)->GetWindow();
41818 wxPyEndAllowThreads(__tstate);
41819 if (PyErr_Occurred()) SWIG_fail;
41820 }
41821 {
41822 resultobj = wxPyMake_wxObject(result, 0);
41823 }
41824 return resultobj;
41825 fail:
41826 return NULL;
41827 }
41828
41829
41830 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41831 PyObject *resultobj = 0;
41832 wxValidator *arg1 = (wxValidator *) 0 ;
41833 wxWindow *arg2 = (wxWindow *) 0 ;
41834 void *argp1 = 0 ;
41835 int res1 = 0 ;
41836 void *argp2 = 0 ;
41837 int res2 = 0 ;
41838 PyObject * obj0 = 0 ;
41839 PyObject * obj1 = 0 ;
41840 char * kwnames[] = {
41841 (char *) "self",(char *) "window", NULL
41842 };
41843
41844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41846 if (!SWIG_IsOK(res1)) {
41847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41848 }
41849 arg1 = reinterpret_cast< wxValidator * >(argp1);
41850 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41851 if (!SWIG_IsOK(res2)) {
41852 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41853 }
41854 arg2 = reinterpret_cast< wxWindow * >(argp2);
41855 {
41856 PyThreadState* __tstate = wxPyBeginAllowThreads();
41857 (arg1)->SetWindow(arg2);
41858 wxPyEndAllowThreads(__tstate);
41859 if (PyErr_Occurred()) SWIG_fail;
41860 }
41861 resultobj = SWIG_Py_Void();
41862 return resultobj;
41863 fail:
41864 return NULL;
41865 }
41866
41867
41868 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41869 PyObject *resultobj = 0;
41870 bool result;
41871
41872 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41873 {
41874 PyThreadState* __tstate = wxPyBeginAllowThreads();
41875 result = (bool)wxValidator::IsSilent();
41876 wxPyEndAllowThreads(__tstate);
41877 if (PyErr_Occurred()) SWIG_fail;
41878 }
41879 {
41880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41881 }
41882 return resultobj;
41883 fail:
41884 return NULL;
41885 }
41886
41887
41888 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41889 PyObject *resultobj = 0;
41890 int arg1 = (int) true ;
41891 int val1 ;
41892 int ecode1 = 0 ;
41893 PyObject * obj0 = 0 ;
41894 char * kwnames[] = {
41895 (char *) "doIt", NULL
41896 };
41897
41898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41899 if (obj0) {
41900 ecode1 = SWIG_AsVal_int(obj0, &val1);
41901 if (!SWIG_IsOK(ecode1)) {
41902 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41903 }
41904 arg1 = static_cast< int >(val1);
41905 }
41906 {
41907 PyThreadState* __tstate = wxPyBeginAllowThreads();
41908 wxValidator::SetBellOnError(arg1);
41909 wxPyEndAllowThreads(__tstate);
41910 if (PyErr_Occurred()) SWIG_fail;
41911 }
41912 resultobj = SWIG_Py_Void();
41913 return resultobj;
41914 fail:
41915 return NULL;
41916 }
41917
41918
41919 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41920 PyObject *obj;
41921 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41922 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41923 return SWIG_Py_Void();
41924 }
41925
41926 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41927 return SWIG_Python_InitShadowInstance(args);
41928 }
41929
41930 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41931 PyObject *resultobj = 0;
41932 wxPyValidator *result = 0 ;
41933
41934 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41935 {
41936 PyThreadState* __tstate = wxPyBeginAllowThreads();
41937 result = (wxPyValidator *)new wxPyValidator();
41938 wxPyEndAllowThreads(__tstate);
41939 if (PyErr_Occurred()) SWIG_fail;
41940 }
41941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41942 return resultobj;
41943 fail:
41944 return NULL;
41945 }
41946
41947
41948 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41949 PyObject *resultobj = 0;
41950 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41951 PyObject *arg2 = (PyObject *) 0 ;
41952 PyObject *arg3 = (PyObject *) 0 ;
41953 int arg4 = (int) 1 ;
41954 void *argp1 = 0 ;
41955 int res1 = 0 ;
41956 int val4 ;
41957 int ecode4 = 0 ;
41958 PyObject * obj0 = 0 ;
41959 PyObject * obj1 = 0 ;
41960 PyObject * obj2 = 0 ;
41961 PyObject * obj3 = 0 ;
41962 char * kwnames[] = {
41963 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41964 };
41965
41966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41968 if (!SWIG_IsOK(res1)) {
41969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41970 }
41971 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41972 arg2 = obj1;
41973 arg3 = obj2;
41974 if (obj3) {
41975 ecode4 = SWIG_AsVal_int(obj3, &val4);
41976 if (!SWIG_IsOK(ecode4)) {
41977 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41978 }
41979 arg4 = static_cast< int >(val4);
41980 }
41981 {
41982 PyThreadState* __tstate = wxPyBeginAllowThreads();
41983 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41984 wxPyEndAllowThreads(__tstate);
41985 if (PyErr_Occurred()) SWIG_fail;
41986 }
41987 resultobj = SWIG_Py_Void();
41988 return resultobj;
41989 fail:
41990 return NULL;
41991 }
41992
41993
41994 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41995 PyObject *obj;
41996 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41997 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41998 return SWIG_Py_Void();
41999 }
42000
42001 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42002 return SWIG_Python_InitShadowInstance(args);
42003 }
42004
42005 SWIGINTERN int DefaultValidator_set(PyObject *) {
42006 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
42007 return 1;
42008 }
42009
42010
42011 SWIGINTERN PyObject *DefaultValidator_get(void) {
42012 PyObject *pyobj = 0;
42013
42014 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
42015 return pyobj;
42016 }
42017
42018
42019 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42020 PyObject *resultobj = 0;
42021 wxString const &arg1_defvalue = wxPyEmptyString ;
42022 wxString *arg1 = (wxString *) &arg1_defvalue ;
42023 long arg2 = (long) 0 ;
42024 wxMenu *result = 0 ;
42025 bool temp1 = false ;
42026 long val2 ;
42027 int ecode2 = 0 ;
42028 PyObject * obj0 = 0 ;
42029 PyObject * obj1 = 0 ;
42030 char * kwnames[] = {
42031 (char *) "title",(char *) "style", NULL
42032 };
42033
42034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
42035 if (obj0) {
42036 {
42037 arg1 = wxString_in_helper(obj0);
42038 if (arg1 == NULL) SWIG_fail;
42039 temp1 = true;
42040 }
42041 }
42042 if (obj1) {
42043 ecode2 = SWIG_AsVal_long(obj1, &val2);
42044 if (!SWIG_IsOK(ecode2)) {
42045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
42046 }
42047 arg2 = static_cast< long >(val2);
42048 }
42049 {
42050 if (!wxPyCheckForApp()) SWIG_fail;
42051 PyThreadState* __tstate = wxPyBeginAllowThreads();
42052 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
42053 wxPyEndAllowThreads(__tstate);
42054 if (PyErr_Occurred()) SWIG_fail;
42055 }
42056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
42057 {
42058 if (temp1)
42059 delete arg1;
42060 }
42061 return resultobj;
42062 fail:
42063 {
42064 if (temp1)
42065 delete arg1;
42066 }
42067 return NULL;
42068 }
42069
42070
42071 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42072 PyObject *resultobj = 0;
42073 wxMenu *arg1 = (wxMenu *) 0 ;
42074 int arg2 ;
42075 wxString const &arg3_defvalue = wxPyEmptyString ;
42076 wxString *arg3 = (wxString *) &arg3_defvalue ;
42077 wxString const &arg4_defvalue = wxPyEmptyString ;
42078 wxString *arg4 = (wxString *) &arg4_defvalue ;
42079 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42080 wxMenuItem *result = 0 ;
42081 void *argp1 = 0 ;
42082 int res1 = 0 ;
42083 int val2 ;
42084 int ecode2 = 0 ;
42085 bool temp3 = false ;
42086 bool temp4 = false ;
42087 int val5 ;
42088 int ecode5 = 0 ;
42089 PyObject * obj0 = 0 ;
42090 PyObject * obj1 = 0 ;
42091 PyObject * obj2 = 0 ;
42092 PyObject * obj3 = 0 ;
42093 PyObject * obj4 = 0 ;
42094 char * kwnames[] = {
42095 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42096 };
42097
42098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42100 if (!SWIG_IsOK(res1)) {
42101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
42102 }
42103 arg1 = reinterpret_cast< wxMenu * >(argp1);
42104 ecode2 = SWIG_AsVal_int(obj1, &val2);
42105 if (!SWIG_IsOK(ecode2)) {
42106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
42107 }
42108 arg2 = static_cast< int >(val2);
42109 if (obj2) {
42110 {
42111 arg3 = wxString_in_helper(obj2);
42112 if (arg3 == NULL) SWIG_fail;
42113 temp3 = true;
42114 }
42115 }
42116 if (obj3) {
42117 {
42118 arg4 = wxString_in_helper(obj3);
42119 if (arg4 == NULL) SWIG_fail;
42120 temp4 = true;
42121 }
42122 }
42123 if (obj4) {
42124 ecode5 = SWIG_AsVal_int(obj4, &val5);
42125 if (!SWIG_IsOK(ecode5)) {
42126 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
42127 }
42128 arg5 = static_cast< wxItemKind >(val5);
42129 }
42130 {
42131 PyThreadState* __tstate = wxPyBeginAllowThreads();
42132 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42133 wxPyEndAllowThreads(__tstate);
42134 if (PyErr_Occurred()) SWIG_fail;
42135 }
42136 {
42137 resultobj = wxPyMake_wxObject(result, (bool)0);
42138 }
42139 {
42140 if (temp3)
42141 delete arg3;
42142 }
42143 {
42144 if (temp4)
42145 delete arg4;
42146 }
42147 return resultobj;
42148 fail:
42149 {
42150 if (temp3)
42151 delete arg3;
42152 }
42153 {
42154 if (temp4)
42155 delete arg4;
42156 }
42157 return NULL;
42158 }
42159
42160
42161 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42162 PyObject *resultobj = 0;
42163 wxMenu *arg1 = (wxMenu *) 0 ;
42164 wxMenuItem *result = 0 ;
42165 void *argp1 = 0 ;
42166 int res1 = 0 ;
42167 PyObject *swig_obj[1] ;
42168
42169 if (!args) SWIG_fail;
42170 swig_obj[0] = args;
42171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42172 if (!SWIG_IsOK(res1)) {
42173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42174 }
42175 arg1 = reinterpret_cast< wxMenu * >(argp1);
42176 {
42177 PyThreadState* __tstate = wxPyBeginAllowThreads();
42178 result = (wxMenuItem *)(arg1)->AppendSeparator();
42179 wxPyEndAllowThreads(__tstate);
42180 if (PyErr_Occurred()) SWIG_fail;
42181 }
42182 {
42183 resultobj = wxPyMake_wxObject(result, (bool)0);
42184 }
42185 return resultobj;
42186 fail:
42187 return NULL;
42188 }
42189
42190
42191 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42192 PyObject *resultobj = 0;
42193 wxMenu *arg1 = (wxMenu *) 0 ;
42194 int arg2 ;
42195 wxString *arg3 = 0 ;
42196 wxString const &arg4_defvalue = wxPyEmptyString ;
42197 wxString *arg4 = (wxString *) &arg4_defvalue ;
42198 wxMenuItem *result = 0 ;
42199 void *argp1 = 0 ;
42200 int res1 = 0 ;
42201 int val2 ;
42202 int ecode2 = 0 ;
42203 bool temp3 = false ;
42204 bool temp4 = false ;
42205 PyObject * obj0 = 0 ;
42206 PyObject * obj1 = 0 ;
42207 PyObject * obj2 = 0 ;
42208 PyObject * obj3 = 0 ;
42209 char * kwnames[] = {
42210 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42211 };
42212
42213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42215 if (!SWIG_IsOK(res1)) {
42216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42217 }
42218 arg1 = reinterpret_cast< wxMenu * >(argp1);
42219 ecode2 = SWIG_AsVal_int(obj1, &val2);
42220 if (!SWIG_IsOK(ecode2)) {
42221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
42222 }
42223 arg2 = static_cast< int >(val2);
42224 {
42225 arg3 = wxString_in_helper(obj2);
42226 if (arg3 == NULL) SWIG_fail;
42227 temp3 = true;
42228 }
42229 if (obj3) {
42230 {
42231 arg4 = wxString_in_helper(obj3);
42232 if (arg4 == NULL) SWIG_fail;
42233 temp4 = true;
42234 }
42235 }
42236 {
42237 PyThreadState* __tstate = wxPyBeginAllowThreads();
42238 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42239 wxPyEndAllowThreads(__tstate);
42240 if (PyErr_Occurred()) SWIG_fail;
42241 }
42242 {
42243 resultobj = wxPyMake_wxObject(result, (bool)0);
42244 }
42245 {
42246 if (temp3)
42247 delete arg3;
42248 }
42249 {
42250 if (temp4)
42251 delete arg4;
42252 }
42253 return resultobj;
42254 fail:
42255 {
42256 if (temp3)
42257 delete arg3;
42258 }
42259 {
42260 if (temp4)
42261 delete arg4;
42262 }
42263 return NULL;
42264 }
42265
42266
42267 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42268 PyObject *resultobj = 0;
42269 wxMenu *arg1 = (wxMenu *) 0 ;
42270 int arg2 ;
42271 wxString *arg3 = 0 ;
42272 wxString const &arg4_defvalue = wxPyEmptyString ;
42273 wxString *arg4 = (wxString *) &arg4_defvalue ;
42274 wxMenuItem *result = 0 ;
42275 void *argp1 = 0 ;
42276 int res1 = 0 ;
42277 int val2 ;
42278 int ecode2 = 0 ;
42279 bool temp3 = false ;
42280 bool temp4 = false ;
42281 PyObject * obj0 = 0 ;
42282 PyObject * obj1 = 0 ;
42283 PyObject * obj2 = 0 ;
42284 PyObject * obj3 = 0 ;
42285 char * kwnames[] = {
42286 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42287 };
42288
42289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42291 if (!SWIG_IsOK(res1)) {
42292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42293 }
42294 arg1 = reinterpret_cast< wxMenu * >(argp1);
42295 ecode2 = SWIG_AsVal_int(obj1, &val2);
42296 if (!SWIG_IsOK(ecode2)) {
42297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
42298 }
42299 arg2 = static_cast< int >(val2);
42300 {
42301 arg3 = wxString_in_helper(obj2);
42302 if (arg3 == NULL) SWIG_fail;
42303 temp3 = true;
42304 }
42305 if (obj3) {
42306 {
42307 arg4 = wxString_in_helper(obj3);
42308 if (arg4 == NULL) SWIG_fail;
42309 temp4 = true;
42310 }
42311 }
42312 {
42313 PyThreadState* __tstate = wxPyBeginAllowThreads();
42314 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42315 wxPyEndAllowThreads(__tstate);
42316 if (PyErr_Occurred()) SWIG_fail;
42317 }
42318 {
42319 resultobj = wxPyMake_wxObject(result, (bool)0);
42320 }
42321 {
42322 if (temp3)
42323 delete arg3;
42324 }
42325 {
42326 if (temp4)
42327 delete arg4;
42328 }
42329 return resultobj;
42330 fail:
42331 {
42332 if (temp3)
42333 delete arg3;
42334 }
42335 {
42336 if (temp4)
42337 delete arg4;
42338 }
42339 return NULL;
42340 }
42341
42342
42343 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42344 PyObject *resultobj = 0;
42345 wxMenu *arg1 = (wxMenu *) 0 ;
42346 int arg2 ;
42347 wxString *arg3 = 0 ;
42348 wxMenu *arg4 = (wxMenu *) 0 ;
42349 wxString const &arg5_defvalue = wxPyEmptyString ;
42350 wxString *arg5 = (wxString *) &arg5_defvalue ;
42351 wxMenuItem *result = 0 ;
42352 void *argp1 = 0 ;
42353 int res1 = 0 ;
42354 int val2 ;
42355 int ecode2 = 0 ;
42356 bool temp3 = false ;
42357 void *argp4 = 0 ;
42358 int res4 = 0 ;
42359 bool temp5 = false ;
42360 PyObject * obj0 = 0 ;
42361 PyObject * obj1 = 0 ;
42362 PyObject * obj2 = 0 ;
42363 PyObject * obj3 = 0 ;
42364 PyObject * obj4 = 0 ;
42365 char * kwnames[] = {
42366 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42367 };
42368
42369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42371 if (!SWIG_IsOK(res1)) {
42372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42373 }
42374 arg1 = reinterpret_cast< wxMenu * >(argp1);
42375 ecode2 = SWIG_AsVal_int(obj1, &val2);
42376 if (!SWIG_IsOK(ecode2)) {
42377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42378 }
42379 arg2 = static_cast< int >(val2);
42380 {
42381 arg3 = wxString_in_helper(obj2);
42382 if (arg3 == NULL) SWIG_fail;
42383 temp3 = true;
42384 }
42385 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42386 if (!SWIG_IsOK(res4)) {
42387 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42388 }
42389 arg4 = reinterpret_cast< wxMenu * >(argp4);
42390 if (obj4) {
42391 {
42392 arg5 = wxString_in_helper(obj4);
42393 if (arg5 == NULL) SWIG_fail;
42394 temp5 = true;
42395 }
42396 }
42397 {
42398 PyThreadState* __tstate = wxPyBeginAllowThreads();
42399 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42400 wxPyEndAllowThreads(__tstate);
42401 if (PyErr_Occurred()) SWIG_fail;
42402 }
42403 {
42404 resultobj = wxPyMake_wxObject(result, (bool)0);
42405 }
42406 {
42407 if (temp3)
42408 delete arg3;
42409 }
42410 {
42411 if (temp5)
42412 delete arg5;
42413 }
42414 return resultobj;
42415 fail:
42416 {
42417 if (temp3)
42418 delete arg3;
42419 }
42420 {
42421 if (temp5)
42422 delete arg5;
42423 }
42424 return NULL;
42425 }
42426
42427
42428 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42429 PyObject *resultobj = 0;
42430 wxMenu *arg1 = (wxMenu *) 0 ;
42431 wxMenu *arg2 = (wxMenu *) 0 ;
42432 wxString *arg3 = 0 ;
42433 wxString const &arg4_defvalue = wxPyEmptyString ;
42434 wxString *arg4 = (wxString *) &arg4_defvalue ;
42435 wxMenuItem *result = 0 ;
42436 void *argp1 = 0 ;
42437 int res1 = 0 ;
42438 void *argp2 = 0 ;
42439 int res2 = 0 ;
42440 bool temp3 = false ;
42441 bool temp4 = false ;
42442 PyObject * obj0 = 0 ;
42443 PyObject * obj1 = 0 ;
42444 PyObject * obj2 = 0 ;
42445 PyObject * obj3 = 0 ;
42446 char * kwnames[] = {
42447 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42448 };
42449
42450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42452 if (!SWIG_IsOK(res1)) {
42453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42454 }
42455 arg1 = reinterpret_cast< wxMenu * >(argp1);
42456 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42457 if (!SWIG_IsOK(res2)) {
42458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42459 }
42460 arg2 = reinterpret_cast< wxMenu * >(argp2);
42461 {
42462 arg3 = wxString_in_helper(obj2);
42463 if (arg3 == NULL) SWIG_fail;
42464 temp3 = true;
42465 }
42466 if (obj3) {
42467 {
42468 arg4 = wxString_in_helper(obj3);
42469 if (arg4 == NULL) SWIG_fail;
42470 temp4 = true;
42471 }
42472 }
42473 {
42474 PyThreadState* __tstate = wxPyBeginAllowThreads();
42475 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42476 wxPyEndAllowThreads(__tstate);
42477 if (PyErr_Occurred()) SWIG_fail;
42478 }
42479 {
42480 resultobj = wxPyMake_wxObject(result, (bool)0);
42481 }
42482 {
42483 if (temp3)
42484 delete arg3;
42485 }
42486 {
42487 if (temp4)
42488 delete arg4;
42489 }
42490 return resultobj;
42491 fail:
42492 {
42493 if (temp3)
42494 delete arg3;
42495 }
42496 {
42497 if (temp4)
42498 delete arg4;
42499 }
42500 return NULL;
42501 }
42502
42503
42504 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42505 PyObject *resultobj = 0;
42506 wxMenu *arg1 = (wxMenu *) 0 ;
42507 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42508 wxMenuItem *result = 0 ;
42509 void *argp1 = 0 ;
42510 int res1 = 0 ;
42511 int res2 = 0 ;
42512 PyObject * obj0 = 0 ;
42513 PyObject * obj1 = 0 ;
42514 char * kwnames[] = {
42515 (char *) "self",(char *) "item", NULL
42516 };
42517
42518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42520 if (!SWIG_IsOK(res1)) {
42521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42522 }
42523 arg1 = reinterpret_cast< wxMenu * >(argp1);
42524 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42525 if (!SWIG_IsOK(res2)) {
42526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42527 }
42528 {
42529 PyThreadState* __tstate = wxPyBeginAllowThreads();
42530 result = (wxMenuItem *)(arg1)->Append(arg2);
42531 wxPyEndAllowThreads(__tstate);
42532 if (PyErr_Occurred()) SWIG_fail;
42533 }
42534 {
42535 resultobj = wxPyMake_wxObject(result, (bool)0);
42536 }
42537 return resultobj;
42538 fail:
42539 return NULL;
42540 }
42541
42542
42543 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42544 PyObject *resultobj = 0;
42545 wxMenu *arg1 = (wxMenu *) 0 ;
42546 size_t arg2 ;
42547 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42548 wxMenuItem *result = 0 ;
42549 void *argp1 = 0 ;
42550 int res1 = 0 ;
42551 size_t val2 ;
42552 int ecode2 = 0 ;
42553 int res3 = 0 ;
42554 PyObject * obj0 = 0 ;
42555 PyObject * obj1 = 0 ;
42556 PyObject * obj2 = 0 ;
42557 char * kwnames[] = {
42558 (char *) "self",(char *) "pos",(char *) "item", NULL
42559 };
42560
42561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42563 if (!SWIG_IsOK(res1)) {
42564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42565 }
42566 arg1 = reinterpret_cast< wxMenu * >(argp1);
42567 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42568 if (!SWIG_IsOK(ecode2)) {
42569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42570 }
42571 arg2 = static_cast< size_t >(val2);
42572 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42573 if (!SWIG_IsOK(res3)) {
42574 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42575 }
42576 {
42577 PyThreadState* __tstate = wxPyBeginAllowThreads();
42578 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42579 wxPyEndAllowThreads(__tstate);
42580 if (PyErr_Occurred()) SWIG_fail;
42581 }
42582 {
42583 resultobj = wxPyMake_wxObject(result, (bool)0);
42584 }
42585 return resultobj;
42586 fail:
42587 return NULL;
42588 }
42589
42590
42591 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42592 PyObject *resultobj = 0;
42593 wxMenu *arg1 = (wxMenu *) 0 ;
42594 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42595 wxMenuItem *result = 0 ;
42596 void *argp1 = 0 ;
42597 int res1 = 0 ;
42598 int res2 = 0 ;
42599 PyObject * obj0 = 0 ;
42600 PyObject * obj1 = 0 ;
42601 char * kwnames[] = {
42602 (char *) "self",(char *) "item", NULL
42603 };
42604
42605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42607 if (!SWIG_IsOK(res1)) {
42608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42609 }
42610 arg1 = reinterpret_cast< wxMenu * >(argp1);
42611 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42612 if (!SWIG_IsOK(res2)) {
42613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42614 }
42615 {
42616 PyThreadState* __tstate = wxPyBeginAllowThreads();
42617 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42618 wxPyEndAllowThreads(__tstate);
42619 if (PyErr_Occurred()) SWIG_fail;
42620 }
42621 {
42622 resultobj = wxPyMake_wxObject(result, (bool)0);
42623 }
42624 return resultobj;
42625 fail:
42626 return NULL;
42627 }
42628
42629
42630 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42631 PyObject *resultobj = 0;
42632 wxMenu *arg1 = (wxMenu *) 0 ;
42633 void *argp1 = 0 ;
42634 int res1 = 0 ;
42635 PyObject *swig_obj[1] ;
42636
42637 if (!args) SWIG_fail;
42638 swig_obj[0] = args;
42639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42640 if (!SWIG_IsOK(res1)) {
42641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42642 }
42643 arg1 = reinterpret_cast< wxMenu * >(argp1);
42644 {
42645 PyThreadState* __tstate = wxPyBeginAllowThreads();
42646 (arg1)->Break();
42647 wxPyEndAllowThreads(__tstate);
42648 if (PyErr_Occurred()) SWIG_fail;
42649 }
42650 resultobj = SWIG_Py_Void();
42651 return resultobj;
42652 fail:
42653 return NULL;
42654 }
42655
42656
42657 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42658 PyObject *resultobj = 0;
42659 wxMenu *arg1 = (wxMenu *) 0 ;
42660 size_t arg2 ;
42661 int arg3 ;
42662 wxString const &arg4_defvalue = wxPyEmptyString ;
42663 wxString *arg4 = (wxString *) &arg4_defvalue ;
42664 wxString const &arg5_defvalue = wxPyEmptyString ;
42665 wxString *arg5 = (wxString *) &arg5_defvalue ;
42666 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42667 wxMenuItem *result = 0 ;
42668 void *argp1 = 0 ;
42669 int res1 = 0 ;
42670 size_t val2 ;
42671 int ecode2 = 0 ;
42672 int val3 ;
42673 int ecode3 = 0 ;
42674 bool temp4 = false ;
42675 bool temp5 = false ;
42676 int val6 ;
42677 int ecode6 = 0 ;
42678 PyObject * obj0 = 0 ;
42679 PyObject * obj1 = 0 ;
42680 PyObject * obj2 = 0 ;
42681 PyObject * obj3 = 0 ;
42682 PyObject * obj4 = 0 ;
42683 PyObject * obj5 = 0 ;
42684 char * kwnames[] = {
42685 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42686 };
42687
42688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42690 if (!SWIG_IsOK(res1)) {
42691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42692 }
42693 arg1 = reinterpret_cast< wxMenu * >(argp1);
42694 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42695 if (!SWIG_IsOK(ecode2)) {
42696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42697 }
42698 arg2 = static_cast< size_t >(val2);
42699 ecode3 = SWIG_AsVal_int(obj2, &val3);
42700 if (!SWIG_IsOK(ecode3)) {
42701 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42702 }
42703 arg3 = static_cast< int >(val3);
42704 if (obj3) {
42705 {
42706 arg4 = wxString_in_helper(obj3);
42707 if (arg4 == NULL) SWIG_fail;
42708 temp4 = true;
42709 }
42710 }
42711 if (obj4) {
42712 {
42713 arg5 = wxString_in_helper(obj4);
42714 if (arg5 == NULL) SWIG_fail;
42715 temp5 = true;
42716 }
42717 }
42718 if (obj5) {
42719 ecode6 = SWIG_AsVal_int(obj5, &val6);
42720 if (!SWIG_IsOK(ecode6)) {
42721 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42722 }
42723 arg6 = static_cast< wxItemKind >(val6);
42724 }
42725 {
42726 PyThreadState* __tstate = wxPyBeginAllowThreads();
42727 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42728 wxPyEndAllowThreads(__tstate);
42729 if (PyErr_Occurred()) SWIG_fail;
42730 }
42731 {
42732 resultobj = wxPyMake_wxObject(result, (bool)0);
42733 }
42734 {
42735 if (temp4)
42736 delete arg4;
42737 }
42738 {
42739 if (temp5)
42740 delete arg5;
42741 }
42742 return resultobj;
42743 fail:
42744 {
42745 if (temp4)
42746 delete arg4;
42747 }
42748 {
42749 if (temp5)
42750 delete arg5;
42751 }
42752 return NULL;
42753 }
42754
42755
42756 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42757 PyObject *resultobj = 0;
42758 wxMenu *arg1 = (wxMenu *) 0 ;
42759 size_t arg2 ;
42760 wxMenuItem *result = 0 ;
42761 void *argp1 = 0 ;
42762 int res1 = 0 ;
42763 size_t val2 ;
42764 int ecode2 = 0 ;
42765 PyObject * obj0 = 0 ;
42766 PyObject * obj1 = 0 ;
42767 char * kwnames[] = {
42768 (char *) "self",(char *) "pos", NULL
42769 };
42770
42771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42773 if (!SWIG_IsOK(res1)) {
42774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42775 }
42776 arg1 = reinterpret_cast< wxMenu * >(argp1);
42777 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42778 if (!SWIG_IsOK(ecode2)) {
42779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42780 }
42781 arg2 = static_cast< size_t >(val2);
42782 {
42783 PyThreadState* __tstate = wxPyBeginAllowThreads();
42784 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42785 wxPyEndAllowThreads(__tstate);
42786 if (PyErr_Occurred()) SWIG_fail;
42787 }
42788 {
42789 resultobj = wxPyMake_wxObject(result, (bool)0);
42790 }
42791 return resultobj;
42792 fail:
42793 return NULL;
42794 }
42795
42796
42797 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42798 PyObject *resultobj = 0;
42799 wxMenu *arg1 = (wxMenu *) 0 ;
42800 size_t arg2 ;
42801 int arg3 ;
42802 wxString *arg4 = 0 ;
42803 wxString const &arg5_defvalue = wxPyEmptyString ;
42804 wxString *arg5 = (wxString *) &arg5_defvalue ;
42805 wxMenuItem *result = 0 ;
42806 void *argp1 = 0 ;
42807 int res1 = 0 ;
42808 size_t val2 ;
42809 int ecode2 = 0 ;
42810 int val3 ;
42811 int ecode3 = 0 ;
42812 bool temp4 = false ;
42813 bool temp5 = false ;
42814 PyObject * obj0 = 0 ;
42815 PyObject * obj1 = 0 ;
42816 PyObject * obj2 = 0 ;
42817 PyObject * obj3 = 0 ;
42818 PyObject * obj4 = 0 ;
42819 char * kwnames[] = {
42820 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42821 };
42822
42823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42825 if (!SWIG_IsOK(res1)) {
42826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42827 }
42828 arg1 = reinterpret_cast< wxMenu * >(argp1);
42829 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42830 if (!SWIG_IsOK(ecode2)) {
42831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42832 }
42833 arg2 = static_cast< size_t >(val2);
42834 ecode3 = SWIG_AsVal_int(obj2, &val3);
42835 if (!SWIG_IsOK(ecode3)) {
42836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42837 }
42838 arg3 = static_cast< int >(val3);
42839 {
42840 arg4 = wxString_in_helper(obj3);
42841 if (arg4 == NULL) SWIG_fail;
42842 temp4 = true;
42843 }
42844 if (obj4) {
42845 {
42846 arg5 = wxString_in_helper(obj4);
42847 if (arg5 == NULL) SWIG_fail;
42848 temp5 = true;
42849 }
42850 }
42851 {
42852 PyThreadState* __tstate = wxPyBeginAllowThreads();
42853 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42854 wxPyEndAllowThreads(__tstate);
42855 if (PyErr_Occurred()) SWIG_fail;
42856 }
42857 {
42858 resultobj = wxPyMake_wxObject(result, (bool)0);
42859 }
42860 {
42861 if (temp4)
42862 delete arg4;
42863 }
42864 {
42865 if (temp5)
42866 delete arg5;
42867 }
42868 return resultobj;
42869 fail:
42870 {
42871 if (temp4)
42872 delete arg4;
42873 }
42874 {
42875 if (temp5)
42876 delete arg5;
42877 }
42878 return NULL;
42879 }
42880
42881
42882 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42883 PyObject *resultobj = 0;
42884 wxMenu *arg1 = (wxMenu *) 0 ;
42885 size_t arg2 ;
42886 int arg3 ;
42887 wxString *arg4 = 0 ;
42888 wxString const &arg5_defvalue = wxPyEmptyString ;
42889 wxString *arg5 = (wxString *) &arg5_defvalue ;
42890 wxMenuItem *result = 0 ;
42891 void *argp1 = 0 ;
42892 int res1 = 0 ;
42893 size_t val2 ;
42894 int ecode2 = 0 ;
42895 int val3 ;
42896 int ecode3 = 0 ;
42897 bool temp4 = false ;
42898 bool temp5 = false ;
42899 PyObject * obj0 = 0 ;
42900 PyObject * obj1 = 0 ;
42901 PyObject * obj2 = 0 ;
42902 PyObject * obj3 = 0 ;
42903 PyObject * obj4 = 0 ;
42904 char * kwnames[] = {
42905 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42906 };
42907
42908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42910 if (!SWIG_IsOK(res1)) {
42911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42912 }
42913 arg1 = reinterpret_cast< wxMenu * >(argp1);
42914 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42915 if (!SWIG_IsOK(ecode2)) {
42916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42917 }
42918 arg2 = static_cast< size_t >(val2);
42919 ecode3 = SWIG_AsVal_int(obj2, &val3);
42920 if (!SWIG_IsOK(ecode3)) {
42921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42922 }
42923 arg3 = static_cast< int >(val3);
42924 {
42925 arg4 = wxString_in_helper(obj3);
42926 if (arg4 == NULL) SWIG_fail;
42927 temp4 = true;
42928 }
42929 if (obj4) {
42930 {
42931 arg5 = wxString_in_helper(obj4);
42932 if (arg5 == NULL) SWIG_fail;
42933 temp5 = true;
42934 }
42935 }
42936 {
42937 PyThreadState* __tstate = wxPyBeginAllowThreads();
42938 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42939 wxPyEndAllowThreads(__tstate);
42940 if (PyErr_Occurred()) SWIG_fail;
42941 }
42942 {
42943 resultobj = wxPyMake_wxObject(result, (bool)0);
42944 }
42945 {
42946 if (temp4)
42947 delete arg4;
42948 }
42949 {
42950 if (temp5)
42951 delete arg5;
42952 }
42953 return resultobj;
42954 fail:
42955 {
42956 if (temp4)
42957 delete arg4;
42958 }
42959 {
42960 if (temp5)
42961 delete arg5;
42962 }
42963 return NULL;
42964 }
42965
42966
42967 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42968 PyObject *resultobj = 0;
42969 wxMenu *arg1 = (wxMenu *) 0 ;
42970 size_t arg2 ;
42971 int arg3 ;
42972 wxString *arg4 = 0 ;
42973 wxMenu *arg5 = (wxMenu *) 0 ;
42974 wxString const &arg6_defvalue = wxPyEmptyString ;
42975 wxString *arg6 = (wxString *) &arg6_defvalue ;
42976 wxMenuItem *result = 0 ;
42977 void *argp1 = 0 ;
42978 int res1 = 0 ;
42979 size_t val2 ;
42980 int ecode2 = 0 ;
42981 int val3 ;
42982 int ecode3 = 0 ;
42983 bool temp4 = false ;
42984 void *argp5 = 0 ;
42985 int res5 = 0 ;
42986 bool temp6 = false ;
42987 PyObject * obj0 = 0 ;
42988 PyObject * obj1 = 0 ;
42989 PyObject * obj2 = 0 ;
42990 PyObject * obj3 = 0 ;
42991 PyObject * obj4 = 0 ;
42992 PyObject * obj5 = 0 ;
42993 char * kwnames[] = {
42994 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42995 };
42996
42997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42999 if (!SWIG_IsOK(res1)) {
43000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43001 }
43002 arg1 = reinterpret_cast< wxMenu * >(argp1);
43003 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43004 if (!SWIG_IsOK(ecode2)) {
43005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
43006 }
43007 arg2 = static_cast< size_t >(val2);
43008 ecode3 = SWIG_AsVal_int(obj2, &val3);
43009 if (!SWIG_IsOK(ecode3)) {
43010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
43011 }
43012 arg3 = static_cast< int >(val3);
43013 {
43014 arg4 = wxString_in_helper(obj3);
43015 if (arg4 == NULL) SWIG_fail;
43016 temp4 = true;
43017 }
43018 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
43019 if (!SWIG_IsOK(res5)) {
43020 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
43021 }
43022 arg5 = reinterpret_cast< wxMenu * >(argp5);
43023 if (obj5) {
43024 {
43025 arg6 = wxString_in_helper(obj5);
43026 if (arg6 == NULL) SWIG_fail;
43027 temp6 = true;
43028 }
43029 }
43030 {
43031 PyThreadState* __tstate = wxPyBeginAllowThreads();
43032 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
43033 wxPyEndAllowThreads(__tstate);
43034 if (PyErr_Occurred()) SWIG_fail;
43035 }
43036 {
43037 resultobj = wxPyMake_wxObject(result, (bool)0);
43038 }
43039 {
43040 if (temp4)
43041 delete arg4;
43042 }
43043 {
43044 if (temp6)
43045 delete arg6;
43046 }
43047 return resultobj;
43048 fail:
43049 {
43050 if (temp4)
43051 delete arg4;
43052 }
43053 {
43054 if (temp6)
43055 delete arg6;
43056 }
43057 return NULL;
43058 }
43059
43060
43061 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43062 PyObject *resultobj = 0;
43063 wxMenu *arg1 = (wxMenu *) 0 ;
43064 int arg2 ;
43065 wxString const &arg3_defvalue = wxPyEmptyString ;
43066 wxString *arg3 = (wxString *) &arg3_defvalue ;
43067 wxString const &arg4_defvalue = wxPyEmptyString ;
43068 wxString *arg4 = (wxString *) &arg4_defvalue ;
43069 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43070 wxMenuItem *result = 0 ;
43071 void *argp1 = 0 ;
43072 int res1 = 0 ;
43073 int val2 ;
43074 int ecode2 = 0 ;
43075 bool temp3 = false ;
43076 bool temp4 = false ;
43077 int val5 ;
43078 int ecode5 = 0 ;
43079 PyObject * obj0 = 0 ;
43080 PyObject * obj1 = 0 ;
43081 PyObject * obj2 = 0 ;
43082 PyObject * obj3 = 0 ;
43083 PyObject * obj4 = 0 ;
43084 char * kwnames[] = {
43085 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
43086 };
43087
43088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43090 if (!SWIG_IsOK(res1)) {
43091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
43092 }
43093 arg1 = reinterpret_cast< wxMenu * >(argp1);
43094 ecode2 = SWIG_AsVal_int(obj1, &val2);
43095 if (!SWIG_IsOK(ecode2)) {
43096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
43097 }
43098 arg2 = static_cast< int >(val2);
43099 if (obj2) {
43100 {
43101 arg3 = wxString_in_helper(obj2);
43102 if (arg3 == NULL) SWIG_fail;
43103 temp3 = true;
43104 }
43105 }
43106 if (obj3) {
43107 {
43108 arg4 = wxString_in_helper(obj3);
43109 if (arg4 == NULL) SWIG_fail;
43110 temp4 = true;
43111 }
43112 }
43113 if (obj4) {
43114 ecode5 = SWIG_AsVal_int(obj4, &val5);
43115 if (!SWIG_IsOK(ecode5)) {
43116 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
43117 }
43118 arg5 = static_cast< wxItemKind >(val5);
43119 }
43120 {
43121 PyThreadState* __tstate = wxPyBeginAllowThreads();
43122 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
43123 wxPyEndAllowThreads(__tstate);
43124 if (PyErr_Occurred()) SWIG_fail;
43125 }
43126 {
43127 resultobj = wxPyMake_wxObject(result, (bool)0);
43128 }
43129 {
43130 if (temp3)
43131 delete arg3;
43132 }
43133 {
43134 if (temp4)
43135 delete arg4;
43136 }
43137 return resultobj;
43138 fail:
43139 {
43140 if (temp3)
43141 delete arg3;
43142 }
43143 {
43144 if (temp4)
43145 delete arg4;
43146 }
43147 return NULL;
43148 }
43149
43150
43151 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43152 PyObject *resultobj = 0;
43153 wxMenu *arg1 = (wxMenu *) 0 ;
43154 wxMenuItem *result = 0 ;
43155 void *argp1 = 0 ;
43156 int res1 = 0 ;
43157 PyObject *swig_obj[1] ;
43158
43159 if (!args) SWIG_fail;
43160 swig_obj[0] = args;
43161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43162 if (!SWIG_IsOK(res1)) {
43163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
43164 }
43165 arg1 = reinterpret_cast< wxMenu * >(argp1);
43166 {
43167 PyThreadState* __tstate = wxPyBeginAllowThreads();
43168 result = (wxMenuItem *)(arg1)->PrependSeparator();
43169 wxPyEndAllowThreads(__tstate);
43170 if (PyErr_Occurred()) SWIG_fail;
43171 }
43172 {
43173 resultobj = wxPyMake_wxObject(result, (bool)0);
43174 }
43175 return resultobj;
43176 fail:
43177 return NULL;
43178 }
43179
43180
43181 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43182 PyObject *resultobj = 0;
43183 wxMenu *arg1 = (wxMenu *) 0 ;
43184 int arg2 ;
43185 wxString *arg3 = 0 ;
43186 wxString const &arg4_defvalue = wxPyEmptyString ;
43187 wxString *arg4 = (wxString *) &arg4_defvalue ;
43188 wxMenuItem *result = 0 ;
43189 void *argp1 = 0 ;
43190 int res1 = 0 ;
43191 int val2 ;
43192 int ecode2 = 0 ;
43193 bool temp3 = false ;
43194 bool temp4 = false ;
43195 PyObject * obj0 = 0 ;
43196 PyObject * obj1 = 0 ;
43197 PyObject * obj2 = 0 ;
43198 PyObject * obj3 = 0 ;
43199 char * kwnames[] = {
43200 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43201 };
43202
43203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43205 if (!SWIG_IsOK(res1)) {
43206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43207 }
43208 arg1 = reinterpret_cast< wxMenu * >(argp1);
43209 ecode2 = SWIG_AsVal_int(obj1, &val2);
43210 if (!SWIG_IsOK(ecode2)) {
43211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
43212 }
43213 arg2 = static_cast< int >(val2);
43214 {
43215 arg3 = wxString_in_helper(obj2);
43216 if (arg3 == NULL) SWIG_fail;
43217 temp3 = true;
43218 }
43219 if (obj3) {
43220 {
43221 arg4 = wxString_in_helper(obj3);
43222 if (arg4 == NULL) SWIG_fail;
43223 temp4 = true;
43224 }
43225 }
43226 {
43227 PyThreadState* __tstate = wxPyBeginAllowThreads();
43228 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43229 wxPyEndAllowThreads(__tstate);
43230 if (PyErr_Occurred()) SWIG_fail;
43231 }
43232 {
43233 resultobj = wxPyMake_wxObject(result, (bool)0);
43234 }
43235 {
43236 if (temp3)
43237 delete arg3;
43238 }
43239 {
43240 if (temp4)
43241 delete arg4;
43242 }
43243 return resultobj;
43244 fail:
43245 {
43246 if (temp3)
43247 delete arg3;
43248 }
43249 {
43250 if (temp4)
43251 delete arg4;
43252 }
43253 return NULL;
43254 }
43255
43256
43257 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43258 PyObject *resultobj = 0;
43259 wxMenu *arg1 = (wxMenu *) 0 ;
43260 int arg2 ;
43261 wxString *arg3 = 0 ;
43262 wxString const &arg4_defvalue = wxPyEmptyString ;
43263 wxString *arg4 = (wxString *) &arg4_defvalue ;
43264 wxMenuItem *result = 0 ;
43265 void *argp1 = 0 ;
43266 int res1 = 0 ;
43267 int val2 ;
43268 int ecode2 = 0 ;
43269 bool temp3 = false ;
43270 bool temp4 = false ;
43271 PyObject * obj0 = 0 ;
43272 PyObject * obj1 = 0 ;
43273 PyObject * obj2 = 0 ;
43274 PyObject * obj3 = 0 ;
43275 char * kwnames[] = {
43276 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43277 };
43278
43279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43281 if (!SWIG_IsOK(res1)) {
43282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43283 }
43284 arg1 = reinterpret_cast< wxMenu * >(argp1);
43285 ecode2 = SWIG_AsVal_int(obj1, &val2);
43286 if (!SWIG_IsOK(ecode2)) {
43287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
43288 }
43289 arg2 = static_cast< int >(val2);
43290 {
43291 arg3 = wxString_in_helper(obj2);
43292 if (arg3 == NULL) SWIG_fail;
43293 temp3 = true;
43294 }
43295 if (obj3) {
43296 {
43297 arg4 = wxString_in_helper(obj3);
43298 if (arg4 == NULL) SWIG_fail;
43299 temp4 = true;
43300 }
43301 }
43302 {
43303 PyThreadState* __tstate = wxPyBeginAllowThreads();
43304 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43305 wxPyEndAllowThreads(__tstate);
43306 if (PyErr_Occurred()) SWIG_fail;
43307 }
43308 {
43309 resultobj = wxPyMake_wxObject(result, (bool)0);
43310 }
43311 {
43312 if (temp3)
43313 delete arg3;
43314 }
43315 {
43316 if (temp4)
43317 delete arg4;
43318 }
43319 return resultobj;
43320 fail:
43321 {
43322 if (temp3)
43323 delete arg3;
43324 }
43325 {
43326 if (temp4)
43327 delete arg4;
43328 }
43329 return NULL;
43330 }
43331
43332
43333 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43334 PyObject *resultobj = 0;
43335 wxMenu *arg1 = (wxMenu *) 0 ;
43336 int arg2 ;
43337 wxString *arg3 = 0 ;
43338 wxMenu *arg4 = (wxMenu *) 0 ;
43339 wxString const &arg5_defvalue = wxPyEmptyString ;
43340 wxString *arg5 = (wxString *) &arg5_defvalue ;
43341 wxMenuItem *result = 0 ;
43342 void *argp1 = 0 ;
43343 int res1 = 0 ;
43344 int val2 ;
43345 int ecode2 = 0 ;
43346 bool temp3 = false ;
43347 void *argp4 = 0 ;
43348 int res4 = 0 ;
43349 bool temp5 = false ;
43350 PyObject * obj0 = 0 ;
43351 PyObject * obj1 = 0 ;
43352 PyObject * obj2 = 0 ;
43353 PyObject * obj3 = 0 ;
43354 PyObject * obj4 = 0 ;
43355 char * kwnames[] = {
43356 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43357 };
43358
43359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43361 if (!SWIG_IsOK(res1)) {
43362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43363 }
43364 arg1 = reinterpret_cast< wxMenu * >(argp1);
43365 ecode2 = SWIG_AsVal_int(obj1, &val2);
43366 if (!SWIG_IsOK(ecode2)) {
43367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43368 }
43369 arg2 = static_cast< int >(val2);
43370 {
43371 arg3 = wxString_in_helper(obj2);
43372 if (arg3 == NULL) SWIG_fail;
43373 temp3 = true;
43374 }
43375 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43376 if (!SWIG_IsOK(res4)) {
43377 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43378 }
43379 arg4 = reinterpret_cast< wxMenu * >(argp4);
43380 if (obj4) {
43381 {
43382 arg5 = wxString_in_helper(obj4);
43383 if (arg5 == NULL) SWIG_fail;
43384 temp5 = true;
43385 }
43386 }
43387 {
43388 PyThreadState* __tstate = wxPyBeginAllowThreads();
43389 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43390 wxPyEndAllowThreads(__tstate);
43391 if (PyErr_Occurred()) SWIG_fail;
43392 }
43393 {
43394 resultobj = wxPyMake_wxObject(result, (bool)0);
43395 }
43396 {
43397 if (temp3)
43398 delete arg3;
43399 }
43400 {
43401 if (temp5)
43402 delete arg5;
43403 }
43404 return resultobj;
43405 fail:
43406 {
43407 if (temp3)
43408 delete arg3;
43409 }
43410 {
43411 if (temp5)
43412 delete arg5;
43413 }
43414 return NULL;
43415 }
43416
43417
43418 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43419 PyObject *resultobj = 0;
43420 wxMenu *arg1 = (wxMenu *) 0 ;
43421 int arg2 ;
43422 wxMenuItem *result = 0 ;
43423 void *argp1 = 0 ;
43424 int res1 = 0 ;
43425 int val2 ;
43426 int ecode2 = 0 ;
43427 PyObject * obj0 = 0 ;
43428 PyObject * obj1 = 0 ;
43429 char * kwnames[] = {
43430 (char *) "self",(char *) "id", NULL
43431 };
43432
43433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43435 if (!SWIG_IsOK(res1)) {
43436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43437 }
43438 arg1 = reinterpret_cast< wxMenu * >(argp1);
43439 ecode2 = SWIG_AsVal_int(obj1, &val2);
43440 if (!SWIG_IsOK(ecode2)) {
43441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43442 }
43443 arg2 = static_cast< int >(val2);
43444 {
43445 PyThreadState* __tstate = wxPyBeginAllowThreads();
43446 result = (wxMenuItem *)(arg1)->Remove(arg2);
43447 wxPyEndAllowThreads(__tstate);
43448 if (PyErr_Occurred()) SWIG_fail;
43449 }
43450 {
43451 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43452 }
43453 return resultobj;
43454 fail:
43455 return NULL;
43456 }
43457
43458
43459 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43460 PyObject *resultobj = 0;
43461 wxMenu *arg1 = (wxMenu *) 0 ;
43462 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43463 wxMenuItem *result = 0 ;
43464 void *argp1 = 0 ;
43465 int res1 = 0 ;
43466 void *argp2 = 0 ;
43467 int res2 = 0 ;
43468 PyObject * obj0 = 0 ;
43469 PyObject * obj1 = 0 ;
43470 char * kwnames[] = {
43471 (char *) "self",(char *) "item", NULL
43472 };
43473
43474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43476 if (!SWIG_IsOK(res1)) {
43477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43478 }
43479 arg1 = reinterpret_cast< wxMenu * >(argp1);
43480 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43481 if (!SWIG_IsOK(res2)) {
43482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43483 }
43484 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43485 {
43486 PyThreadState* __tstate = wxPyBeginAllowThreads();
43487 result = (wxMenuItem *)(arg1)->Remove(arg2);
43488 wxPyEndAllowThreads(__tstate);
43489 if (PyErr_Occurred()) SWIG_fail;
43490 }
43491 {
43492 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43493 }
43494 return resultobj;
43495 fail:
43496 return NULL;
43497 }
43498
43499
43500 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43501 PyObject *resultobj = 0;
43502 wxMenu *arg1 = (wxMenu *) 0 ;
43503 int arg2 ;
43504 bool result;
43505 void *argp1 = 0 ;
43506 int res1 = 0 ;
43507 int val2 ;
43508 int ecode2 = 0 ;
43509 PyObject * obj0 = 0 ;
43510 PyObject * obj1 = 0 ;
43511 char * kwnames[] = {
43512 (char *) "self",(char *) "id", NULL
43513 };
43514
43515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43517 if (!SWIG_IsOK(res1)) {
43518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43519 }
43520 arg1 = reinterpret_cast< wxMenu * >(argp1);
43521 ecode2 = SWIG_AsVal_int(obj1, &val2);
43522 if (!SWIG_IsOK(ecode2)) {
43523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43524 }
43525 arg2 = static_cast< int >(val2);
43526 {
43527 PyThreadState* __tstate = wxPyBeginAllowThreads();
43528 result = (bool)(arg1)->Delete(arg2);
43529 wxPyEndAllowThreads(__tstate);
43530 if (PyErr_Occurred()) SWIG_fail;
43531 }
43532 {
43533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43534 }
43535 return resultobj;
43536 fail:
43537 return NULL;
43538 }
43539
43540
43541 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43542 PyObject *resultobj = 0;
43543 wxMenu *arg1 = (wxMenu *) 0 ;
43544 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43545 bool result;
43546 void *argp1 = 0 ;
43547 int res1 = 0 ;
43548 void *argp2 = 0 ;
43549 int res2 = 0 ;
43550 PyObject * obj0 = 0 ;
43551 PyObject * obj1 = 0 ;
43552 char * kwnames[] = {
43553 (char *) "self",(char *) "item", NULL
43554 };
43555
43556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43558 if (!SWIG_IsOK(res1)) {
43559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43560 }
43561 arg1 = reinterpret_cast< wxMenu * >(argp1);
43562 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43563 if (!SWIG_IsOK(res2)) {
43564 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43565 }
43566 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43567 {
43568 PyThreadState* __tstate = wxPyBeginAllowThreads();
43569 result = (bool)(arg1)->Delete(arg2);
43570 wxPyEndAllowThreads(__tstate);
43571 if (PyErr_Occurred()) SWIG_fail;
43572 }
43573 {
43574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43575 }
43576 return resultobj;
43577 fail:
43578 return NULL;
43579 }
43580
43581
43582 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43583 PyObject *resultobj = 0;
43584 wxMenu *arg1 = (wxMenu *) 0 ;
43585 void *argp1 = 0 ;
43586 int res1 = 0 ;
43587 PyObject *swig_obj[1] ;
43588
43589 if (!args) SWIG_fail;
43590 swig_obj[0] = args;
43591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43592 if (!SWIG_IsOK(res1)) {
43593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43594 }
43595 arg1 = reinterpret_cast< wxMenu * >(argp1);
43596 {
43597 PyThreadState* __tstate = wxPyBeginAllowThreads();
43598 wxMenu_Destroy(arg1);
43599 wxPyEndAllowThreads(__tstate);
43600 if (PyErr_Occurred()) SWIG_fail;
43601 }
43602 resultobj = SWIG_Py_Void();
43603 return resultobj;
43604 fail:
43605 return NULL;
43606 }
43607
43608
43609 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43610 PyObject *resultobj = 0;
43611 wxMenu *arg1 = (wxMenu *) 0 ;
43612 int arg2 ;
43613 bool result;
43614 void *argp1 = 0 ;
43615 int res1 = 0 ;
43616 int val2 ;
43617 int ecode2 = 0 ;
43618 PyObject * obj0 = 0 ;
43619 PyObject * obj1 = 0 ;
43620 char * kwnames[] = {
43621 (char *) "self",(char *) "id", NULL
43622 };
43623
43624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43626 if (!SWIG_IsOK(res1)) {
43627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43628 }
43629 arg1 = reinterpret_cast< wxMenu * >(argp1);
43630 ecode2 = SWIG_AsVal_int(obj1, &val2);
43631 if (!SWIG_IsOK(ecode2)) {
43632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43633 }
43634 arg2 = static_cast< int >(val2);
43635 {
43636 PyThreadState* __tstate = wxPyBeginAllowThreads();
43637 result = (bool)(arg1)->Destroy(arg2);
43638 wxPyEndAllowThreads(__tstate);
43639 if (PyErr_Occurred()) SWIG_fail;
43640 }
43641 {
43642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43643 }
43644 return resultobj;
43645 fail:
43646 return NULL;
43647 }
43648
43649
43650 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43651 PyObject *resultobj = 0;
43652 wxMenu *arg1 = (wxMenu *) 0 ;
43653 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43654 bool result;
43655 void *argp1 = 0 ;
43656 int res1 = 0 ;
43657 void *argp2 = 0 ;
43658 int res2 = 0 ;
43659 PyObject * obj0 = 0 ;
43660 PyObject * obj1 = 0 ;
43661 char * kwnames[] = {
43662 (char *) "self",(char *) "item", NULL
43663 };
43664
43665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43667 if (!SWIG_IsOK(res1)) {
43668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43669 }
43670 arg1 = reinterpret_cast< wxMenu * >(argp1);
43671 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43672 if (!SWIG_IsOK(res2)) {
43673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43674 }
43675 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43676 {
43677 PyThreadState* __tstate = wxPyBeginAllowThreads();
43678 result = (bool)(arg1)->Destroy(arg2);
43679 wxPyEndAllowThreads(__tstate);
43680 if (PyErr_Occurred()) SWIG_fail;
43681 }
43682 {
43683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43684 }
43685 return resultobj;
43686 fail:
43687 return NULL;
43688 }
43689
43690
43691 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43692 PyObject *resultobj = 0;
43693 wxMenu *arg1 = (wxMenu *) 0 ;
43694 size_t result;
43695 void *argp1 = 0 ;
43696 int res1 = 0 ;
43697 PyObject *swig_obj[1] ;
43698
43699 if (!args) SWIG_fail;
43700 swig_obj[0] = args;
43701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43702 if (!SWIG_IsOK(res1)) {
43703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43704 }
43705 arg1 = reinterpret_cast< wxMenu * >(argp1);
43706 {
43707 PyThreadState* __tstate = wxPyBeginAllowThreads();
43708 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43709 wxPyEndAllowThreads(__tstate);
43710 if (PyErr_Occurred()) SWIG_fail;
43711 }
43712 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43713 return resultobj;
43714 fail:
43715 return NULL;
43716 }
43717
43718
43719 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43720 PyObject *resultobj = 0;
43721 wxMenu *arg1 = (wxMenu *) 0 ;
43722 PyObject *result = 0 ;
43723 void *argp1 = 0 ;
43724 int res1 = 0 ;
43725 PyObject *swig_obj[1] ;
43726
43727 if (!args) SWIG_fail;
43728 swig_obj[0] = args;
43729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43730 if (!SWIG_IsOK(res1)) {
43731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43732 }
43733 arg1 = reinterpret_cast< wxMenu * >(argp1);
43734 {
43735 PyThreadState* __tstate = wxPyBeginAllowThreads();
43736 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43737 wxPyEndAllowThreads(__tstate);
43738 if (PyErr_Occurred()) SWIG_fail;
43739 }
43740 resultobj = result;
43741 return resultobj;
43742 fail:
43743 return NULL;
43744 }
43745
43746
43747 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43748 PyObject *resultobj = 0;
43749 wxMenu *arg1 = (wxMenu *) 0 ;
43750 wxString *arg2 = 0 ;
43751 int result;
43752 void *argp1 = 0 ;
43753 int res1 = 0 ;
43754 bool temp2 = false ;
43755 PyObject * obj0 = 0 ;
43756 PyObject * obj1 = 0 ;
43757 char * kwnames[] = {
43758 (char *) "self",(char *) "item", NULL
43759 };
43760
43761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43763 if (!SWIG_IsOK(res1)) {
43764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43765 }
43766 arg1 = reinterpret_cast< wxMenu * >(argp1);
43767 {
43768 arg2 = wxString_in_helper(obj1);
43769 if (arg2 == NULL) SWIG_fail;
43770 temp2 = true;
43771 }
43772 {
43773 PyThreadState* __tstate = wxPyBeginAllowThreads();
43774 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43775 wxPyEndAllowThreads(__tstate);
43776 if (PyErr_Occurred()) SWIG_fail;
43777 }
43778 resultobj = SWIG_From_int(static_cast< int >(result));
43779 {
43780 if (temp2)
43781 delete arg2;
43782 }
43783 return resultobj;
43784 fail:
43785 {
43786 if (temp2)
43787 delete arg2;
43788 }
43789 return NULL;
43790 }
43791
43792
43793 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43794 PyObject *resultobj = 0;
43795 wxMenu *arg1 = (wxMenu *) 0 ;
43796 int arg2 ;
43797 wxMenuItem *result = 0 ;
43798 void *argp1 = 0 ;
43799 int res1 = 0 ;
43800 int val2 ;
43801 int ecode2 = 0 ;
43802 PyObject * obj0 = 0 ;
43803 PyObject * obj1 = 0 ;
43804 char * kwnames[] = {
43805 (char *) "self",(char *) "id", NULL
43806 };
43807
43808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43810 if (!SWIG_IsOK(res1)) {
43811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43812 }
43813 arg1 = reinterpret_cast< wxMenu * >(argp1);
43814 ecode2 = SWIG_AsVal_int(obj1, &val2);
43815 if (!SWIG_IsOK(ecode2)) {
43816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43817 }
43818 arg2 = static_cast< int >(val2);
43819 {
43820 PyThreadState* __tstate = wxPyBeginAllowThreads();
43821 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43822 wxPyEndAllowThreads(__tstate);
43823 if (PyErr_Occurred()) SWIG_fail;
43824 }
43825 {
43826 resultobj = wxPyMake_wxObject(result, (bool)0);
43827 }
43828 return resultobj;
43829 fail:
43830 return NULL;
43831 }
43832
43833
43834 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43835 PyObject *resultobj = 0;
43836 wxMenu *arg1 = (wxMenu *) 0 ;
43837 size_t arg2 ;
43838 wxMenuItem *result = 0 ;
43839 void *argp1 = 0 ;
43840 int res1 = 0 ;
43841 size_t val2 ;
43842 int ecode2 = 0 ;
43843 PyObject * obj0 = 0 ;
43844 PyObject * obj1 = 0 ;
43845 char * kwnames[] = {
43846 (char *) "self",(char *) "position", NULL
43847 };
43848
43849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43851 if (!SWIG_IsOK(res1)) {
43852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43853 }
43854 arg1 = reinterpret_cast< wxMenu * >(argp1);
43855 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43856 if (!SWIG_IsOK(ecode2)) {
43857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43858 }
43859 arg2 = static_cast< size_t >(val2);
43860 {
43861 PyThreadState* __tstate = wxPyBeginAllowThreads();
43862 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43863 wxPyEndAllowThreads(__tstate);
43864 if (PyErr_Occurred()) SWIG_fail;
43865 }
43866 {
43867 resultobj = wxPyMake_wxObject(result, (bool)0);
43868 }
43869 return resultobj;
43870 fail:
43871 return NULL;
43872 }
43873
43874
43875 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43876 PyObject *resultobj = 0;
43877 wxMenu *arg1 = (wxMenu *) 0 ;
43878 int arg2 ;
43879 bool arg3 ;
43880 void *argp1 = 0 ;
43881 int res1 = 0 ;
43882 int val2 ;
43883 int ecode2 = 0 ;
43884 bool val3 ;
43885 int ecode3 = 0 ;
43886 PyObject * obj0 = 0 ;
43887 PyObject * obj1 = 0 ;
43888 PyObject * obj2 = 0 ;
43889 char * kwnames[] = {
43890 (char *) "self",(char *) "id",(char *) "enable", NULL
43891 };
43892
43893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43895 if (!SWIG_IsOK(res1)) {
43896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43897 }
43898 arg1 = reinterpret_cast< wxMenu * >(argp1);
43899 ecode2 = SWIG_AsVal_int(obj1, &val2);
43900 if (!SWIG_IsOK(ecode2)) {
43901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43902 }
43903 arg2 = static_cast< int >(val2);
43904 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43905 if (!SWIG_IsOK(ecode3)) {
43906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43907 }
43908 arg3 = static_cast< bool >(val3);
43909 {
43910 PyThreadState* __tstate = wxPyBeginAllowThreads();
43911 (arg1)->Enable(arg2,arg3);
43912 wxPyEndAllowThreads(__tstate);
43913 if (PyErr_Occurred()) SWIG_fail;
43914 }
43915 resultobj = SWIG_Py_Void();
43916 return resultobj;
43917 fail:
43918 return NULL;
43919 }
43920
43921
43922 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43923 PyObject *resultobj = 0;
43924 wxMenu *arg1 = (wxMenu *) 0 ;
43925 int arg2 ;
43926 bool result;
43927 void *argp1 = 0 ;
43928 int res1 = 0 ;
43929 int val2 ;
43930 int ecode2 = 0 ;
43931 PyObject * obj0 = 0 ;
43932 PyObject * obj1 = 0 ;
43933 char * kwnames[] = {
43934 (char *) "self",(char *) "id", NULL
43935 };
43936
43937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43939 if (!SWIG_IsOK(res1)) {
43940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43941 }
43942 arg1 = reinterpret_cast< wxMenu * >(argp1);
43943 ecode2 = SWIG_AsVal_int(obj1, &val2);
43944 if (!SWIG_IsOK(ecode2)) {
43945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43946 }
43947 arg2 = static_cast< int >(val2);
43948 {
43949 PyThreadState* __tstate = wxPyBeginAllowThreads();
43950 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43951 wxPyEndAllowThreads(__tstate);
43952 if (PyErr_Occurred()) SWIG_fail;
43953 }
43954 {
43955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43956 }
43957 return resultobj;
43958 fail:
43959 return NULL;
43960 }
43961
43962
43963 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43964 PyObject *resultobj = 0;
43965 wxMenu *arg1 = (wxMenu *) 0 ;
43966 int arg2 ;
43967 bool arg3 ;
43968 void *argp1 = 0 ;
43969 int res1 = 0 ;
43970 int val2 ;
43971 int ecode2 = 0 ;
43972 bool val3 ;
43973 int ecode3 = 0 ;
43974 PyObject * obj0 = 0 ;
43975 PyObject * obj1 = 0 ;
43976 PyObject * obj2 = 0 ;
43977 char * kwnames[] = {
43978 (char *) "self",(char *) "id",(char *) "check", NULL
43979 };
43980
43981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43983 if (!SWIG_IsOK(res1)) {
43984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43985 }
43986 arg1 = reinterpret_cast< wxMenu * >(argp1);
43987 ecode2 = SWIG_AsVal_int(obj1, &val2);
43988 if (!SWIG_IsOK(ecode2)) {
43989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43990 }
43991 arg2 = static_cast< int >(val2);
43992 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43993 if (!SWIG_IsOK(ecode3)) {
43994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43995 }
43996 arg3 = static_cast< bool >(val3);
43997 {
43998 PyThreadState* __tstate = wxPyBeginAllowThreads();
43999 (arg1)->Check(arg2,arg3);
44000 wxPyEndAllowThreads(__tstate);
44001 if (PyErr_Occurred()) SWIG_fail;
44002 }
44003 resultobj = SWIG_Py_Void();
44004 return resultobj;
44005 fail:
44006 return NULL;
44007 }
44008
44009
44010 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44011 PyObject *resultobj = 0;
44012 wxMenu *arg1 = (wxMenu *) 0 ;
44013 int arg2 ;
44014 bool result;
44015 void *argp1 = 0 ;
44016 int res1 = 0 ;
44017 int val2 ;
44018 int ecode2 = 0 ;
44019 PyObject * obj0 = 0 ;
44020 PyObject * obj1 = 0 ;
44021 char * kwnames[] = {
44022 (char *) "self",(char *) "id", NULL
44023 };
44024
44025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
44026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44027 if (!SWIG_IsOK(res1)) {
44028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
44029 }
44030 arg1 = reinterpret_cast< wxMenu * >(argp1);
44031 ecode2 = SWIG_AsVal_int(obj1, &val2);
44032 if (!SWIG_IsOK(ecode2)) {
44033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
44034 }
44035 arg2 = static_cast< int >(val2);
44036 {
44037 PyThreadState* __tstate = wxPyBeginAllowThreads();
44038 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
44039 wxPyEndAllowThreads(__tstate);
44040 if (PyErr_Occurred()) SWIG_fail;
44041 }
44042 {
44043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44044 }
44045 return resultobj;
44046 fail:
44047 return NULL;
44048 }
44049
44050
44051 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44052 PyObject *resultobj = 0;
44053 wxMenu *arg1 = (wxMenu *) 0 ;
44054 int arg2 ;
44055 wxString *arg3 = 0 ;
44056 void *argp1 = 0 ;
44057 int res1 = 0 ;
44058 int val2 ;
44059 int ecode2 = 0 ;
44060 bool temp3 = false ;
44061 PyObject * obj0 = 0 ;
44062 PyObject * obj1 = 0 ;
44063 PyObject * obj2 = 0 ;
44064 char * kwnames[] = {
44065 (char *) "self",(char *) "id",(char *) "label", NULL
44066 };
44067
44068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44070 if (!SWIG_IsOK(res1)) {
44071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
44072 }
44073 arg1 = reinterpret_cast< wxMenu * >(argp1);
44074 ecode2 = SWIG_AsVal_int(obj1, &val2);
44075 if (!SWIG_IsOK(ecode2)) {
44076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
44077 }
44078 arg2 = static_cast< int >(val2);
44079 {
44080 arg3 = wxString_in_helper(obj2);
44081 if (arg3 == NULL) SWIG_fail;
44082 temp3 = true;
44083 }
44084 {
44085 PyThreadState* __tstate = wxPyBeginAllowThreads();
44086 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
44087 wxPyEndAllowThreads(__tstate);
44088 if (PyErr_Occurred()) SWIG_fail;
44089 }
44090 resultobj = SWIG_Py_Void();
44091 {
44092 if (temp3)
44093 delete arg3;
44094 }
44095 return resultobj;
44096 fail:
44097 {
44098 if (temp3)
44099 delete arg3;
44100 }
44101 return NULL;
44102 }
44103
44104
44105 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44106 PyObject *resultobj = 0;
44107 wxMenu *arg1 = (wxMenu *) 0 ;
44108 int arg2 ;
44109 wxString result;
44110 void *argp1 = 0 ;
44111 int res1 = 0 ;
44112 int val2 ;
44113 int ecode2 = 0 ;
44114 PyObject * obj0 = 0 ;
44115 PyObject * obj1 = 0 ;
44116 char * kwnames[] = {
44117 (char *) "self",(char *) "id", NULL
44118 };
44119
44120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
44121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44122 if (!SWIG_IsOK(res1)) {
44123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
44124 }
44125 arg1 = reinterpret_cast< wxMenu * >(argp1);
44126 ecode2 = SWIG_AsVal_int(obj1, &val2);
44127 if (!SWIG_IsOK(ecode2)) {
44128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
44129 }
44130 arg2 = static_cast< int >(val2);
44131 {
44132 PyThreadState* __tstate = wxPyBeginAllowThreads();
44133 result = ((wxMenu const *)arg1)->GetLabel(arg2);
44134 wxPyEndAllowThreads(__tstate);
44135 if (PyErr_Occurred()) SWIG_fail;
44136 }
44137 {
44138 #if wxUSE_UNICODE
44139 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44140 #else
44141 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44142 #endif
44143 }
44144 return resultobj;
44145 fail:
44146 return NULL;
44147 }
44148
44149
44150 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44151 PyObject *resultobj = 0;
44152 wxMenu *arg1 = (wxMenu *) 0 ;
44153 int arg2 ;
44154 wxString *arg3 = 0 ;
44155 void *argp1 = 0 ;
44156 int res1 = 0 ;
44157 int val2 ;
44158 int ecode2 = 0 ;
44159 bool temp3 = false ;
44160 PyObject * obj0 = 0 ;
44161 PyObject * obj1 = 0 ;
44162 PyObject * obj2 = 0 ;
44163 char * kwnames[] = {
44164 (char *) "self",(char *) "id",(char *) "helpString", NULL
44165 };
44166
44167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44169 if (!SWIG_IsOK(res1)) {
44170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
44171 }
44172 arg1 = reinterpret_cast< wxMenu * >(argp1);
44173 ecode2 = SWIG_AsVal_int(obj1, &val2);
44174 if (!SWIG_IsOK(ecode2)) {
44175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
44176 }
44177 arg2 = static_cast< int >(val2);
44178 {
44179 arg3 = wxString_in_helper(obj2);
44180 if (arg3 == NULL) SWIG_fail;
44181 temp3 = true;
44182 }
44183 {
44184 PyThreadState* __tstate = wxPyBeginAllowThreads();
44185 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
44186 wxPyEndAllowThreads(__tstate);
44187 if (PyErr_Occurred()) SWIG_fail;
44188 }
44189 resultobj = SWIG_Py_Void();
44190 {
44191 if (temp3)
44192 delete arg3;
44193 }
44194 return resultobj;
44195 fail:
44196 {
44197 if (temp3)
44198 delete arg3;
44199 }
44200 return NULL;
44201 }
44202
44203
44204 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44205 PyObject *resultobj = 0;
44206 wxMenu *arg1 = (wxMenu *) 0 ;
44207 int arg2 ;
44208 wxString result;
44209 void *argp1 = 0 ;
44210 int res1 = 0 ;
44211 int val2 ;
44212 int ecode2 = 0 ;
44213 PyObject * obj0 = 0 ;
44214 PyObject * obj1 = 0 ;
44215 char * kwnames[] = {
44216 (char *) "self",(char *) "id", NULL
44217 };
44218
44219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
44220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44221 if (!SWIG_IsOK(res1)) {
44222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
44223 }
44224 arg1 = reinterpret_cast< wxMenu * >(argp1);
44225 ecode2 = SWIG_AsVal_int(obj1, &val2);
44226 if (!SWIG_IsOK(ecode2)) {
44227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
44228 }
44229 arg2 = static_cast< int >(val2);
44230 {
44231 PyThreadState* __tstate = wxPyBeginAllowThreads();
44232 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
44233 wxPyEndAllowThreads(__tstate);
44234 if (PyErr_Occurred()) SWIG_fail;
44235 }
44236 {
44237 #if wxUSE_UNICODE
44238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44239 #else
44240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44241 #endif
44242 }
44243 return resultobj;
44244 fail:
44245 return NULL;
44246 }
44247
44248
44249 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44250 PyObject *resultobj = 0;
44251 wxMenu *arg1 = (wxMenu *) 0 ;
44252 wxString *arg2 = 0 ;
44253 void *argp1 = 0 ;
44254 int res1 = 0 ;
44255 bool temp2 = false ;
44256 PyObject * obj0 = 0 ;
44257 PyObject * obj1 = 0 ;
44258 char * kwnames[] = {
44259 (char *) "self",(char *) "title", NULL
44260 };
44261
44262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
44263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44264 if (!SWIG_IsOK(res1)) {
44265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
44266 }
44267 arg1 = reinterpret_cast< wxMenu * >(argp1);
44268 {
44269 arg2 = wxString_in_helper(obj1);
44270 if (arg2 == NULL) SWIG_fail;
44271 temp2 = true;
44272 }
44273 {
44274 PyThreadState* __tstate = wxPyBeginAllowThreads();
44275 (arg1)->SetTitle((wxString const &)*arg2);
44276 wxPyEndAllowThreads(__tstate);
44277 if (PyErr_Occurred()) SWIG_fail;
44278 }
44279 resultobj = SWIG_Py_Void();
44280 {
44281 if (temp2)
44282 delete arg2;
44283 }
44284 return resultobj;
44285 fail:
44286 {
44287 if (temp2)
44288 delete arg2;
44289 }
44290 return NULL;
44291 }
44292
44293
44294 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44295 PyObject *resultobj = 0;
44296 wxMenu *arg1 = (wxMenu *) 0 ;
44297 wxString result;
44298 void *argp1 = 0 ;
44299 int res1 = 0 ;
44300 PyObject *swig_obj[1] ;
44301
44302 if (!args) SWIG_fail;
44303 swig_obj[0] = args;
44304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44305 if (!SWIG_IsOK(res1)) {
44306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44307 }
44308 arg1 = reinterpret_cast< wxMenu * >(argp1);
44309 {
44310 PyThreadState* __tstate = wxPyBeginAllowThreads();
44311 result = ((wxMenu const *)arg1)->GetTitle();
44312 wxPyEndAllowThreads(__tstate);
44313 if (PyErr_Occurred()) SWIG_fail;
44314 }
44315 {
44316 #if wxUSE_UNICODE
44317 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44318 #else
44319 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44320 #endif
44321 }
44322 return resultobj;
44323 fail:
44324 return NULL;
44325 }
44326
44327
44328 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44329 PyObject *resultobj = 0;
44330 wxMenu *arg1 = (wxMenu *) 0 ;
44331 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44332 void *argp1 = 0 ;
44333 int res1 = 0 ;
44334 void *argp2 = 0 ;
44335 int res2 = 0 ;
44336 PyObject * obj0 = 0 ;
44337 PyObject * obj1 = 0 ;
44338 char * kwnames[] = {
44339 (char *) "self",(char *) "handler", NULL
44340 };
44341
44342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44344 if (!SWIG_IsOK(res1)) {
44345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44346 }
44347 arg1 = reinterpret_cast< wxMenu * >(argp1);
44348 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44349 if (!SWIG_IsOK(res2)) {
44350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44351 }
44352 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44353 {
44354 PyThreadState* __tstate = wxPyBeginAllowThreads();
44355 (arg1)->SetEventHandler(arg2);
44356 wxPyEndAllowThreads(__tstate);
44357 if (PyErr_Occurred()) SWIG_fail;
44358 }
44359 resultobj = SWIG_Py_Void();
44360 return resultobj;
44361 fail:
44362 return NULL;
44363 }
44364
44365
44366 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44367 PyObject *resultobj = 0;
44368 wxMenu *arg1 = (wxMenu *) 0 ;
44369 wxEvtHandler *result = 0 ;
44370 void *argp1 = 0 ;
44371 int res1 = 0 ;
44372 PyObject *swig_obj[1] ;
44373
44374 if (!args) SWIG_fail;
44375 swig_obj[0] = args;
44376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44377 if (!SWIG_IsOK(res1)) {
44378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44379 }
44380 arg1 = reinterpret_cast< wxMenu * >(argp1);
44381 {
44382 PyThreadState* __tstate = wxPyBeginAllowThreads();
44383 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44384 wxPyEndAllowThreads(__tstate);
44385 if (PyErr_Occurred()) SWIG_fail;
44386 }
44387 {
44388 resultobj = wxPyMake_wxObject(result, 0);
44389 }
44390 return resultobj;
44391 fail:
44392 return NULL;
44393 }
44394
44395
44396 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44397 PyObject *resultobj = 0;
44398 wxMenu *arg1 = (wxMenu *) 0 ;
44399 wxWindow *arg2 = (wxWindow *) 0 ;
44400 void *argp1 = 0 ;
44401 int res1 = 0 ;
44402 void *argp2 = 0 ;
44403 int res2 = 0 ;
44404 PyObject * obj0 = 0 ;
44405 PyObject * obj1 = 0 ;
44406 char * kwnames[] = {
44407 (char *) "self",(char *) "win", NULL
44408 };
44409
44410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44412 if (!SWIG_IsOK(res1)) {
44413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44414 }
44415 arg1 = reinterpret_cast< wxMenu * >(argp1);
44416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44417 if (!SWIG_IsOK(res2)) {
44418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44419 }
44420 arg2 = reinterpret_cast< wxWindow * >(argp2);
44421 {
44422 PyThreadState* __tstate = wxPyBeginAllowThreads();
44423 (arg1)->SetInvokingWindow(arg2);
44424 wxPyEndAllowThreads(__tstate);
44425 if (PyErr_Occurred()) SWIG_fail;
44426 }
44427 resultobj = SWIG_Py_Void();
44428 return resultobj;
44429 fail:
44430 return NULL;
44431 }
44432
44433
44434 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44435 PyObject *resultobj = 0;
44436 wxMenu *arg1 = (wxMenu *) 0 ;
44437 wxWindow *result = 0 ;
44438 void *argp1 = 0 ;
44439 int res1 = 0 ;
44440 PyObject *swig_obj[1] ;
44441
44442 if (!args) SWIG_fail;
44443 swig_obj[0] = args;
44444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44445 if (!SWIG_IsOK(res1)) {
44446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44447 }
44448 arg1 = reinterpret_cast< wxMenu * >(argp1);
44449 {
44450 PyThreadState* __tstate = wxPyBeginAllowThreads();
44451 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44452 wxPyEndAllowThreads(__tstate);
44453 if (PyErr_Occurred()) SWIG_fail;
44454 }
44455 {
44456 resultobj = wxPyMake_wxObject(result, 0);
44457 }
44458 return resultobj;
44459 fail:
44460 return NULL;
44461 }
44462
44463
44464 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44465 PyObject *resultobj = 0;
44466 wxMenu *arg1 = (wxMenu *) 0 ;
44467 long result;
44468 void *argp1 = 0 ;
44469 int res1 = 0 ;
44470 PyObject *swig_obj[1] ;
44471
44472 if (!args) SWIG_fail;
44473 swig_obj[0] = args;
44474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44475 if (!SWIG_IsOK(res1)) {
44476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44477 }
44478 arg1 = reinterpret_cast< wxMenu * >(argp1);
44479 {
44480 PyThreadState* __tstate = wxPyBeginAllowThreads();
44481 result = (long)((wxMenu const *)arg1)->GetStyle();
44482 wxPyEndAllowThreads(__tstate);
44483 if (PyErr_Occurred()) SWIG_fail;
44484 }
44485 resultobj = SWIG_From_long(static_cast< long >(result));
44486 return resultobj;
44487 fail:
44488 return NULL;
44489 }
44490
44491
44492 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44493 PyObject *resultobj = 0;
44494 wxMenu *arg1 = (wxMenu *) 0 ;
44495 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44496 void *argp1 = 0 ;
44497 int res1 = 0 ;
44498 void *argp2 = 0 ;
44499 int res2 = 0 ;
44500 PyObject * obj0 = 0 ;
44501 PyObject * obj1 = 0 ;
44502 char * kwnames[] = {
44503 (char *) "self",(char *) "source", NULL
44504 };
44505
44506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44508 if (!SWIG_IsOK(res1)) {
44509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44510 }
44511 arg1 = reinterpret_cast< wxMenu * >(argp1);
44512 if (obj1) {
44513 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44514 if (!SWIG_IsOK(res2)) {
44515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44516 }
44517 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44518 }
44519 {
44520 PyThreadState* __tstate = wxPyBeginAllowThreads();
44521 (arg1)->UpdateUI(arg2);
44522 wxPyEndAllowThreads(__tstate);
44523 if (PyErr_Occurred()) SWIG_fail;
44524 }
44525 resultobj = SWIG_Py_Void();
44526 return resultobj;
44527 fail:
44528 return NULL;
44529 }
44530
44531
44532 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44533 PyObject *resultobj = 0;
44534 wxMenu *arg1 = (wxMenu *) 0 ;
44535 wxMenuBar *result = 0 ;
44536 void *argp1 = 0 ;
44537 int res1 = 0 ;
44538 PyObject *swig_obj[1] ;
44539
44540 if (!args) SWIG_fail;
44541 swig_obj[0] = args;
44542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44543 if (!SWIG_IsOK(res1)) {
44544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44545 }
44546 arg1 = reinterpret_cast< wxMenu * >(argp1);
44547 {
44548 PyThreadState* __tstate = wxPyBeginAllowThreads();
44549 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44550 wxPyEndAllowThreads(__tstate);
44551 if (PyErr_Occurred()) SWIG_fail;
44552 }
44553 {
44554 resultobj = wxPyMake_wxObject(result, (bool)0);
44555 }
44556 return resultobj;
44557 fail:
44558 return NULL;
44559 }
44560
44561
44562 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44563 PyObject *resultobj = 0;
44564 wxMenu *arg1 = (wxMenu *) 0 ;
44565 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44566 void *argp1 = 0 ;
44567 int res1 = 0 ;
44568 void *argp2 = 0 ;
44569 int res2 = 0 ;
44570 PyObject * obj0 = 0 ;
44571 PyObject * obj1 = 0 ;
44572 char * kwnames[] = {
44573 (char *) "self",(char *) "menubar", NULL
44574 };
44575
44576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44578 if (!SWIG_IsOK(res1)) {
44579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44580 }
44581 arg1 = reinterpret_cast< wxMenu * >(argp1);
44582 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44583 if (!SWIG_IsOK(res2)) {
44584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44585 }
44586 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44587 {
44588 PyThreadState* __tstate = wxPyBeginAllowThreads();
44589 (arg1)->Attach(arg2);
44590 wxPyEndAllowThreads(__tstate);
44591 if (PyErr_Occurred()) SWIG_fail;
44592 }
44593 resultobj = SWIG_Py_Void();
44594 return resultobj;
44595 fail:
44596 return NULL;
44597 }
44598
44599
44600 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44601 PyObject *resultobj = 0;
44602 wxMenu *arg1 = (wxMenu *) 0 ;
44603 void *argp1 = 0 ;
44604 int res1 = 0 ;
44605 PyObject *swig_obj[1] ;
44606
44607 if (!args) SWIG_fail;
44608 swig_obj[0] = args;
44609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44610 if (!SWIG_IsOK(res1)) {
44611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44612 }
44613 arg1 = reinterpret_cast< wxMenu * >(argp1);
44614 {
44615 PyThreadState* __tstate = wxPyBeginAllowThreads();
44616 (arg1)->Detach();
44617 wxPyEndAllowThreads(__tstate);
44618 if (PyErr_Occurred()) SWIG_fail;
44619 }
44620 resultobj = SWIG_Py_Void();
44621 return resultobj;
44622 fail:
44623 return NULL;
44624 }
44625
44626
44627 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44628 PyObject *resultobj = 0;
44629 wxMenu *arg1 = (wxMenu *) 0 ;
44630 bool result;
44631 void *argp1 = 0 ;
44632 int res1 = 0 ;
44633 PyObject *swig_obj[1] ;
44634
44635 if (!args) SWIG_fail;
44636 swig_obj[0] = args;
44637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44638 if (!SWIG_IsOK(res1)) {
44639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44640 }
44641 arg1 = reinterpret_cast< wxMenu * >(argp1);
44642 {
44643 PyThreadState* __tstate = wxPyBeginAllowThreads();
44644 result = (bool)((wxMenu const *)arg1)->IsAttached();
44645 wxPyEndAllowThreads(__tstate);
44646 if (PyErr_Occurred()) SWIG_fail;
44647 }
44648 {
44649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44650 }
44651 return resultobj;
44652 fail:
44653 return NULL;
44654 }
44655
44656
44657 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44658 PyObject *resultobj = 0;
44659 wxMenu *arg1 = (wxMenu *) 0 ;
44660 wxMenu *arg2 = (wxMenu *) 0 ;
44661 void *argp1 = 0 ;
44662 int res1 = 0 ;
44663 void *argp2 = 0 ;
44664 int res2 = 0 ;
44665 PyObject * obj0 = 0 ;
44666 PyObject * obj1 = 0 ;
44667 char * kwnames[] = {
44668 (char *) "self",(char *) "parent", NULL
44669 };
44670
44671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44673 if (!SWIG_IsOK(res1)) {
44674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44675 }
44676 arg1 = reinterpret_cast< wxMenu * >(argp1);
44677 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44678 if (!SWIG_IsOK(res2)) {
44679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44680 }
44681 arg2 = reinterpret_cast< wxMenu * >(argp2);
44682 {
44683 PyThreadState* __tstate = wxPyBeginAllowThreads();
44684 (arg1)->SetParent(arg2);
44685 wxPyEndAllowThreads(__tstate);
44686 if (PyErr_Occurred()) SWIG_fail;
44687 }
44688 resultobj = SWIG_Py_Void();
44689 return resultobj;
44690 fail:
44691 return NULL;
44692 }
44693
44694
44695 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44696 PyObject *resultobj = 0;
44697 wxMenu *arg1 = (wxMenu *) 0 ;
44698 wxMenu *result = 0 ;
44699 void *argp1 = 0 ;
44700 int res1 = 0 ;
44701 PyObject *swig_obj[1] ;
44702
44703 if (!args) SWIG_fail;
44704 swig_obj[0] = args;
44705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44706 if (!SWIG_IsOK(res1)) {
44707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44708 }
44709 arg1 = reinterpret_cast< wxMenu * >(argp1);
44710 {
44711 PyThreadState* __tstate = wxPyBeginAllowThreads();
44712 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44713 wxPyEndAllowThreads(__tstate);
44714 if (PyErr_Occurred()) SWIG_fail;
44715 }
44716 {
44717 resultobj = wxPyMake_wxObject(result, 0);
44718 }
44719 return resultobj;
44720 fail:
44721 return NULL;
44722 }
44723
44724
44725 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44726 PyObject *obj;
44727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44728 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44729 return SWIG_Py_Void();
44730 }
44731
44732 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44733 return SWIG_Python_InitShadowInstance(args);
44734 }
44735
44736 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44737 PyObject *resultobj = 0;
44738 long arg1 = (long) 0 ;
44739 wxMenuBar *result = 0 ;
44740 long val1 ;
44741 int ecode1 = 0 ;
44742 PyObject * obj0 = 0 ;
44743 char * kwnames[] = {
44744 (char *) "style", NULL
44745 };
44746
44747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44748 if (obj0) {
44749 ecode1 = SWIG_AsVal_long(obj0, &val1);
44750 if (!SWIG_IsOK(ecode1)) {
44751 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44752 }
44753 arg1 = static_cast< long >(val1);
44754 }
44755 {
44756 if (!wxPyCheckForApp()) SWIG_fail;
44757 PyThreadState* __tstate = wxPyBeginAllowThreads();
44758 result = (wxMenuBar *)new wxMenuBar(arg1);
44759 wxPyEndAllowThreads(__tstate);
44760 if (PyErr_Occurred()) SWIG_fail;
44761 }
44762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44763 return resultobj;
44764 fail:
44765 return NULL;
44766 }
44767
44768
44769 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44770 PyObject *resultobj = 0;
44771 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44772 wxMenu *arg2 = (wxMenu *) 0 ;
44773 wxString *arg3 = 0 ;
44774 bool result;
44775 void *argp1 = 0 ;
44776 int res1 = 0 ;
44777 void *argp2 = 0 ;
44778 int res2 = 0 ;
44779 bool temp3 = false ;
44780 PyObject * obj0 = 0 ;
44781 PyObject * obj1 = 0 ;
44782 PyObject * obj2 = 0 ;
44783 char * kwnames[] = {
44784 (char *) "self",(char *) "menu",(char *) "title", NULL
44785 };
44786
44787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44789 if (!SWIG_IsOK(res1)) {
44790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44791 }
44792 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44793 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44794 if (!SWIG_IsOK(res2)) {
44795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44796 }
44797 arg2 = reinterpret_cast< wxMenu * >(argp2);
44798 {
44799 arg3 = wxString_in_helper(obj2);
44800 if (arg3 == NULL) SWIG_fail;
44801 temp3 = true;
44802 }
44803 {
44804 PyThreadState* __tstate = wxPyBeginAllowThreads();
44805 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44806 wxPyEndAllowThreads(__tstate);
44807 if (PyErr_Occurred()) SWIG_fail;
44808 }
44809 {
44810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44811 }
44812 {
44813 if (temp3)
44814 delete arg3;
44815 }
44816 return resultobj;
44817 fail:
44818 {
44819 if (temp3)
44820 delete arg3;
44821 }
44822 return NULL;
44823 }
44824
44825
44826 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44827 PyObject *resultobj = 0;
44828 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44829 size_t arg2 ;
44830 wxMenu *arg3 = (wxMenu *) 0 ;
44831 wxString *arg4 = 0 ;
44832 bool result;
44833 void *argp1 = 0 ;
44834 int res1 = 0 ;
44835 size_t val2 ;
44836 int ecode2 = 0 ;
44837 void *argp3 = 0 ;
44838 int res3 = 0 ;
44839 bool temp4 = false ;
44840 PyObject * obj0 = 0 ;
44841 PyObject * obj1 = 0 ;
44842 PyObject * obj2 = 0 ;
44843 PyObject * obj3 = 0 ;
44844 char * kwnames[] = {
44845 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44846 };
44847
44848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44850 if (!SWIG_IsOK(res1)) {
44851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44852 }
44853 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44854 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44855 if (!SWIG_IsOK(ecode2)) {
44856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44857 }
44858 arg2 = static_cast< size_t >(val2);
44859 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44860 if (!SWIG_IsOK(res3)) {
44861 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44862 }
44863 arg3 = reinterpret_cast< wxMenu * >(argp3);
44864 {
44865 arg4 = wxString_in_helper(obj3);
44866 if (arg4 == NULL) SWIG_fail;
44867 temp4 = true;
44868 }
44869 {
44870 PyThreadState* __tstate = wxPyBeginAllowThreads();
44871 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44872 wxPyEndAllowThreads(__tstate);
44873 if (PyErr_Occurred()) SWIG_fail;
44874 }
44875 {
44876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44877 }
44878 {
44879 if (temp4)
44880 delete arg4;
44881 }
44882 return resultobj;
44883 fail:
44884 {
44885 if (temp4)
44886 delete arg4;
44887 }
44888 return NULL;
44889 }
44890
44891
44892 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44893 PyObject *resultobj = 0;
44894 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44895 size_t result;
44896 void *argp1 = 0 ;
44897 int res1 = 0 ;
44898 PyObject *swig_obj[1] ;
44899
44900 if (!args) SWIG_fail;
44901 swig_obj[0] = args;
44902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44903 if (!SWIG_IsOK(res1)) {
44904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44905 }
44906 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44907 {
44908 PyThreadState* __tstate = wxPyBeginAllowThreads();
44909 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44910 wxPyEndAllowThreads(__tstate);
44911 if (PyErr_Occurred()) SWIG_fail;
44912 }
44913 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44914 return resultobj;
44915 fail:
44916 return NULL;
44917 }
44918
44919
44920 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44921 PyObject *resultobj = 0;
44922 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44923 size_t arg2 ;
44924 wxMenu *result = 0 ;
44925 void *argp1 = 0 ;
44926 int res1 = 0 ;
44927 size_t val2 ;
44928 int ecode2 = 0 ;
44929 PyObject * obj0 = 0 ;
44930 PyObject * obj1 = 0 ;
44931 char * kwnames[] = {
44932 (char *) "self",(char *) "pos", NULL
44933 };
44934
44935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44937 if (!SWIG_IsOK(res1)) {
44938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44939 }
44940 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44941 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44942 if (!SWIG_IsOK(ecode2)) {
44943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44944 }
44945 arg2 = static_cast< size_t >(val2);
44946 {
44947 PyThreadState* __tstate = wxPyBeginAllowThreads();
44948 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44949 wxPyEndAllowThreads(__tstate);
44950 if (PyErr_Occurred()) SWIG_fail;
44951 }
44952 {
44953 resultobj = wxPyMake_wxObject(result, 0);
44954 }
44955 return resultobj;
44956 fail:
44957 return NULL;
44958 }
44959
44960
44961 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44962 PyObject *resultobj = 0;
44963 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44964 size_t arg2 ;
44965 wxMenu *arg3 = (wxMenu *) 0 ;
44966 wxString *arg4 = 0 ;
44967 wxMenu *result = 0 ;
44968 void *argp1 = 0 ;
44969 int res1 = 0 ;
44970 size_t val2 ;
44971 int ecode2 = 0 ;
44972 void *argp3 = 0 ;
44973 int res3 = 0 ;
44974 bool temp4 = false ;
44975 PyObject * obj0 = 0 ;
44976 PyObject * obj1 = 0 ;
44977 PyObject * obj2 = 0 ;
44978 PyObject * obj3 = 0 ;
44979 char * kwnames[] = {
44980 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44981 };
44982
44983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44985 if (!SWIG_IsOK(res1)) {
44986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44987 }
44988 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44989 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44990 if (!SWIG_IsOK(ecode2)) {
44991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44992 }
44993 arg2 = static_cast< size_t >(val2);
44994 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44995 if (!SWIG_IsOK(res3)) {
44996 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44997 }
44998 arg3 = reinterpret_cast< wxMenu * >(argp3);
44999 {
45000 arg4 = wxString_in_helper(obj3);
45001 if (arg4 == NULL) SWIG_fail;
45002 temp4 = true;
45003 }
45004 {
45005 PyThreadState* __tstate = wxPyBeginAllowThreads();
45006 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
45007 wxPyEndAllowThreads(__tstate);
45008 if (PyErr_Occurred()) SWIG_fail;
45009 }
45010 {
45011 resultobj = wxPyMake_wxObject(result, 0);
45012 }
45013 {
45014 if (temp4)
45015 delete arg4;
45016 }
45017 return resultobj;
45018 fail:
45019 {
45020 if (temp4)
45021 delete arg4;
45022 }
45023 return NULL;
45024 }
45025
45026
45027 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45028 PyObject *resultobj = 0;
45029 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45030 size_t arg2 ;
45031 wxMenu *result = 0 ;
45032 void *argp1 = 0 ;
45033 int res1 = 0 ;
45034 size_t val2 ;
45035 int ecode2 = 0 ;
45036 PyObject * obj0 = 0 ;
45037 PyObject * obj1 = 0 ;
45038 char * kwnames[] = {
45039 (char *) "self",(char *) "pos", NULL
45040 };
45041
45042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
45043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45044 if (!SWIG_IsOK(res1)) {
45045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45046 }
45047 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45048 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45049 if (!SWIG_IsOK(ecode2)) {
45050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
45051 }
45052 arg2 = static_cast< size_t >(val2);
45053 {
45054 PyThreadState* __tstate = wxPyBeginAllowThreads();
45055 result = (wxMenu *)(arg1)->Remove(arg2);
45056 wxPyEndAllowThreads(__tstate);
45057 if (PyErr_Occurred()) SWIG_fail;
45058 }
45059 {
45060 resultobj = wxPyMake_wxObject(result, 0);
45061 }
45062 return resultobj;
45063 fail:
45064 return NULL;
45065 }
45066
45067
45068 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45069 PyObject *resultobj = 0;
45070 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45071 size_t arg2 ;
45072 bool arg3 ;
45073 void *argp1 = 0 ;
45074 int res1 = 0 ;
45075 size_t val2 ;
45076 int ecode2 = 0 ;
45077 bool val3 ;
45078 int ecode3 = 0 ;
45079 PyObject * obj0 = 0 ;
45080 PyObject * obj1 = 0 ;
45081 PyObject * obj2 = 0 ;
45082 char * kwnames[] = {
45083 (char *) "self",(char *) "pos",(char *) "enable", NULL
45084 };
45085
45086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45088 if (!SWIG_IsOK(res1)) {
45089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45090 }
45091 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45092 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45093 if (!SWIG_IsOK(ecode2)) {
45094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
45095 }
45096 arg2 = static_cast< size_t >(val2);
45097 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45098 if (!SWIG_IsOK(ecode3)) {
45099 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
45100 }
45101 arg3 = static_cast< bool >(val3);
45102 {
45103 PyThreadState* __tstate = wxPyBeginAllowThreads();
45104 (arg1)->EnableTop(arg2,arg3);
45105 wxPyEndAllowThreads(__tstate);
45106 if (PyErr_Occurred()) SWIG_fail;
45107 }
45108 resultobj = SWIG_Py_Void();
45109 return resultobj;
45110 fail:
45111 return NULL;
45112 }
45113
45114
45115 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45116 PyObject *resultobj = 0;
45117 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45118 size_t arg2 ;
45119 bool result;
45120 void *argp1 = 0 ;
45121 int res1 = 0 ;
45122 size_t val2 ;
45123 int ecode2 = 0 ;
45124 PyObject * obj0 = 0 ;
45125 PyObject * obj1 = 0 ;
45126 char * kwnames[] = {
45127 (char *) "self",(char *) "pos", NULL
45128 };
45129
45130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
45131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45132 if (!SWIG_IsOK(res1)) {
45133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45134 }
45135 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45136 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45137 if (!SWIG_IsOK(ecode2)) {
45138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
45139 }
45140 arg2 = static_cast< size_t >(val2);
45141 {
45142 PyThreadState* __tstate = wxPyBeginAllowThreads();
45143 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
45144 wxPyEndAllowThreads(__tstate);
45145 if (PyErr_Occurred()) SWIG_fail;
45146 }
45147 {
45148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45149 }
45150 return resultobj;
45151 fail:
45152 return NULL;
45153 }
45154
45155
45156 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45157 PyObject *resultobj = 0;
45158 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45159 size_t arg2 ;
45160 wxString *arg3 = 0 ;
45161 void *argp1 = 0 ;
45162 int res1 = 0 ;
45163 size_t val2 ;
45164 int ecode2 = 0 ;
45165 bool temp3 = false ;
45166 PyObject * obj0 = 0 ;
45167 PyObject * obj1 = 0 ;
45168 PyObject * obj2 = 0 ;
45169 char * kwnames[] = {
45170 (char *) "self",(char *) "pos",(char *) "label", NULL
45171 };
45172
45173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45175 if (!SWIG_IsOK(res1)) {
45176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45177 }
45178 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45179 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45180 if (!SWIG_IsOK(ecode2)) {
45181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45182 }
45183 arg2 = static_cast< size_t >(val2);
45184 {
45185 arg3 = wxString_in_helper(obj2);
45186 if (arg3 == NULL) SWIG_fail;
45187 temp3 = true;
45188 }
45189 {
45190 PyThreadState* __tstate = wxPyBeginAllowThreads();
45191 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
45192 wxPyEndAllowThreads(__tstate);
45193 if (PyErr_Occurred()) SWIG_fail;
45194 }
45195 resultobj = SWIG_Py_Void();
45196 {
45197 if (temp3)
45198 delete arg3;
45199 }
45200 return resultobj;
45201 fail:
45202 {
45203 if (temp3)
45204 delete arg3;
45205 }
45206 return NULL;
45207 }
45208
45209
45210 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45211 PyObject *resultobj = 0;
45212 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45213 size_t arg2 ;
45214 wxString result;
45215 void *argp1 = 0 ;
45216 int res1 = 0 ;
45217 size_t val2 ;
45218 int ecode2 = 0 ;
45219 PyObject * obj0 = 0 ;
45220 PyObject * obj1 = 0 ;
45221 char * kwnames[] = {
45222 (char *) "self",(char *) "pos", NULL
45223 };
45224
45225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
45226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45227 if (!SWIG_IsOK(res1)) {
45228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45229 }
45230 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45231 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45232 if (!SWIG_IsOK(ecode2)) {
45233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45234 }
45235 arg2 = static_cast< size_t >(val2);
45236 {
45237 PyThreadState* __tstate = wxPyBeginAllowThreads();
45238 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
45239 wxPyEndAllowThreads(__tstate);
45240 if (PyErr_Occurred()) SWIG_fail;
45241 }
45242 {
45243 #if wxUSE_UNICODE
45244 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45245 #else
45246 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45247 #endif
45248 }
45249 return resultobj;
45250 fail:
45251 return NULL;
45252 }
45253
45254
45255 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45256 PyObject *resultobj = 0;
45257 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45258 wxString *arg2 = 0 ;
45259 wxString *arg3 = 0 ;
45260 int result;
45261 void *argp1 = 0 ;
45262 int res1 = 0 ;
45263 bool temp2 = false ;
45264 bool temp3 = false ;
45265 PyObject * obj0 = 0 ;
45266 PyObject * obj1 = 0 ;
45267 PyObject * obj2 = 0 ;
45268 char * kwnames[] = {
45269 (char *) "self",(char *) "menu",(char *) "item", NULL
45270 };
45271
45272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45274 if (!SWIG_IsOK(res1)) {
45275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45276 }
45277 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45278 {
45279 arg2 = wxString_in_helper(obj1);
45280 if (arg2 == NULL) SWIG_fail;
45281 temp2 = true;
45282 }
45283 {
45284 arg3 = wxString_in_helper(obj2);
45285 if (arg3 == NULL) SWIG_fail;
45286 temp3 = true;
45287 }
45288 {
45289 PyThreadState* __tstate = wxPyBeginAllowThreads();
45290 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
45291 wxPyEndAllowThreads(__tstate);
45292 if (PyErr_Occurred()) SWIG_fail;
45293 }
45294 resultobj = SWIG_From_int(static_cast< int >(result));
45295 {
45296 if (temp2)
45297 delete arg2;
45298 }
45299 {
45300 if (temp3)
45301 delete arg3;
45302 }
45303 return resultobj;
45304 fail:
45305 {
45306 if (temp2)
45307 delete arg2;
45308 }
45309 {
45310 if (temp3)
45311 delete arg3;
45312 }
45313 return NULL;
45314 }
45315
45316
45317 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45318 PyObject *resultobj = 0;
45319 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45320 int arg2 ;
45321 wxMenuItem *result = 0 ;
45322 void *argp1 = 0 ;
45323 int res1 = 0 ;
45324 int val2 ;
45325 int ecode2 = 0 ;
45326 PyObject * obj0 = 0 ;
45327 PyObject * obj1 = 0 ;
45328 char * kwnames[] = {
45329 (char *) "self",(char *) "id", NULL
45330 };
45331
45332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45334 if (!SWIG_IsOK(res1)) {
45335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45336 }
45337 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45338 ecode2 = SWIG_AsVal_int(obj1, &val2);
45339 if (!SWIG_IsOK(ecode2)) {
45340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45341 }
45342 arg2 = static_cast< int >(val2);
45343 {
45344 PyThreadState* __tstate = wxPyBeginAllowThreads();
45345 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45346 wxPyEndAllowThreads(__tstate);
45347 if (PyErr_Occurred()) SWIG_fail;
45348 }
45349 {
45350 resultobj = wxPyMake_wxObject(result, (bool)0);
45351 }
45352 return resultobj;
45353 fail:
45354 return NULL;
45355 }
45356
45357
45358 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45359 PyObject *resultobj = 0;
45360 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45361 wxString *arg2 = 0 ;
45362 int result;
45363 void *argp1 = 0 ;
45364 int res1 = 0 ;
45365 bool temp2 = false ;
45366 PyObject * obj0 = 0 ;
45367 PyObject * obj1 = 0 ;
45368 char * kwnames[] = {
45369 (char *) "self",(char *) "title", NULL
45370 };
45371
45372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45374 if (!SWIG_IsOK(res1)) {
45375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45376 }
45377 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45378 {
45379 arg2 = wxString_in_helper(obj1);
45380 if (arg2 == NULL) SWIG_fail;
45381 temp2 = true;
45382 }
45383 {
45384 PyThreadState* __tstate = wxPyBeginAllowThreads();
45385 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45386 wxPyEndAllowThreads(__tstate);
45387 if (PyErr_Occurred()) SWIG_fail;
45388 }
45389 resultobj = SWIG_From_int(static_cast< int >(result));
45390 {
45391 if (temp2)
45392 delete arg2;
45393 }
45394 return resultobj;
45395 fail:
45396 {
45397 if (temp2)
45398 delete arg2;
45399 }
45400 return NULL;
45401 }
45402
45403
45404 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45405 PyObject *resultobj = 0;
45406 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45407 int arg2 ;
45408 bool arg3 ;
45409 void *argp1 = 0 ;
45410 int res1 = 0 ;
45411 int val2 ;
45412 int ecode2 = 0 ;
45413 bool val3 ;
45414 int ecode3 = 0 ;
45415 PyObject * obj0 = 0 ;
45416 PyObject * obj1 = 0 ;
45417 PyObject * obj2 = 0 ;
45418 char * kwnames[] = {
45419 (char *) "self",(char *) "id",(char *) "enable", NULL
45420 };
45421
45422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45424 if (!SWIG_IsOK(res1)) {
45425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45426 }
45427 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45428 ecode2 = SWIG_AsVal_int(obj1, &val2);
45429 if (!SWIG_IsOK(ecode2)) {
45430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45431 }
45432 arg2 = static_cast< int >(val2);
45433 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45434 if (!SWIG_IsOK(ecode3)) {
45435 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45436 }
45437 arg3 = static_cast< bool >(val3);
45438 {
45439 PyThreadState* __tstate = wxPyBeginAllowThreads();
45440 (arg1)->Enable(arg2,arg3);
45441 wxPyEndAllowThreads(__tstate);
45442 if (PyErr_Occurred()) SWIG_fail;
45443 }
45444 resultobj = SWIG_Py_Void();
45445 return resultobj;
45446 fail:
45447 return NULL;
45448 }
45449
45450
45451 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45452 PyObject *resultobj = 0;
45453 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45454 int arg2 ;
45455 bool arg3 ;
45456 void *argp1 = 0 ;
45457 int res1 = 0 ;
45458 int val2 ;
45459 int ecode2 = 0 ;
45460 bool val3 ;
45461 int ecode3 = 0 ;
45462 PyObject * obj0 = 0 ;
45463 PyObject * obj1 = 0 ;
45464 PyObject * obj2 = 0 ;
45465 char * kwnames[] = {
45466 (char *) "self",(char *) "id",(char *) "check", NULL
45467 };
45468
45469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45471 if (!SWIG_IsOK(res1)) {
45472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45473 }
45474 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45475 ecode2 = SWIG_AsVal_int(obj1, &val2);
45476 if (!SWIG_IsOK(ecode2)) {
45477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45478 }
45479 arg2 = static_cast< int >(val2);
45480 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45481 if (!SWIG_IsOK(ecode3)) {
45482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45483 }
45484 arg3 = static_cast< bool >(val3);
45485 {
45486 PyThreadState* __tstate = wxPyBeginAllowThreads();
45487 (arg1)->Check(arg2,arg3);
45488 wxPyEndAllowThreads(__tstate);
45489 if (PyErr_Occurred()) SWIG_fail;
45490 }
45491 resultobj = SWIG_Py_Void();
45492 return resultobj;
45493 fail:
45494 return NULL;
45495 }
45496
45497
45498 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45499 PyObject *resultobj = 0;
45500 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45501 int arg2 ;
45502 bool result;
45503 void *argp1 = 0 ;
45504 int res1 = 0 ;
45505 int val2 ;
45506 int ecode2 = 0 ;
45507 PyObject * obj0 = 0 ;
45508 PyObject * obj1 = 0 ;
45509 char * kwnames[] = {
45510 (char *) "self",(char *) "id", NULL
45511 };
45512
45513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45515 if (!SWIG_IsOK(res1)) {
45516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45517 }
45518 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45519 ecode2 = SWIG_AsVal_int(obj1, &val2);
45520 if (!SWIG_IsOK(ecode2)) {
45521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45522 }
45523 arg2 = static_cast< int >(val2);
45524 {
45525 PyThreadState* __tstate = wxPyBeginAllowThreads();
45526 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45527 wxPyEndAllowThreads(__tstate);
45528 if (PyErr_Occurred()) SWIG_fail;
45529 }
45530 {
45531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45532 }
45533 return resultobj;
45534 fail:
45535 return NULL;
45536 }
45537
45538
45539 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45540 PyObject *resultobj = 0;
45541 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45542 int arg2 ;
45543 bool result;
45544 void *argp1 = 0 ;
45545 int res1 = 0 ;
45546 int val2 ;
45547 int ecode2 = 0 ;
45548 PyObject * obj0 = 0 ;
45549 PyObject * obj1 = 0 ;
45550 char * kwnames[] = {
45551 (char *) "self",(char *) "id", NULL
45552 };
45553
45554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45556 if (!SWIG_IsOK(res1)) {
45557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45558 }
45559 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45560 ecode2 = SWIG_AsVal_int(obj1, &val2);
45561 if (!SWIG_IsOK(ecode2)) {
45562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45563 }
45564 arg2 = static_cast< int >(val2);
45565 {
45566 PyThreadState* __tstate = wxPyBeginAllowThreads();
45567 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45568 wxPyEndAllowThreads(__tstate);
45569 if (PyErr_Occurred()) SWIG_fail;
45570 }
45571 {
45572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45573 }
45574 return resultobj;
45575 fail:
45576 return NULL;
45577 }
45578
45579
45580 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45581 PyObject *resultobj = 0;
45582 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45583 int arg2 ;
45584 wxString *arg3 = 0 ;
45585 void *argp1 = 0 ;
45586 int res1 = 0 ;
45587 int val2 ;
45588 int ecode2 = 0 ;
45589 bool temp3 = false ;
45590 PyObject * obj0 = 0 ;
45591 PyObject * obj1 = 0 ;
45592 PyObject * obj2 = 0 ;
45593 char * kwnames[] = {
45594 (char *) "self",(char *) "id",(char *) "label", NULL
45595 };
45596
45597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45599 if (!SWIG_IsOK(res1)) {
45600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45601 }
45602 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45603 ecode2 = SWIG_AsVal_int(obj1, &val2);
45604 if (!SWIG_IsOK(ecode2)) {
45605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45606 }
45607 arg2 = static_cast< int >(val2);
45608 {
45609 arg3 = wxString_in_helper(obj2);
45610 if (arg3 == NULL) SWIG_fail;
45611 temp3 = true;
45612 }
45613 {
45614 PyThreadState* __tstate = wxPyBeginAllowThreads();
45615 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45616 wxPyEndAllowThreads(__tstate);
45617 if (PyErr_Occurred()) SWIG_fail;
45618 }
45619 resultobj = SWIG_Py_Void();
45620 {
45621 if (temp3)
45622 delete arg3;
45623 }
45624 return resultobj;
45625 fail:
45626 {
45627 if (temp3)
45628 delete arg3;
45629 }
45630 return NULL;
45631 }
45632
45633
45634 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45635 PyObject *resultobj = 0;
45636 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45637 int arg2 ;
45638 wxString result;
45639 void *argp1 = 0 ;
45640 int res1 = 0 ;
45641 int val2 ;
45642 int ecode2 = 0 ;
45643 PyObject * obj0 = 0 ;
45644 PyObject * obj1 = 0 ;
45645 char * kwnames[] = {
45646 (char *) "self",(char *) "id", NULL
45647 };
45648
45649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45651 if (!SWIG_IsOK(res1)) {
45652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45653 }
45654 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45655 ecode2 = SWIG_AsVal_int(obj1, &val2);
45656 if (!SWIG_IsOK(ecode2)) {
45657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45658 }
45659 arg2 = static_cast< int >(val2);
45660 {
45661 PyThreadState* __tstate = wxPyBeginAllowThreads();
45662 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45663 wxPyEndAllowThreads(__tstate);
45664 if (PyErr_Occurred()) SWIG_fail;
45665 }
45666 {
45667 #if wxUSE_UNICODE
45668 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45669 #else
45670 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45671 #endif
45672 }
45673 return resultobj;
45674 fail:
45675 return NULL;
45676 }
45677
45678
45679 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45680 PyObject *resultobj = 0;
45681 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45682 int arg2 ;
45683 wxString *arg3 = 0 ;
45684 void *argp1 = 0 ;
45685 int res1 = 0 ;
45686 int val2 ;
45687 int ecode2 = 0 ;
45688 bool temp3 = false ;
45689 PyObject * obj0 = 0 ;
45690 PyObject * obj1 = 0 ;
45691 PyObject * obj2 = 0 ;
45692 char * kwnames[] = {
45693 (char *) "self",(char *) "id",(char *) "helpString", NULL
45694 };
45695
45696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45698 if (!SWIG_IsOK(res1)) {
45699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45700 }
45701 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45702 ecode2 = SWIG_AsVal_int(obj1, &val2);
45703 if (!SWIG_IsOK(ecode2)) {
45704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45705 }
45706 arg2 = static_cast< int >(val2);
45707 {
45708 arg3 = wxString_in_helper(obj2);
45709 if (arg3 == NULL) SWIG_fail;
45710 temp3 = true;
45711 }
45712 {
45713 PyThreadState* __tstate = wxPyBeginAllowThreads();
45714 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45715 wxPyEndAllowThreads(__tstate);
45716 if (PyErr_Occurred()) SWIG_fail;
45717 }
45718 resultobj = SWIG_Py_Void();
45719 {
45720 if (temp3)
45721 delete arg3;
45722 }
45723 return resultobj;
45724 fail:
45725 {
45726 if (temp3)
45727 delete arg3;
45728 }
45729 return NULL;
45730 }
45731
45732
45733 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45734 PyObject *resultobj = 0;
45735 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45736 int arg2 ;
45737 wxString result;
45738 void *argp1 = 0 ;
45739 int res1 = 0 ;
45740 int val2 ;
45741 int ecode2 = 0 ;
45742 PyObject * obj0 = 0 ;
45743 PyObject * obj1 = 0 ;
45744 char * kwnames[] = {
45745 (char *) "self",(char *) "id", NULL
45746 };
45747
45748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45750 if (!SWIG_IsOK(res1)) {
45751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45752 }
45753 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45754 ecode2 = SWIG_AsVal_int(obj1, &val2);
45755 if (!SWIG_IsOK(ecode2)) {
45756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45757 }
45758 arg2 = static_cast< int >(val2);
45759 {
45760 PyThreadState* __tstate = wxPyBeginAllowThreads();
45761 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45762 wxPyEndAllowThreads(__tstate);
45763 if (PyErr_Occurred()) SWIG_fail;
45764 }
45765 {
45766 #if wxUSE_UNICODE
45767 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45768 #else
45769 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45770 #endif
45771 }
45772 return resultobj;
45773 fail:
45774 return NULL;
45775 }
45776
45777
45778 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45779 PyObject *resultobj = 0;
45780 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45781 wxFrame *result = 0 ;
45782 void *argp1 = 0 ;
45783 int res1 = 0 ;
45784 PyObject *swig_obj[1] ;
45785
45786 if (!args) SWIG_fail;
45787 swig_obj[0] = args;
45788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45789 if (!SWIG_IsOK(res1)) {
45790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45791 }
45792 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45793 {
45794 PyThreadState* __tstate = wxPyBeginAllowThreads();
45795 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45796 wxPyEndAllowThreads(__tstate);
45797 if (PyErr_Occurred()) SWIG_fail;
45798 }
45799 {
45800 resultobj = wxPyMake_wxObject(result, (bool)0);
45801 }
45802 return resultobj;
45803 fail:
45804 return NULL;
45805 }
45806
45807
45808 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45809 PyObject *resultobj = 0;
45810 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45811 bool result;
45812 void *argp1 = 0 ;
45813 int res1 = 0 ;
45814 PyObject *swig_obj[1] ;
45815
45816 if (!args) SWIG_fail;
45817 swig_obj[0] = args;
45818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45819 if (!SWIG_IsOK(res1)) {
45820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45821 }
45822 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45823 {
45824 PyThreadState* __tstate = wxPyBeginAllowThreads();
45825 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45826 wxPyEndAllowThreads(__tstate);
45827 if (PyErr_Occurred()) SWIG_fail;
45828 }
45829 {
45830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45831 }
45832 return resultobj;
45833 fail:
45834 return NULL;
45835 }
45836
45837
45838 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45839 PyObject *resultobj = 0;
45840 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45841 wxFrame *arg2 = (wxFrame *) 0 ;
45842 void *argp1 = 0 ;
45843 int res1 = 0 ;
45844 void *argp2 = 0 ;
45845 int res2 = 0 ;
45846 PyObject * obj0 = 0 ;
45847 PyObject * obj1 = 0 ;
45848 char * kwnames[] = {
45849 (char *) "self",(char *) "frame", NULL
45850 };
45851
45852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45854 if (!SWIG_IsOK(res1)) {
45855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45856 }
45857 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45858 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45859 if (!SWIG_IsOK(res2)) {
45860 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45861 }
45862 arg2 = reinterpret_cast< wxFrame * >(argp2);
45863 {
45864 PyThreadState* __tstate = wxPyBeginAllowThreads();
45865 (arg1)->Attach(arg2);
45866 wxPyEndAllowThreads(__tstate);
45867 if (PyErr_Occurred()) SWIG_fail;
45868 }
45869 resultobj = SWIG_Py_Void();
45870 return resultobj;
45871 fail:
45872 return NULL;
45873 }
45874
45875
45876 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45877 PyObject *resultobj = 0;
45878 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45879 void *argp1 = 0 ;
45880 int res1 = 0 ;
45881 PyObject *swig_obj[1] ;
45882
45883 if (!args) SWIG_fail;
45884 swig_obj[0] = args;
45885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45886 if (!SWIG_IsOK(res1)) {
45887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45888 }
45889 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45890 {
45891 PyThreadState* __tstate = wxPyBeginAllowThreads();
45892 (arg1)->Detach();
45893 wxPyEndAllowThreads(__tstate);
45894 if (PyErr_Occurred()) SWIG_fail;
45895 }
45896 resultobj = SWIG_Py_Void();
45897 return resultobj;
45898 fail:
45899 return NULL;
45900 }
45901
45902
45903 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45904 PyObject *resultobj = 0;
45905 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45906 void *argp1 = 0 ;
45907 int res1 = 0 ;
45908 PyObject *swig_obj[1] ;
45909
45910 if (!args) SWIG_fail;
45911 swig_obj[0] = args;
45912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45913 if (!SWIG_IsOK(res1)) {
45914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45915 }
45916 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45917 {
45918 PyThreadState* __tstate = wxPyBeginAllowThreads();
45919 (arg1)->UpdateMenus();
45920 wxPyEndAllowThreads(__tstate);
45921 if (PyErr_Occurred()) SWIG_fail;
45922 }
45923 resultobj = SWIG_Py_Void();
45924 return resultobj;
45925 fail:
45926 return NULL;
45927 }
45928
45929
45930 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45931 PyObject *resultobj = 0;
45932 bool arg1 ;
45933 bool val1 ;
45934 int ecode1 = 0 ;
45935 PyObject * obj0 = 0 ;
45936 char * kwnames[] = {
45937 (char *) "enable", NULL
45938 };
45939
45940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45941 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45942 if (!SWIG_IsOK(ecode1)) {
45943 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45944 }
45945 arg1 = static_cast< bool >(val1);
45946 {
45947 PyThreadState* __tstate = wxPyBeginAllowThreads();
45948 wxMenuBar_SetAutoWindowMenu(arg1);
45949 wxPyEndAllowThreads(__tstate);
45950 if (PyErr_Occurred()) SWIG_fail;
45951 }
45952 resultobj = SWIG_Py_Void();
45953 return resultobj;
45954 fail:
45955 return NULL;
45956 }
45957
45958
45959 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45960 PyObject *resultobj = 0;
45961 bool result;
45962
45963 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45964 {
45965 PyThreadState* __tstate = wxPyBeginAllowThreads();
45966 result = (bool)wxMenuBar_GetAutoWindowMenu();
45967 wxPyEndAllowThreads(__tstate);
45968 if (PyErr_Occurred()) SWIG_fail;
45969 }
45970 {
45971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45972 }
45973 return resultobj;
45974 fail:
45975 return NULL;
45976 }
45977
45978
45979 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45980 PyObject *obj;
45981 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45982 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45983 return SWIG_Py_Void();
45984 }
45985
45986 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45987 return SWIG_Python_InitShadowInstance(args);
45988 }
45989
45990 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45991 PyObject *resultobj = 0;
45992 wxMenu *arg1 = (wxMenu *) NULL ;
45993 int arg2 = (int) wxID_SEPARATOR ;
45994 wxString const &arg3_defvalue = wxPyEmptyString ;
45995 wxString *arg3 = (wxString *) &arg3_defvalue ;
45996 wxString const &arg4_defvalue = wxPyEmptyString ;
45997 wxString *arg4 = (wxString *) &arg4_defvalue ;
45998 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45999 wxMenu *arg6 = (wxMenu *) NULL ;
46000 wxMenuItem *result = 0 ;
46001 void *argp1 = 0 ;
46002 int res1 = 0 ;
46003 int val2 ;
46004 int ecode2 = 0 ;
46005 bool temp3 = false ;
46006 bool temp4 = false ;
46007 int val5 ;
46008 int ecode5 = 0 ;
46009 void *argp6 = 0 ;
46010 int res6 = 0 ;
46011 PyObject * obj0 = 0 ;
46012 PyObject * obj1 = 0 ;
46013 PyObject * obj2 = 0 ;
46014 PyObject * obj3 = 0 ;
46015 PyObject * obj4 = 0 ;
46016 PyObject * obj5 = 0 ;
46017 char * kwnames[] = {
46018 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
46019 };
46020
46021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46022 if (obj0) {
46023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
46024 if (!SWIG_IsOK(res1)) {
46025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
46026 }
46027 arg1 = reinterpret_cast< wxMenu * >(argp1);
46028 }
46029 if (obj1) {
46030 ecode2 = SWIG_AsVal_int(obj1, &val2);
46031 if (!SWIG_IsOK(ecode2)) {
46032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
46033 }
46034 arg2 = static_cast< int >(val2);
46035 }
46036 if (obj2) {
46037 {
46038 arg3 = wxString_in_helper(obj2);
46039 if (arg3 == NULL) SWIG_fail;
46040 temp3 = true;
46041 }
46042 }
46043 if (obj3) {
46044 {
46045 arg4 = wxString_in_helper(obj3);
46046 if (arg4 == NULL) SWIG_fail;
46047 temp4 = true;
46048 }
46049 }
46050 if (obj4) {
46051 ecode5 = SWIG_AsVal_int(obj4, &val5);
46052 if (!SWIG_IsOK(ecode5)) {
46053 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
46054 }
46055 arg5 = static_cast< wxItemKind >(val5);
46056 }
46057 if (obj5) {
46058 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
46059 if (!SWIG_IsOK(res6)) {
46060 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
46061 }
46062 arg6 = reinterpret_cast< wxMenu * >(argp6);
46063 }
46064 {
46065 PyThreadState* __tstate = wxPyBeginAllowThreads();
46066 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
46067 wxPyEndAllowThreads(__tstate);
46068 if (PyErr_Occurred()) SWIG_fail;
46069 }
46070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
46071 {
46072 if (temp3)
46073 delete arg3;
46074 }
46075 {
46076 if (temp4)
46077 delete arg4;
46078 }
46079 return resultobj;
46080 fail:
46081 {
46082 if (temp3)
46083 delete arg3;
46084 }
46085 {
46086 if (temp4)
46087 delete arg4;
46088 }
46089 return NULL;
46090 }
46091
46092
46093 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46094 PyObject *resultobj = 0;
46095 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46096 void *argp1 = 0 ;
46097 int res1 = 0 ;
46098 PyObject *swig_obj[1] ;
46099
46100 if (!args) SWIG_fail;
46101 swig_obj[0] = args;
46102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
46103 if (!SWIG_IsOK(res1)) {
46104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46105 }
46106 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46107 {
46108 PyThreadState* __tstate = wxPyBeginAllowThreads();
46109 delete arg1;
46110
46111 wxPyEndAllowThreads(__tstate);
46112 if (PyErr_Occurred()) SWIG_fail;
46113 }
46114 resultobj = SWIG_Py_Void();
46115 return resultobj;
46116 fail:
46117 return NULL;
46118 }
46119
46120
46121 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46122 PyObject *resultobj = 0;
46123 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46124 wxMenu *result = 0 ;
46125 void *argp1 = 0 ;
46126 int res1 = 0 ;
46127 PyObject *swig_obj[1] ;
46128
46129 if (!args) SWIG_fail;
46130 swig_obj[0] = args;
46131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46132 if (!SWIG_IsOK(res1)) {
46133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46134 }
46135 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46136 {
46137 PyThreadState* __tstate = wxPyBeginAllowThreads();
46138 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
46139 wxPyEndAllowThreads(__tstate);
46140 if (PyErr_Occurred()) SWIG_fail;
46141 }
46142 {
46143 resultobj = wxPyMake_wxObject(result, 0);
46144 }
46145 return resultobj;
46146 fail:
46147 return NULL;
46148 }
46149
46150
46151 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46152 PyObject *resultobj = 0;
46153 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46154 wxMenu *arg2 = (wxMenu *) 0 ;
46155 void *argp1 = 0 ;
46156 int res1 = 0 ;
46157 void *argp2 = 0 ;
46158 int res2 = 0 ;
46159 PyObject * obj0 = 0 ;
46160 PyObject * obj1 = 0 ;
46161 char * kwnames[] = {
46162 (char *) "self",(char *) "menu", NULL
46163 };
46164
46165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46167 if (!SWIG_IsOK(res1)) {
46168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46169 }
46170 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46171 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46172 if (!SWIG_IsOK(res2)) {
46173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46174 }
46175 arg2 = reinterpret_cast< wxMenu * >(argp2);
46176 {
46177 PyThreadState* __tstate = wxPyBeginAllowThreads();
46178 (arg1)->SetMenu(arg2);
46179 wxPyEndAllowThreads(__tstate);
46180 if (PyErr_Occurred()) SWIG_fail;
46181 }
46182 resultobj = SWIG_Py_Void();
46183 return resultobj;
46184 fail:
46185 return NULL;
46186 }
46187
46188
46189 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46190 PyObject *resultobj = 0;
46191 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46192 int arg2 ;
46193 void *argp1 = 0 ;
46194 int res1 = 0 ;
46195 int val2 ;
46196 int ecode2 = 0 ;
46197 PyObject * obj0 = 0 ;
46198 PyObject * obj1 = 0 ;
46199 char * kwnames[] = {
46200 (char *) "self",(char *) "id", NULL
46201 };
46202
46203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
46204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46205 if (!SWIG_IsOK(res1)) {
46206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46207 }
46208 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46209 ecode2 = SWIG_AsVal_int(obj1, &val2);
46210 if (!SWIG_IsOK(ecode2)) {
46211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
46212 }
46213 arg2 = static_cast< int >(val2);
46214 {
46215 PyThreadState* __tstate = wxPyBeginAllowThreads();
46216 (arg1)->SetId(arg2);
46217 wxPyEndAllowThreads(__tstate);
46218 if (PyErr_Occurred()) SWIG_fail;
46219 }
46220 resultobj = SWIG_Py_Void();
46221 return resultobj;
46222 fail:
46223 return NULL;
46224 }
46225
46226
46227 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46228 PyObject *resultobj = 0;
46229 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46230 int result;
46231 void *argp1 = 0 ;
46232 int res1 = 0 ;
46233 PyObject *swig_obj[1] ;
46234
46235 if (!args) SWIG_fail;
46236 swig_obj[0] = args;
46237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46238 if (!SWIG_IsOK(res1)) {
46239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46240 }
46241 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46242 {
46243 PyThreadState* __tstate = wxPyBeginAllowThreads();
46244 result = (int)((wxMenuItem const *)arg1)->GetId();
46245 wxPyEndAllowThreads(__tstate);
46246 if (PyErr_Occurred()) SWIG_fail;
46247 }
46248 resultobj = SWIG_From_int(static_cast< int >(result));
46249 return resultobj;
46250 fail:
46251 return NULL;
46252 }
46253
46254
46255 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46256 PyObject *resultobj = 0;
46257 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46258 bool result;
46259 void *argp1 = 0 ;
46260 int res1 = 0 ;
46261 PyObject *swig_obj[1] ;
46262
46263 if (!args) SWIG_fail;
46264 swig_obj[0] = args;
46265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46266 if (!SWIG_IsOK(res1)) {
46267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46268 }
46269 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46270 {
46271 PyThreadState* __tstate = wxPyBeginAllowThreads();
46272 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
46273 wxPyEndAllowThreads(__tstate);
46274 if (PyErr_Occurred()) SWIG_fail;
46275 }
46276 {
46277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46278 }
46279 return resultobj;
46280 fail:
46281 return NULL;
46282 }
46283
46284
46285 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46286 PyObject *resultobj = 0;
46287 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46288 wxString *arg2 = 0 ;
46289 void *argp1 = 0 ;
46290 int res1 = 0 ;
46291 bool temp2 = false ;
46292 PyObject * obj0 = 0 ;
46293 PyObject * obj1 = 0 ;
46294 char * kwnames[] = {
46295 (char *) "self",(char *) "str", NULL
46296 };
46297
46298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
46299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46300 if (!SWIG_IsOK(res1)) {
46301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46302 }
46303 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46304 {
46305 arg2 = wxString_in_helper(obj1);
46306 if (arg2 == NULL) SWIG_fail;
46307 temp2 = true;
46308 }
46309 {
46310 PyThreadState* __tstate = wxPyBeginAllowThreads();
46311 (arg1)->SetText((wxString const &)*arg2);
46312 wxPyEndAllowThreads(__tstate);
46313 if (PyErr_Occurred()) SWIG_fail;
46314 }
46315 resultobj = SWIG_Py_Void();
46316 {
46317 if (temp2)
46318 delete arg2;
46319 }
46320 return resultobj;
46321 fail:
46322 {
46323 if (temp2)
46324 delete arg2;
46325 }
46326 return NULL;
46327 }
46328
46329
46330 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46331 PyObject *resultobj = 0;
46332 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46333 wxString result;
46334 void *argp1 = 0 ;
46335 int res1 = 0 ;
46336 PyObject *swig_obj[1] ;
46337
46338 if (!args) SWIG_fail;
46339 swig_obj[0] = args;
46340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46341 if (!SWIG_IsOK(res1)) {
46342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46343 }
46344 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46345 {
46346 PyThreadState* __tstate = wxPyBeginAllowThreads();
46347 result = ((wxMenuItem const *)arg1)->GetLabel();
46348 wxPyEndAllowThreads(__tstate);
46349 if (PyErr_Occurred()) SWIG_fail;
46350 }
46351 {
46352 #if wxUSE_UNICODE
46353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46354 #else
46355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46356 #endif
46357 }
46358 return resultobj;
46359 fail:
46360 return NULL;
46361 }
46362
46363
46364 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46365 PyObject *resultobj = 0;
46366 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46367 wxString *result = 0 ;
46368 void *argp1 = 0 ;
46369 int res1 = 0 ;
46370 PyObject *swig_obj[1] ;
46371
46372 if (!args) SWIG_fail;
46373 swig_obj[0] = args;
46374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46375 if (!SWIG_IsOK(res1)) {
46376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46377 }
46378 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46379 {
46380 PyThreadState* __tstate = wxPyBeginAllowThreads();
46381 {
46382 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46383 result = (wxString *) &_result_ref;
46384 }
46385 wxPyEndAllowThreads(__tstate);
46386 if (PyErr_Occurred()) SWIG_fail;
46387 }
46388 {
46389 #if wxUSE_UNICODE
46390 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46391 #else
46392 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46393 #endif
46394 }
46395 return resultobj;
46396 fail:
46397 return NULL;
46398 }
46399
46400
46401 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46402 PyObject *resultobj = 0;
46403 wxString *arg1 = 0 ;
46404 wxString result;
46405 bool temp1 = false ;
46406 PyObject * obj0 = 0 ;
46407 char * kwnames[] = {
46408 (char *) "text", NULL
46409 };
46410
46411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46412 {
46413 arg1 = wxString_in_helper(obj0);
46414 if (arg1 == NULL) SWIG_fail;
46415 temp1 = true;
46416 }
46417 {
46418 PyThreadState* __tstate = wxPyBeginAllowThreads();
46419 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46420 wxPyEndAllowThreads(__tstate);
46421 if (PyErr_Occurred()) SWIG_fail;
46422 }
46423 {
46424 #if wxUSE_UNICODE
46425 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46426 #else
46427 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46428 #endif
46429 }
46430 {
46431 if (temp1)
46432 delete arg1;
46433 }
46434 return resultobj;
46435 fail:
46436 {
46437 if (temp1)
46438 delete arg1;
46439 }
46440 return NULL;
46441 }
46442
46443
46444 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46445 PyObject *resultobj = 0;
46446 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46447 wxItemKind result;
46448 void *argp1 = 0 ;
46449 int res1 = 0 ;
46450 PyObject *swig_obj[1] ;
46451
46452 if (!args) SWIG_fail;
46453 swig_obj[0] = args;
46454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46455 if (!SWIG_IsOK(res1)) {
46456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46457 }
46458 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46459 {
46460 PyThreadState* __tstate = wxPyBeginAllowThreads();
46461 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46462 wxPyEndAllowThreads(__tstate);
46463 if (PyErr_Occurred()) SWIG_fail;
46464 }
46465 resultobj = SWIG_From_int(static_cast< int >(result));
46466 return resultobj;
46467 fail:
46468 return NULL;
46469 }
46470
46471
46472 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46473 PyObject *resultobj = 0;
46474 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46475 wxItemKind arg2 ;
46476 void *argp1 = 0 ;
46477 int res1 = 0 ;
46478 int val2 ;
46479 int ecode2 = 0 ;
46480 PyObject * obj0 = 0 ;
46481 PyObject * obj1 = 0 ;
46482 char * kwnames[] = {
46483 (char *) "self",(char *) "kind", NULL
46484 };
46485
46486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46488 if (!SWIG_IsOK(res1)) {
46489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46490 }
46491 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46492 ecode2 = SWIG_AsVal_int(obj1, &val2);
46493 if (!SWIG_IsOK(ecode2)) {
46494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46495 }
46496 arg2 = static_cast< wxItemKind >(val2);
46497 {
46498 PyThreadState* __tstate = wxPyBeginAllowThreads();
46499 (arg1)->SetKind(arg2);
46500 wxPyEndAllowThreads(__tstate);
46501 if (PyErr_Occurred()) SWIG_fail;
46502 }
46503 resultobj = SWIG_Py_Void();
46504 return resultobj;
46505 fail:
46506 return NULL;
46507 }
46508
46509
46510 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46511 PyObject *resultobj = 0;
46512 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46513 bool arg2 ;
46514 void *argp1 = 0 ;
46515 int res1 = 0 ;
46516 bool val2 ;
46517 int ecode2 = 0 ;
46518 PyObject * obj0 = 0 ;
46519 PyObject * obj1 = 0 ;
46520 char * kwnames[] = {
46521 (char *) "self",(char *) "checkable", NULL
46522 };
46523
46524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46526 if (!SWIG_IsOK(res1)) {
46527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46528 }
46529 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46530 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46531 if (!SWIG_IsOK(ecode2)) {
46532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46533 }
46534 arg2 = static_cast< bool >(val2);
46535 {
46536 PyThreadState* __tstate = wxPyBeginAllowThreads();
46537 (arg1)->SetCheckable(arg2);
46538 wxPyEndAllowThreads(__tstate);
46539 if (PyErr_Occurred()) SWIG_fail;
46540 }
46541 resultobj = SWIG_Py_Void();
46542 return resultobj;
46543 fail:
46544 return NULL;
46545 }
46546
46547
46548 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46549 PyObject *resultobj = 0;
46550 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46551 bool result;
46552 void *argp1 = 0 ;
46553 int res1 = 0 ;
46554 PyObject *swig_obj[1] ;
46555
46556 if (!args) SWIG_fail;
46557 swig_obj[0] = args;
46558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46559 if (!SWIG_IsOK(res1)) {
46560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46561 }
46562 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46563 {
46564 PyThreadState* __tstate = wxPyBeginAllowThreads();
46565 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46566 wxPyEndAllowThreads(__tstate);
46567 if (PyErr_Occurred()) SWIG_fail;
46568 }
46569 {
46570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46571 }
46572 return resultobj;
46573 fail:
46574 return NULL;
46575 }
46576
46577
46578 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46579 PyObject *resultobj = 0;
46580 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46581 bool result;
46582 void *argp1 = 0 ;
46583 int res1 = 0 ;
46584 PyObject *swig_obj[1] ;
46585
46586 if (!args) SWIG_fail;
46587 swig_obj[0] = args;
46588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46589 if (!SWIG_IsOK(res1)) {
46590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46591 }
46592 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46593 {
46594 PyThreadState* __tstate = wxPyBeginAllowThreads();
46595 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46596 wxPyEndAllowThreads(__tstate);
46597 if (PyErr_Occurred()) SWIG_fail;
46598 }
46599 {
46600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46601 }
46602 return resultobj;
46603 fail:
46604 return NULL;
46605 }
46606
46607
46608 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46609 PyObject *resultobj = 0;
46610 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46611 wxMenu *arg2 = (wxMenu *) 0 ;
46612 void *argp1 = 0 ;
46613 int res1 = 0 ;
46614 void *argp2 = 0 ;
46615 int res2 = 0 ;
46616 PyObject * obj0 = 0 ;
46617 PyObject * obj1 = 0 ;
46618 char * kwnames[] = {
46619 (char *) "self",(char *) "menu", NULL
46620 };
46621
46622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46624 if (!SWIG_IsOK(res1)) {
46625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46626 }
46627 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46628 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46629 if (!SWIG_IsOK(res2)) {
46630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46631 }
46632 arg2 = reinterpret_cast< wxMenu * >(argp2);
46633 {
46634 PyThreadState* __tstate = wxPyBeginAllowThreads();
46635 (arg1)->SetSubMenu(arg2);
46636 wxPyEndAllowThreads(__tstate);
46637 if (PyErr_Occurred()) SWIG_fail;
46638 }
46639 resultobj = SWIG_Py_Void();
46640 return resultobj;
46641 fail:
46642 return NULL;
46643 }
46644
46645
46646 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46647 PyObject *resultobj = 0;
46648 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46649 wxMenu *result = 0 ;
46650 void *argp1 = 0 ;
46651 int res1 = 0 ;
46652 PyObject *swig_obj[1] ;
46653
46654 if (!args) SWIG_fail;
46655 swig_obj[0] = args;
46656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46657 if (!SWIG_IsOK(res1)) {
46658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46659 }
46660 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46661 {
46662 PyThreadState* __tstate = wxPyBeginAllowThreads();
46663 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46664 wxPyEndAllowThreads(__tstate);
46665 if (PyErr_Occurred()) SWIG_fail;
46666 }
46667 {
46668 resultobj = wxPyMake_wxObject(result, 0);
46669 }
46670 return resultobj;
46671 fail:
46672 return NULL;
46673 }
46674
46675
46676 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46677 PyObject *resultobj = 0;
46678 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46679 bool arg2 = (bool) true ;
46680 void *argp1 = 0 ;
46681 int res1 = 0 ;
46682 bool val2 ;
46683 int ecode2 = 0 ;
46684 PyObject * obj0 = 0 ;
46685 PyObject * obj1 = 0 ;
46686 char * kwnames[] = {
46687 (char *) "self",(char *) "enable", NULL
46688 };
46689
46690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46692 if (!SWIG_IsOK(res1)) {
46693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46694 }
46695 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46696 if (obj1) {
46697 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46698 if (!SWIG_IsOK(ecode2)) {
46699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46700 }
46701 arg2 = static_cast< bool >(val2);
46702 }
46703 {
46704 PyThreadState* __tstate = wxPyBeginAllowThreads();
46705 (arg1)->Enable(arg2);
46706 wxPyEndAllowThreads(__tstate);
46707 if (PyErr_Occurred()) SWIG_fail;
46708 }
46709 resultobj = SWIG_Py_Void();
46710 return resultobj;
46711 fail:
46712 return NULL;
46713 }
46714
46715
46716 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46717 PyObject *resultobj = 0;
46718 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46719 bool result;
46720 void *argp1 = 0 ;
46721 int res1 = 0 ;
46722 PyObject *swig_obj[1] ;
46723
46724 if (!args) SWIG_fail;
46725 swig_obj[0] = args;
46726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46727 if (!SWIG_IsOK(res1)) {
46728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46729 }
46730 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46731 {
46732 PyThreadState* __tstate = wxPyBeginAllowThreads();
46733 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46734 wxPyEndAllowThreads(__tstate);
46735 if (PyErr_Occurred()) SWIG_fail;
46736 }
46737 {
46738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46739 }
46740 return resultobj;
46741 fail:
46742 return NULL;
46743 }
46744
46745
46746 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46747 PyObject *resultobj = 0;
46748 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46749 bool arg2 = (bool) true ;
46750 void *argp1 = 0 ;
46751 int res1 = 0 ;
46752 bool val2 ;
46753 int ecode2 = 0 ;
46754 PyObject * obj0 = 0 ;
46755 PyObject * obj1 = 0 ;
46756 char * kwnames[] = {
46757 (char *) "self",(char *) "check", NULL
46758 };
46759
46760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46762 if (!SWIG_IsOK(res1)) {
46763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46764 }
46765 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46766 if (obj1) {
46767 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46768 if (!SWIG_IsOK(ecode2)) {
46769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46770 }
46771 arg2 = static_cast< bool >(val2);
46772 }
46773 {
46774 PyThreadState* __tstate = wxPyBeginAllowThreads();
46775 (arg1)->Check(arg2);
46776 wxPyEndAllowThreads(__tstate);
46777 if (PyErr_Occurred()) SWIG_fail;
46778 }
46779 resultobj = SWIG_Py_Void();
46780 return resultobj;
46781 fail:
46782 return NULL;
46783 }
46784
46785
46786 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46787 PyObject *resultobj = 0;
46788 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46789 bool result;
46790 void *argp1 = 0 ;
46791 int res1 = 0 ;
46792 PyObject *swig_obj[1] ;
46793
46794 if (!args) SWIG_fail;
46795 swig_obj[0] = args;
46796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46797 if (!SWIG_IsOK(res1)) {
46798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46799 }
46800 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46801 {
46802 PyThreadState* __tstate = wxPyBeginAllowThreads();
46803 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46804 wxPyEndAllowThreads(__tstate);
46805 if (PyErr_Occurred()) SWIG_fail;
46806 }
46807 {
46808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46809 }
46810 return resultobj;
46811 fail:
46812 return NULL;
46813 }
46814
46815
46816 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46817 PyObject *resultobj = 0;
46818 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46819 void *argp1 = 0 ;
46820 int res1 = 0 ;
46821 PyObject *swig_obj[1] ;
46822
46823 if (!args) SWIG_fail;
46824 swig_obj[0] = args;
46825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46826 if (!SWIG_IsOK(res1)) {
46827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46828 }
46829 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46830 {
46831 PyThreadState* __tstate = wxPyBeginAllowThreads();
46832 (arg1)->Toggle();
46833 wxPyEndAllowThreads(__tstate);
46834 if (PyErr_Occurred()) SWIG_fail;
46835 }
46836 resultobj = SWIG_Py_Void();
46837 return resultobj;
46838 fail:
46839 return NULL;
46840 }
46841
46842
46843 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46844 PyObject *resultobj = 0;
46845 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46846 wxString *arg2 = 0 ;
46847 void *argp1 = 0 ;
46848 int res1 = 0 ;
46849 bool temp2 = false ;
46850 PyObject * obj0 = 0 ;
46851 PyObject * obj1 = 0 ;
46852 char * kwnames[] = {
46853 (char *) "self",(char *) "str", NULL
46854 };
46855
46856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46858 if (!SWIG_IsOK(res1)) {
46859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46860 }
46861 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46862 {
46863 arg2 = wxString_in_helper(obj1);
46864 if (arg2 == NULL) SWIG_fail;
46865 temp2 = true;
46866 }
46867 {
46868 PyThreadState* __tstate = wxPyBeginAllowThreads();
46869 (arg1)->SetHelp((wxString const &)*arg2);
46870 wxPyEndAllowThreads(__tstate);
46871 if (PyErr_Occurred()) SWIG_fail;
46872 }
46873 resultobj = SWIG_Py_Void();
46874 {
46875 if (temp2)
46876 delete arg2;
46877 }
46878 return resultobj;
46879 fail:
46880 {
46881 if (temp2)
46882 delete arg2;
46883 }
46884 return NULL;
46885 }
46886
46887
46888 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46889 PyObject *resultobj = 0;
46890 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46891 wxString *result = 0 ;
46892 void *argp1 = 0 ;
46893 int res1 = 0 ;
46894 PyObject *swig_obj[1] ;
46895
46896 if (!args) SWIG_fail;
46897 swig_obj[0] = args;
46898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46899 if (!SWIG_IsOK(res1)) {
46900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46901 }
46902 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46903 {
46904 PyThreadState* __tstate = wxPyBeginAllowThreads();
46905 {
46906 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46907 result = (wxString *) &_result_ref;
46908 }
46909 wxPyEndAllowThreads(__tstate);
46910 if (PyErr_Occurred()) SWIG_fail;
46911 }
46912 {
46913 #if wxUSE_UNICODE
46914 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46915 #else
46916 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46917 #endif
46918 }
46919 return resultobj;
46920 fail:
46921 return NULL;
46922 }
46923
46924
46925 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46926 PyObject *resultobj = 0;
46927 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46928 wxAcceleratorEntry *result = 0 ;
46929 void *argp1 = 0 ;
46930 int res1 = 0 ;
46931 PyObject *swig_obj[1] ;
46932
46933 if (!args) SWIG_fail;
46934 swig_obj[0] = args;
46935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46936 if (!SWIG_IsOK(res1)) {
46937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46938 }
46939 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46940 {
46941 PyThreadState* __tstate = wxPyBeginAllowThreads();
46942 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46943 wxPyEndAllowThreads(__tstate);
46944 if (PyErr_Occurred()) SWIG_fail;
46945 }
46946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46947 return resultobj;
46948 fail:
46949 return NULL;
46950 }
46951
46952
46953 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46954 PyObject *resultobj = 0;
46955 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46956 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46957 void *argp1 = 0 ;
46958 int res1 = 0 ;
46959 void *argp2 = 0 ;
46960 int res2 = 0 ;
46961 PyObject * obj0 = 0 ;
46962 PyObject * obj1 = 0 ;
46963 char * kwnames[] = {
46964 (char *) "self",(char *) "accel", NULL
46965 };
46966
46967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46969 if (!SWIG_IsOK(res1)) {
46970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46971 }
46972 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46973 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46974 if (!SWIG_IsOK(res2)) {
46975 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46976 }
46977 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46978 {
46979 PyThreadState* __tstate = wxPyBeginAllowThreads();
46980 (arg1)->SetAccel(arg2);
46981 wxPyEndAllowThreads(__tstate);
46982 if (PyErr_Occurred()) SWIG_fail;
46983 }
46984 resultobj = SWIG_Py_Void();
46985 return resultobj;
46986 fail:
46987 return NULL;
46988 }
46989
46990
46991 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46992 PyObject *resultobj = 0;
46993 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46994 wxBitmap *arg2 = 0 ;
46995 void *argp1 = 0 ;
46996 int res1 = 0 ;
46997 void *argp2 = 0 ;
46998 int res2 = 0 ;
46999 PyObject * obj0 = 0 ;
47000 PyObject * obj1 = 0 ;
47001 char * kwnames[] = {
47002 (char *) "self",(char *) "bitmap", NULL
47003 };
47004
47005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47007 if (!SWIG_IsOK(res1)) {
47008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47009 }
47010 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47011 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47012 if (!SWIG_IsOK(res2)) {
47013 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47014 }
47015 if (!argp2) {
47016 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47017 }
47018 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47019 {
47020 PyThreadState* __tstate = wxPyBeginAllowThreads();
47021 (arg1)->SetBitmap((wxBitmap const &)*arg2);
47022 wxPyEndAllowThreads(__tstate);
47023 if (PyErr_Occurred()) SWIG_fail;
47024 }
47025 resultobj = SWIG_Py_Void();
47026 return resultobj;
47027 fail:
47028 return NULL;
47029 }
47030
47031
47032 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47033 PyObject *resultobj = 0;
47034 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47035 wxBitmap *result = 0 ;
47036 void *argp1 = 0 ;
47037 int res1 = 0 ;
47038 PyObject *swig_obj[1] ;
47039
47040 if (!args) SWIG_fail;
47041 swig_obj[0] = args;
47042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47043 if (!SWIG_IsOK(res1)) {
47044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47045 }
47046 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47047 {
47048 PyThreadState* __tstate = wxPyBeginAllowThreads();
47049 {
47050 wxBitmap const &_result_ref = (arg1)->GetBitmap();
47051 result = (wxBitmap *) &_result_ref;
47052 }
47053 wxPyEndAllowThreads(__tstate);
47054 if (PyErr_Occurred()) SWIG_fail;
47055 }
47056 {
47057 wxBitmap* resultptr = new wxBitmap(*result);
47058 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47059 }
47060 return resultobj;
47061 fail:
47062 return NULL;
47063 }
47064
47065
47066 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47067 PyObject *resultobj = 0;
47068 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47069 wxFont *arg2 = 0 ;
47070 void *argp1 = 0 ;
47071 int res1 = 0 ;
47072 void *argp2 = 0 ;
47073 int res2 = 0 ;
47074 PyObject * obj0 = 0 ;
47075 PyObject * obj1 = 0 ;
47076 char * kwnames[] = {
47077 (char *) "self",(char *) "font", NULL
47078 };
47079
47080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
47081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47082 if (!SWIG_IsOK(res1)) {
47083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47084 }
47085 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47086 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
47087 if (!SWIG_IsOK(res2)) {
47088 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47089 }
47090 if (!argp2) {
47091 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47092 }
47093 arg2 = reinterpret_cast< wxFont * >(argp2);
47094 {
47095 PyThreadState* __tstate = wxPyBeginAllowThreads();
47096 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
47097 wxPyEndAllowThreads(__tstate);
47098 if (PyErr_Occurred()) SWIG_fail;
47099 }
47100 resultobj = SWIG_Py_Void();
47101 return resultobj;
47102 fail:
47103 return NULL;
47104 }
47105
47106
47107 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47108 PyObject *resultobj = 0;
47109 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47110 wxFont result;
47111 void *argp1 = 0 ;
47112 int res1 = 0 ;
47113 PyObject *swig_obj[1] ;
47114
47115 if (!args) SWIG_fail;
47116 swig_obj[0] = args;
47117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47118 if (!SWIG_IsOK(res1)) {
47119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47120 }
47121 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47122 {
47123 PyThreadState* __tstate = wxPyBeginAllowThreads();
47124 result = wxMenuItem_GetFont(arg1);
47125 wxPyEndAllowThreads(__tstate);
47126 if (PyErr_Occurred()) SWIG_fail;
47127 }
47128 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
47129 return resultobj;
47130 fail:
47131 return NULL;
47132 }
47133
47134
47135 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47136 PyObject *resultobj = 0;
47137 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47138 wxColour *arg2 = 0 ;
47139 void *argp1 = 0 ;
47140 int res1 = 0 ;
47141 wxColour temp2 ;
47142 PyObject * obj0 = 0 ;
47143 PyObject * obj1 = 0 ;
47144 char * kwnames[] = {
47145 (char *) "self",(char *) "colText", NULL
47146 };
47147
47148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
47149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47150 if (!SWIG_IsOK(res1)) {
47151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47152 }
47153 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47154 {
47155 arg2 = &temp2;
47156 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47157 }
47158 {
47159 PyThreadState* __tstate = wxPyBeginAllowThreads();
47160 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
47161 wxPyEndAllowThreads(__tstate);
47162 if (PyErr_Occurred()) SWIG_fail;
47163 }
47164 resultobj = SWIG_Py_Void();
47165 return resultobj;
47166 fail:
47167 return NULL;
47168 }
47169
47170
47171 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47172 PyObject *resultobj = 0;
47173 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47174 wxColour result;
47175 void *argp1 = 0 ;
47176 int res1 = 0 ;
47177 PyObject *swig_obj[1] ;
47178
47179 if (!args) SWIG_fail;
47180 swig_obj[0] = args;
47181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47182 if (!SWIG_IsOK(res1)) {
47183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47184 }
47185 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47186 {
47187 PyThreadState* __tstate = wxPyBeginAllowThreads();
47188 result = wxMenuItem_GetTextColour(arg1);
47189 wxPyEndAllowThreads(__tstate);
47190 if (PyErr_Occurred()) SWIG_fail;
47191 }
47192 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47193 return resultobj;
47194 fail:
47195 return NULL;
47196 }
47197
47198
47199 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47200 PyObject *resultobj = 0;
47201 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47202 wxColour *arg2 = 0 ;
47203 void *argp1 = 0 ;
47204 int res1 = 0 ;
47205 wxColour temp2 ;
47206 PyObject * obj0 = 0 ;
47207 PyObject * obj1 = 0 ;
47208 char * kwnames[] = {
47209 (char *) "self",(char *) "colBack", NULL
47210 };
47211
47212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
47213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47214 if (!SWIG_IsOK(res1)) {
47215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47216 }
47217 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47218 {
47219 arg2 = &temp2;
47220 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47221 }
47222 {
47223 PyThreadState* __tstate = wxPyBeginAllowThreads();
47224 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
47225 wxPyEndAllowThreads(__tstate);
47226 if (PyErr_Occurred()) SWIG_fail;
47227 }
47228 resultobj = SWIG_Py_Void();
47229 return resultobj;
47230 fail:
47231 return NULL;
47232 }
47233
47234
47235 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47236 PyObject *resultobj = 0;
47237 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47238 wxColour result;
47239 void *argp1 = 0 ;
47240 int res1 = 0 ;
47241 PyObject *swig_obj[1] ;
47242
47243 if (!args) SWIG_fail;
47244 swig_obj[0] = args;
47245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47246 if (!SWIG_IsOK(res1)) {
47247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47248 }
47249 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47250 {
47251 PyThreadState* __tstate = wxPyBeginAllowThreads();
47252 result = wxMenuItem_GetBackgroundColour(arg1);
47253 wxPyEndAllowThreads(__tstate);
47254 if (PyErr_Occurred()) SWIG_fail;
47255 }
47256 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47257 return resultobj;
47258 fail:
47259 return NULL;
47260 }
47261
47262
47263 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47264 PyObject *resultobj = 0;
47265 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47266 wxBitmap *arg2 = 0 ;
47267 wxBitmap const &arg3_defvalue = wxNullBitmap ;
47268 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
47269 void *argp1 = 0 ;
47270 int res1 = 0 ;
47271 void *argp2 = 0 ;
47272 int res2 = 0 ;
47273 void *argp3 = 0 ;
47274 int res3 = 0 ;
47275 PyObject * obj0 = 0 ;
47276 PyObject * obj1 = 0 ;
47277 PyObject * obj2 = 0 ;
47278 char * kwnames[] = {
47279 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
47280 };
47281
47282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47284 if (!SWIG_IsOK(res1)) {
47285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47286 }
47287 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47288 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47289 if (!SWIG_IsOK(res2)) {
47290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47291 }
47292 if (!argp2) {
47293 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47294 }
47295 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47296 if (obj2) {
47297 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
47298 if (!SWIG_IsOK(res3)) {
47299 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47300 }
47301 if (!argp3) {
47302 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47303 }
47304 arg3 = reinterpret_cast< wxBitmap * >(argp3);
47305 }
47306 {
47307 PyThreadState* __tstate = wxPyBeginAllowThreads();
47308 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
47309 wxPyEndAllowThreads(__tstate);
47310 if (PyErr_Occurred()) SWIG_fail;
47311 }
47312 resultobj = SWIG_Py_Void();
47313 return resultobj;
47314 fail:
47315 return NULL;
47316 }
47317
47318
47319 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47320 PyObject *resultobj = 0;
47321 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47322 wxBitmap *arg2 = 0 ;
47323 void *argp1 = 0 ;
47324 int res1 = 0 ;
47325 void *argp2 = 0 ;
47326 int res2 = 0 ;
47327 PyObject * obj0 = 0 ;
47328 PyObject * obj1 = 0 ;
47329 char * kwnames[] = {
47330 (char *) "self",(char *) "bmpDisabled", NULL
47331 };
47332
47333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47335 if (!SWIG_IsOK(res1)) {
47336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47337 }
47338 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47339 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47340 if (!SWIG_IsOK(res2)) {
47341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47342 }
47343 if (!argp2) {
47344 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47345 }
47346 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47347 {
47348 PyThreadState* __tstate = wxPyBeginAllowThreads();
47349 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
47350 wxPyEndAllowThreads(__tstate);
47351 if (PyErr_Occurred()) SWIG_fail;
47352 }
47353 resultobj = SWIG_Py_Void();
47354 return resultobj;
47355 fail:
47356 return NULL;
47357 }
47358
47359
47360 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47361 PyObject *resultobj = 0;
47362 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47363 wxBitmap *result = 0 ;
47364 void *argp1 = 0 ;
47365 int res1 = 0 ;
47366 PyObject *swig_obj[1] ;
47367
47368 if (!args) SWIG_fail;
47369 swig_obj[0] = args;
47370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47371 if (!SWIG_IsOK(res1)) {
47372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47373 }
47374 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47375 {
47376 PyThreadState* __tstate = wxPyBeginAllowThreads();
47377 {
47378 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
47379 result = (wxBitmap *) &_result_ref;
47380 }
47381 wxPyEndAllowThreads(__tstate);
47382 if (PyErr_Occurred()) SWIG_fail;
47383 }
47384 {
47385 wxBitmap* resultptr = new wxBitmap(*result);
47386 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47387 }
47388 return resultobj;
47389 fail:
47390 return NULL;
47391 }
47392
47393
47394 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47395 PyObject *resultobj = 0;
47396 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47397 int arg2 ;
47398 void *argp1 = 0 ;
47399 int res1 = 0 ;
47400 int val2 ;
47401 int ecode2 = 0 ;
47402 PyObject * obj0 = 0 ;
47403 PyObject * obj1 = 0 ;
47404 char * kwnames[] = {
47405 (char *) "self",(char *) "nWidth", NULL
47406 };
47407
47408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47410 if (!SWIG_IsOK(res1)) {
47411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47412 }
47413 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47414 ecode2 = SWIG_AsVal_int(obj1, &val2);
47415 if (!SWIG_IsOK(ecode2)) {
47416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47417 }
47418 arg2 = static_cast< int >(val2);
47419 {
47420 PyThreadState* __tstate = wxPyBeginAllowThreads();
47421 wxMenuItem_SetMarginWidth(arg1,arg2);
47422 wxPyEndAllowThreads(__tstate);
47423 if (PyErr_Occurred()) SWIG_fail;
47424 }
47425 resultobj = SWIG_Py_Void();
47426 return resultobj;
47427 fail:
47428 return NULL;
47429 }
47430
47431
47432 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47433 PyObject *resultobj = 0;
47434 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47435 int result;
47436 void *argp1 = 0 ;
47437 int res1 = 0 ;
47438 PyObject *swig_obj[1] ;
47439
47440 if (!args) SWIG_fail;
47441 swig_obj[0] = args;
47442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47443 if (!SWIG_IsOK(res1)) {
47444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47445 }
47446 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47447 {
47448 PyThreadState* __tstate = wxPyBeginAllowThreads();
47449 result = (int)wxMenuItem_GetMarginWidth(arg1);
47450 wxPyEndAllowThreads(__tstate);
47451 if (PyErr_Occurred()) SWIG_fail;
47452 }
47453 resultobj = SWIG_From_int(static_cast< int >(result));
47454 return resultobj;
47455 fail:
47456 return NULL;
47457 }
47458
47459
47460 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47461 PyObject *resultobj = 0;
47462 int result;
47463
47464 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47465 {
47466 PyThreadState* __tstate = wxPyBeginAllowThreads();
47467 result = (int)wxMenuItem_GetDefaultMarginWidth();
47468 wxPyEndAllowThreads(__tstate);
47469 if (PyErr_Occurred()) SWIG_fail;
47470 }
47471 resultobj = SWIG_From_int(static_cast< int >(result));
47472 return resultobj;
47473 fail:
47474 return NULL;
47475 }
47476
47477
47478 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47479 PyObject *resultobj = 0;
47480 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47481 bool result;
47482 void *argp1 = 0 ;
47483 int res1 = 0 ;
47484 PyObject *swig_obj[1] ;
47485
47486 if (!args) SWIG_fail;
47487 swig_obj[0] = args;
47488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47489 if (!SWIG_IsOK(res1)) {
47490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47491 }
47492 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47493 {
47494 PyThreadState* __tstate = wxPyBeginAllowThreads();
47495 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47496 wxPyEndAllowThreads(__tstate);
47497 if (PyErr_Occurred()) SWIG_fail;
47498 }
47499 {
47500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47501 }
47502 return resultobj;
47503 fail:
47504 return NULL;
47505 }
47506
47507
47508 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47509 PyObject *resultobj = 0;
47510 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47511 bool arg2 = (bool) true ;
47512 void *argp1 = 0 ;
47513 int res1 = 0 ;
47514 bool val2 ;
47515 int ecode2 = 0 ;
47516 PyObject * obj0 = 0 ;
47517 PyObject * obj1 = 0 ;
47518 char * kwnames[] = {
47519 (char *) "self",(char *) "ownerDrawn", NULL
47520 };
47521
47522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47524 if (!SWIG_IsOK(res1)) {
47525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47526 }
47527 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47528 if (obj1) {
47529 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47530 if (!SWIG_IsOK(ecode2)) {
47531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47532 }
47533 arg2 = static_cast< bool >(val2);
47534 }
47535 {
47536 PyThreadState* __tstate = wxPyBeginAllowThreads();
47537 wxMenuItem_SetOwnerDrawn(arg1,arg2);
47538 wxPyEndAllowThreads(__tstate);
47539 if (PyErr_Occurred()) SWIG_fail;
47540 }
47541 resultobj = SWIG_Py_Void();
47542 return resultobj;
47543 fail:
47544 return NULL;
47545 }
47546
47547
47548 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47549 PyObject *resultobj = 0;
47550 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47551 void *argp1 = 0 ;
47552 int res1 = 0 ;
47553 PyObject *swig_obj[1] ;
47554
47555 if (!args) SWIG_fail;
47556 swig_obj[0] = args;
47557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47558 if (!SWIG_IsOK(res1)) {
47559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47560 }
47561 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47562 {
47563 PyThreadState* __tstate = wxPyBeginAllowThreads();
47564 wxMenuItem_ResetOwnerDrawn(arg1);
47565 wxPyEndAllowThreads(__tstate);
47566 if (PyErr_Occurred()) SWIG_fail;
47567 }
47568 resultobj = SWIG_Py_Void();
47569 return resultobj;
47570 fail:
47571 return NULL;
47572 }
47573
47574
47575 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47576 PyObject *obj;
47577 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47578 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47579 return SWIG_Py_Void();
47580 }
47581
47582 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47583 return SWIG_Python_InitShadowInstance(args);
47584 }
47585
47586 SWIGINTERN int ControlNameStr_set(PyObject *) {
47587 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47588 return 1;
47589 }
47590
47591
47592 SWIGINTERN PyObject *ControlNameStr_get(void) {
47593 PyObject *pyobj = 0;
47594
47595 {
47596 #if wxUSE_UNICODE
47597 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47598 #else
47599 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47600 #endif
47601 }
47602 return pyobj;
47603 }
47604
47605
47606 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47607 PyObject *resultobj = 0;
47608 wxWindow *arg1 = (wxWindow *) 0 ;
47609 int arg2 = (int) -1 ;
47610 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47611 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47612 wxSize const &arg4_defvalue = wxDefaultSize ;
47613 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47614 long arg5 = (long) 0 ;
47615 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47616 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47617 wxString const &arg7_defvalue = wxPyControlNameStr ;
47618 wxString *arg7 = (wxString *) &arg7_defvalue ;
47619 wxControl *result = 0 ;
47620 void *argp1 = 0 ;
47621 int res1 = 0 ;
47622 int val2 ;
47623 int ecode2 = 0 ;
47624 wxPoint temp3 ;
47625 wxSize temp4 ;
47626 long val5 ;
47627 int ecode5 = 0 ;
47628 void *argp6 = 0 ;
47629 int res6 = 0 ;
47630 bool temp7 = false ;
47631 PyObject * obj0 = 0 ;
47632 PyObject * obj1 = 0 ;
47633 PyObject * obj2 = 0 ;
47634 PyObject * obj3 = 0 ;
47635 PyObject * obj4 = 0 ;
47636 PyObject * obj5 = 0 ;
47637 PyObject * obj6 = 0 ;
47638 char * kwnames[] = {
47639 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47640 };
47641
47642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47644 if (!SWIG_IsOK(res1)) {
47645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47646 }
47647 arg1 = reinterpret_cast< wxWindow * >(argp1);
47648 if (obj1) {
47649 ecode2 = SWIG_AsVal_int(obj1, &val2);
47650 if (!SWIG_IsOK(ecode2)) {
47651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47652 }
47653 arg2 = static_cast< int >(val2);
47654 }
47655 if (obj2) {
47656 {
47657 arg3 = &temp3;
47658 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47659 }
47660 }
47661 if (obj3) {
47662 {
47663 arg4 = &temp4;
47664 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47665 }
47666 }
47667 if (obj4) {
47668 ecode5 = SWIG_AsVal_long(obj4, &val5);
47669 if (!SWIG_IsOK(ecode5)) {
47670 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47671 }
47672 arg5 = static_cast< long >(val5);
47673 }
47674 if (obj5) {
47675 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47676 if (!SWIG_IsOK(res6)) {
47677 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47678 }
47679 if (!argp6) {
47680 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47681 }
47682 arg6 = reinterpret_cast< wxValidator * >(argp6);
47683 }
47684 if (obj6) {
47685 {
47686 arg7 = wxString_in_helper(obj6);
47687 if (arg7 == NULL) SWIG_fail;
47688 temp7 = true;
47689 }
47690 }
47691 {
47692 if (!wxPyCheckForApp()) SWIG_fail;
47693 PyThreadState* __tstate = wxPyBeginAllowThreads();
47694 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47695 wxPyEndAllowThreads(__tstate);
47696 if (PyErr_Occurred()) SWIG_fail;
47697 }
47698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47699 {
47700 if (temp7)
47701 delete arg7;
47702 }
47703 return resultobj;
47704 fail:
47705 {
47706 if (temp7)
47707 delete arg7;
47708 }
47709 return NULL;
47710 }
47711
47712
47713 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47714 PyObject *resultobj = 0;
47715 wxControl *result = 0 ;
47716
47717 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47718 {
47719 if (!wxPyCheckForApp()) SWIG_fail;
47720 PyThreadState* __tstate = wxPyBeginAllowThreads();
47721 result = (wxControl *)new wxControl();
47722 wxPyEndAllowThreads(__tstate);
47723 if (PyErr_Occurred()) SWIG_fail;
47724 }
47725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47726 return resultobj;
47727 fail:
47728 return NULL;
47729 }
47730
47731
47732 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47733 PyObject *resultobj = 0;
47734 wxControl *arg1 = (wxControl *) 0 ;
47735 wxWindow *arg2 = (wxWindow *) 0 ;
47736 int arg3 = (int) -1 ;
47737 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47738 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47739 wxSize const &arg5_defvalue = wxDefaultSize ;
47740 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47741 long arg6 = (long) 0 ;
47742 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47743 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47744 wxString const &arg8_defvalue = wxPyControlNameStr ;
47745 wxString *arg8 = (wxString *) &arg8_defvalue ;
47746 bool result;
47747 void *argp1 = 0 ;
47748 int res1 = 0 ;
47749 void *argp2 = 0 ;
47750 int res2 = 0 ;
47751 int val3 ;
47752 int ecode3 = 0 ;
47753 wxPoint temp4 ;
47754 wxSize temp5 ;
47755 long val6 ;
47756 int ecode6 = 0 ;
47757 void *argp7 = 0 ;
47758 int res7 = 0 ;
47759 bool temp8 = false ;
47760 PyObject * obj0 = 0 ;
47761 PyObject * obj1 = 0 ;
47762 PyObject * obj2 = 0 ;
47763 PyObject * obj3 = 0 ;
47764 PyObject * obj4 = 0 ;
47765 PyObject * obj5 = 0 ;
47766 PyObject * obj6 = 0 ;
47767 PyObject * obj7 = 0 ;
47768 char * kwnames[] = {
47769 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47770 };
47771
47772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47774 if (!SWIG_IsOK(res1)) {
47775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47776 }
47777 arg1 = reinterpret_cast< wxControl * >(argp1);
47778 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47779 if (!SWIG_IsOK(res2)) {
47780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47781 }
47782 arg2 = reinterpret_cast< wxWindow * >(argp2);
47783 if (obj2) {
47784 ecode3 = SWIG_AsVal_int(obj2, &val3);
47785 if (!SWIG_IsOK(ecode3)) {
47786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47787 }
47788 arg3 = static_cast< int >(val3);
47789 }
47790 if (obj3) {
47791 {
47792 arg4 = &temp4;
47793 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47794 }
47795 }
47796 if (obj4) {
47797 {
47798 arg5 = &temp5;
47799 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47800 }
47801 }
47802 if (obj5) {
47803 ecode6 = SWIG_AsVal_long(obj5, &val6);
47804 if (!SWIG_IsOK(ecode6)) {
47805 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47806 }
47807 arg6 = static_cast< long >(val6);
47808 }
47809 if (obj6) {
47810 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47811 if (!SWIG_IsOK(res7)) {
47812 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47813 }
47814 if (!argp7) {
47815 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47816 }
47817 arg7 = reinterpret_cast< wxValidator * >(argp7);
47818 }
47819 if (obj7) {
47820 {
47821 arg8 = wxString_in_helper(obj7);
47822 if (arg8 == NULL) SWIG_fail;
47823 temp8 = true;
47824 }
47825 }
47826 {
47827 PyThreadState* __tstate = wxPyBeginAllowThreads();
47828 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47829 wxPyEndAllowThreads(__tstate);
47830 if (PyErr_Occurred()) SWIG_fail;
47831 }
47832 {
47833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47834 }
47835 {
47836 if (temp8)
47837 delete arg8;
47838 }
47839 return resultobj;
47840 fail:
47841 {
47842 if (temp8)
47843 delete arg8;
47844 }
47845 return NULL;
47846 }
47847
47848
47849 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47850 PyObject *resultobj = 0;
47851 wxControl *arg1 = (wxControl *) 0 ;
47852 int result;
47853 void *argp1 = 0 ;
47854 int res1 = 0 ;
47855 PyObject *swig_obj[1] ;
47856
47857 if (!args) SWIG_fail;
47858 swig_obj[0] = args;
47859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47860 if (!SWIG_IsOK(res1)) {
47861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47862 }
47863 arg1 = reinterpret_cast< wxControl * >(argp1);
47864 {
47865 PyThreadState* __tstate = wxPyBeginAllowThreads();
47866 result = (int)((wxControl const *)arg1)->GetAlignment();
47867 wxPyEndAllowThreads(__tstate);
47868 if (PyErr_Occurred()) SWIG_fail;
47869 }
47870 resultobj = SWIG_From_int(static_cast< int >(result));
47871 return resultobj;
47872 fail:
47873 return NULL;
47874 }
47875
47876
47877 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47878 PyObject *resultobj = 0;
47879 wxControl *arg1 = (wxControl *) 0 ;
47880 wxString result;
47881 void *argp1 = 0 ;
47882 int res1 = 0 ;
47883 PyObject *swig_obj[1] ;
47884
47885 if (!args) SWIG_fail;
47886 swig_obj[0] = args;
47887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47888 if (!SWIG_IsOK(res1)) {
47889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47890 }
47891 arg1 = reinterpret_cast< wxControl * >(argp1);
47892 {
47893 PyThreadState* __tstate = wxPyBeginAllowThreads();
47894 result = ((wxControl const *)arg1)->GetLabelText();
47895 wxPyEndAllowThreads(__tstate);
47896 if (PyErr_Occurred()) SWIG_fail;
47897 }
47898 {
47899 #if wxUSE_UNICODE
47900 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47901 #else
47902 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47903 #endif
47904 }
47905 return resultobj;
47906 fail:
47907 return NULL;
47908 }
47909
47910
47911 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47912 PyObject *resultobj = 0;
47913 wxControl *arg1 = (wxControl *) 0 ;
47914 wxCommandEvent *arg2 = 0 ;
47915 void *argp1 = 0 ;
47916 int res1 = 0 ;
47917 void *argp2 = 0 ;
47918 int res2 = 0 ;
47919 PyObject * obj0 = 0 ;
47920 PyObject * obj1 = 0 ;
47921 char * kwnames[] = {
47922 (char *) "self",(char *) "event", NULL
47923 };
47924
47925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47927 if (!SWIG_IsOK(res1)) {
47928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47929 }
47930 arg1 = reinterpret_cast< wxControl * >(argp1);
47931 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47932 if (!SWIG_IsOK(res2)) {
47933 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47934 }
47935 if (!argp2) {
47936 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47937 }
47938 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47939 {
47940 PyThreadState* __tstate = wxPyBeginAllowThreads();
47941 (arg1)->Command(*arg2);
47942 wxPyEndAllowThreads(__tstate);
47943 if (PyErr_Occurred()) SWIG_fail;
47944 }
47945 resultobj = SWIG_Py_Void();
47946 return resultobj;
47947 fail:
47948 return NULL;
47949 }
47950
47951
47952 SWIGINTERN PyObject *_wrap_Control_RemoveMnemonics(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47953 PyObject *resultobj = 0;
47954 wxString *arg1 = 0 ;
47955 wxString result;
47956 bool temp1 = false ;
47957 PyObject * obj0 = 0 ;
47958 char * kwnames[] = {
47959 (char *) "str", NULL
47960 };
47961
47962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_RemoveMnemonics",kwnames,&obj0)) SWIG_fail;
47963 {
47964 arg1 = wxString_in_helper(obj0);
47965 if (arg1 == NULL) SWIG_fail;
47966 temp1 = true;
47967 }
47968 {
47969 PyThreadState* __tstate = wxPyBeginAllowThreads();
47970 result = wxControl::RemoveMnemonics((wxString const &)*arg1);
47971 wxPyEndAllowThreads(__tstate);
47972 if (PyErr_Occurred()) SWIG_fail;
47973 }
47974 {
47975 #if wxUSE_UNICODE
47976 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47977 #else
47978 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47979 #endif
47980 }
47981 {
47982 if (temp1)
47983 delete arg1;
47984 }
47985 return resultobj;
47986 fail:
47987 {
47988 if (temp1)
47989 delete arg1;
47990 }
47991 return NULL;
47992 }
47993
47994
47995 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47996 PyObject *resultobj = 0;
47997 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47998 SwigValueWrapper<wxVisualAttributes > result;
47999 int val1 ;
48000 int ecode1 = 0 ;
48001 PyObject * obj0 = 0 ;
48002 char * kwnames[] = {
48003 (char *) "variant", NULL
48004 };
48005
48006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
48007 if (obj0) {
48008 ecode1 = SWIG_AsVal_int(obj0, &val1);
48009 if (!SWIG_IsOK(ecode1)) {
48010 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
48011 }
48012 arg1 = static_cast< wxWindowVariant >(val1);
48013 }
48014 {
48015 if (!wxPyCheckForApp()) SWIG_fail;
48016 PyThreadState* __tstate = wxPyBeginAllowThreads();
48017 result = wxControl::GetClassDefaultAttributes(arg1);
48018 wxPyEndAllowThreads(__tstate);
48019 if (PyErr_Occurred()) SWIG_fail;
48020 }
48021 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
48022 return resultobj;
48023 fail:
48024 return NULL;
48025 }
48026
48027
48028 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48029 PyObject *obj;
48030 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48031 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
48032 return SWIG_Py_Void();
48033 }
48034
48035 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48036 return SWIG_Python_InitShadowInstance(args);
48037 }
48038
48039 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48040 PyObject *resultobj = 0;
48041 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48042 wxString *arg2 = 0 ;
48043 PyObject *arg3 = (PyObject *) NULL ;
48044 int result;
48045 void *argp1 = 0 ;
48046 int res1 = 0 ;
48047 bool temp2 = false ;
48048 PyObject * obj0 = 0 ;
48049 PyObject * obj1 = 0 ;
48050 PyObject * obj2 = 0 ;
48051 char * kwnames[] = {
48052 (char *) "self",(char *) "item",(char *) "clientData", NULL
48053 };
48054
48055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48057 if (!SWIG_IsOK(res1)) {
48058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48059 }
48060 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48061 {
48062 arg2 = wxString_in_helper(obj1);
48063 if (arg2 == NULL) SWIG_fail;
48064 temp2 = true;
48065 }
48066 if (obj2) {
48067 arg3 = obj2;
48068 }
48069 {
48070 PyThreadState* __tstate = wxPyBeginAllowThreads();
48071 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
48072 wxPyEndAllowThreads(__tstate);
48073 if (PyErr_Occurred()) SWIG_fail;
48074 }
48075 resultobj = SWIG_From_int(static_cast< int >(result));
48076 {
48077 if (temp2)
48078 delete arg2;
48079 }
48080 return resultobj;
48081 fail:
48082 {
48083 if (temp2)
48084 delete arg2;
48085 }
48086 return NULL;
48087 }
48088
48089
48090 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48091 PyObject *resultobj = 0;
48092 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48093 wxArrayString *arg2 = 0 ;
48094 void *argp1 = 0 ;
48095 int res1 = 0 ;
48096 bool temp2 = false ;
48097 PyObject * obj0 = 0 ;
48098 PyObject * obj1 = 0 ;
48099 char * kwnames[] = {
48100 (char *) "self",(char *) "strings", NULL
48101 };
48102
48103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
48104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48105 if (!SWIG_IsOK(res1)) {
48106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48107 }
48108 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48109 {
48110 if (! PySequence_Check(obj1)) {
48111 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
48112 SWIG_fail;
48113 }
48114 arg2 = new wxArrayString;
48115 temp2 = true;
48116 int i, len=PySequence_Length(obj1);
48117 for (i=0; i<len; i++) {
48118 PyObject* item = PySequence_GetItem(obj1, i);
48119 wxString* s = wxString_in_helper(item);
48120 if (PyErr_Occurred()) SWIG_fail;
48121 arg2->Add(*s);
48122 delete s;
48123 Py_DECREF(item);
48124 }
48125 }
48126 {
48127 PyThreadState* __tstate = wxPyBeginAllowThreads();
48128 (arg1)->Append((wxArrayString const &)*arg2);
48129 wxPyEndAllowThreads(__tstate);
48130 if (PyErr_Occurred()) SWIG_fail;
48131 }
48132 resultobj = SWIG_Py_Void();
48133 {
48134 if (temp2) delete arg2;
48135 }
48136 return resultobj;
48137 fail:
48138 {
48139 if (temp2) delete arg2;
48140 }
48141 return NULL;
48142 }
48143
48144
48145 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48146 PyObject *resultobj = 0;
48147 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48148 wxString *arg2 = 0 ;
48149 int arg3 ;
48150 PyObject *arg4 = (PyObject *) NULL ;
48151 int result;
48152 void *argp1 = 0 ;
48153 int res1 = 0 ;
48154 bool temp2 = false ;
48155 int val3 ;
48156 int ecode3 = 0 ;
48157 PyObject * obj0 = 0 ;
48158 PyObject * obj1 = 0 ;
48159 PyObject * obj2 = 0 ;
48160 PyObject * obj3 = 0 ;
48161 char * kwnames[] = {
48162 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
48163 };
48164
48165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48167 if (!SWIG_IsOK(res1)) {
48168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48169 }
48170 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48171 {
48172 arg2 = wxString_in_helper(obj1);
48173 if (arg2 == NULL) SWIG_fail;
48174 temp2 = true;
48175 }
48176 ecode3 = SWIG_AsVal_int(obj2, &val3);
48177 if (!SWIG_IsOK(ecode3)) {
48178 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
48179 }
48180 arg3 = static_cast< int >(val3);
48181 if (obj3) {
48182 arg4 = obj3;
48183 }
48184 {
48185 PyThreadState* __tstate = wxPyBeginAllowThreads();
48186 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
48187 wxPyEndAllowThreads(__tstate);
48188 if (PyErr_Occurred()) SWIG_fail;
48189 }
48190 resultobj = SWIG_From_int(static_cast< int >(result));
48191 {
48192 if (temp2)
48193 delete arg2;
48194 }
48195 return resultobj;
48196 fail:
48197 {
48198 if (temp2)
48199 delete arg2;
48200 }
48201 return NULL;
48202 }
48203
48204
48205 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48206 PyObject *resultobj = 0;
48207 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48208 void *argp1 = 0 ;
48209 int res1 = 0 ;
48210 PyObject *swig_obj[1] ;
48211
48212 if (!args) SWIG_fail;
48213 swig_obj[0] = args;
48214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48215 if (!SWIG_IsOK(res1)) {
48216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48217 }
48218 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48219 {
48220 PyThreadState* __tstate = wxPyBeginAllowThreads();
48221 (arg1)->Clear();
48222 wxPyEndAllowThreads(__tstate);
48223 if (PyErr_Occurred()) SWIG_fail;
48224 }
48225 resultobj = SWIG_Py_Void();
48226 return resultobj;
48227 fail:
48228 return NULL;
48229 }
48230
48231
48232 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48233 PyObject *resultobj = 0;
48234 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48235 int arg2 ;
48236 void *argp1 = 0 ;
48237 int res1 = 0 ;
48238 int val2 ;
48239 int ecode2 = 0 ;
48240 PyObject * obj0 = 0 ;
48241 PyObject * obj1 = 0 ;
48242 char * kwnames[] = {
48243 (char *) "self",(char *) "n", NULL
48244 };
48245
48246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
48247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48248 if (!SWIG_IsOK(res1)) {
48249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48250 }
48251 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48252 ecode2 = SWIG_AsVal_int(obj1, &val2);
48253 if (!SWIG_IsOK(ecode2)) {
48254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
48255 }
48256 arg2 = static_cast< int >(val2);
48257 {
48258 PyThreadState* __tstate = wxPyBeginAllowThreads();
48259 (arg1)->Delete(arg2);
48260 wxPyEndAllowThreads(__tstate);
48261 if (PyErr_Occurred()) SWIG_fail;
48262 }
48263 resultobj = SWIG_Py_Void();
48264 return resultobj;
48265 fail:
48266 return NULL;
48267 }
48268
48269
48270 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48271 PyObject *resultobj = 0;
48272 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48273 int arg2 ;
48274 PyObject *result = 0 ;
48275 void *argp1 = 0 ;
48276 int res1 = 0 ;
48277 int val2 ;
48278 int ecode2 = 0 ;
48279 PyObject * obj0 = 0 ;
48280 PyObject * obj1 = 0 ;
48281 char * kwnames[] = {
48282 (char *) "self",(char *) "n", NULL
48283 };
48284
48285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
48286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48287 if (!SWIG_IsOK(res1)) {
48288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48289 }
48290 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48291 ecode2 = SWIG_AsVal_int(obj1, &val2);
48292 if (!SWIG_IsOK(ecode2)) {
48293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
48294 }
48295 arg2 = static_cast< int >(val2);
48296 {
48297 PyThreadState* __tstate = wxPyBeginAllowThreads();
48298 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
48299 wxPyEndAllowThreads(__tstate);
48300 if (PyErr_Occurred()) SWIG_fail;
48301 }
48302 resultobj = result;
48303 return resultobj;
48304 fail:
48305 return NULL;
48306 }
48307
48308
48309 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48310 PyObject *resultobj = 0;
48311 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48312 int arg2 ;
48313 PyObject *arg3 = (PyObject *) 0 ;
48314 void *argp1 = 0 ;
48315 int res1 = 0 ;
48316 int val2 ;
48317 int ecode2 = 0 ;
48318 PyObject * obj0 = 0 ;
48319 PyObject * obj1 = 0 ;
48320 PyObject * obj2 = 0 ;
48321 char * kwnames[] = {
48322 (char *) "self",(char *) "n",(char *) "clientData", NULL
48323 };
48324
48325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48327 if (!SWIG_IsOK(res1)) {
48328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48329 }
48330 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48331 ecode2 = SWIG_AsVal_int(obj1, &val2);
48332 if (!SWIG_IsOK(ecode2)) {
48333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
48334 }
48335 arg2 = static_cast< int >(val2);
48336 arg3 = obj2;
48337 {
48338 PyThreadState* __tstate = wxPyBeginAllowThreads();
48339 wxItemContainer_SetClientData(arg1,arg2,arg3);
48340 wxPyEndAllowThreads(__tstate);
48341 if (PyErr_Occurred()) SWIG_fail;
48342 }
48343 resultobj = SWIG_Py_Void();
48344 return resultobj;
48345 fail:
48346 return NULL;
48347 }
48348
48349
48350 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48351 PyObject *resultobj = 0;
48352 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48353 int result;
48354 void *argp1 = 0 ;
48355 int res1 = 0 ;
48356 PyObject *swig_obj[1] ;
48357
48358 if (!args) SWIG_fail;
48359 swig_obj[0] = args;
48360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48361 if (!SWIG_IsOK(res1)) {
48362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48363 }
48364 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48365 {
48366 PyThreadState* __tstate = wxPyBeginAllowThreads();
48367 result = (int)((wxItemContainer const *)arg1)->GetCount();
48368 wxPyEndAllowThreads(__tstate);
48369 if (PyErr_Occurred()) SWIG_fail;
48370 }
48371 resultobj = SWIG_From_int(static_cast< int >(result));
48372 return resultobj;
48373 fail:
48374 return NULL;
48375 }
48376
48377
48378 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48379 PyObject *resultobj = 0;
48380 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48381 bool result;
48382 void *argp1 = 0 ;
48383 int res1 = 0 ;
48384 PyObject *swig_obj[1] ;
48385
48386 if (!args) SWIG_fail;
48387 swig_obj[0] = args;
48388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48389 if (!SWIG_IsOK(res1)) {
48390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48391 }
48392 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48393 {
48394 PyThreadState* __tstate = wxPyBeginAllowThreads();
48395 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48396 wxPyEndAllowThreads(__tstate);
48397 if (PyErr_Occurred()) SWIG_fail;
48398 }
48399 {
48400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48401 }
48402 return resultobj;
48403 fail:
48404 return NULL;
48405 }
48406
48407
48408 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48409 PyObject *resultobj = 0;
48410 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48411 int arg2 ;
48412 wxString result;
48413 void *argp1 = 0 ;
48414 int res1 = 0 ;
48415 int val2 ;
48416 int ecode2 = 0 ;
48417 PyObject * obj0 = 0 ;
48418 PyObject * obj1 = 0 ;
48419 char * kwnames[] = {
48420 (char *) "self",(char *) "n", NULL
48421 };
48422
48423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48425 if (!SWIG_IsOK(res1)) {
48426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48427 }
48428 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48429 ecode2 = SWIG_AsVal_int(obj1, &val2);
48430 if (!SWIG_IsOK(ecode2)) {
48431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
48432 }
48433 arg2 = static_cast< int >(val2);
48434 {
48435 PyThreadState* __tstate = wxPyBeginAllowThreads();
48436 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48437 wxPyEndAllowThreads(__tstate);
48438 if (PyErr_Occurred()) SWIG_fail;
48439 }
48440 {
48441 #if wxUSE_UNICODE
48442 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48443 #else
48444 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48445 #endif
48446 }
48447 return resultobj;
48448 fail:
48449 return NULL;
48450 }
48451
48452
48453 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48454 PyObject *resultobj = 0;
48455 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48456 wxArrayString result;
48457 void *argp1 = 0 ;
48458 int res1 = 0 ;
48459 PyObject *swig_obj[1] ;
48460
48461 if (!args) SWIG_fail;
48462 swig_obj[0] = args;
48463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48464 if (!SWIG_IsOK(res1)) {
48465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48466 }
48467 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48468 {
48469 PyThreadState* __tstate = wxPyBeginAllowThreads();
48470 result = ((wxItemContainer const *)arg1)->GetStrings();
48471 wxPyEndAllowThreads(__tstate);
48472 if (PyErr_Occurred()) SWIG_fail;
48473 }
48474 {
48475 resultobj = wxArrayString2PyList_helper(result);
48476 }
48477 return resultobj;
48478 fail:
48479 return NULL;
48480 }
48481
48482
48483 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48484 PyObject *resultobj = 0;
48485 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48486 int arg2 ;
48487 wxString *arg3 = 0 ;
48488 void *argp1 = 0 ;
48489 int res1 = 0 ;
48490 int val2 ;
48491 int ecode2 = 0 ;
48492 bool temp3 = false ;
48493 PyObject * obj0 = 0 ;
48494 PyObject * obj1 = 0 ;
48495 PyObject * obj2 = 0 ;
48496 char * kwnames[] = {
48497 (char *) "self",(char *) "n",(char *) "s", NULL
48498 };
48499
48500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48502 if (!SWIG_IsOK(res1)) {
48503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48504 }
48505 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48506 ecode2 = SWIG_AsVal_int(obj1, &val2);
48507 if (!SWIG_IsOK(ecode2)) {
48508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
48509 }
48510 arg2 = static_cast< int >(val2);
48511 {
48512 arg3 = wxString_in_helper(obj2);
48513 if (arg3 == NULL) SWIG_fail;
48514 temp3 = true;
48515 }
48516 {
48517 PyThreadState* __tstate = wxPyBeginAllowThreads();
48518 (arg1)->SetString(arg2,(wxString const &)*arg3);
48519 wxPyEndAllowThreads(__tstate);
48520 if (PyErr_Occurred()) SWIG_fail;
48521 }
48522 resultobj = SWIG_Py_Void();
48523 {
48524 if (temp3)
48525 delete arg3;
48526 }
48527 return resultobj;
48528 fail:
48529 {
48530 if (temp3)
48531 delete arg3;
48532 }
48533 return NULL;
48534 }
48535
48536
48537 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48538 PyObject *resultobj = 0;
48539 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48540 wxString *arg2 = 0 ;
48541 int result;
48542 void *argp1 = 0 ;
48543 int res1 = 0 ;
48544 bool temp2 = false ;
48545 PyObject * obj0 = 0 ;
48546 PyObject * obj1 = 0 ;
48547 char * kwnames[] = {
48548 (char *) "self",(char *) "s", NULL
48549 };
48550
48551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48553 if (!SWIG_IsOK(res1)) {
48554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48555 }
48556 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48557 {
48558 arg2 = wxString_in_helper(obj1);
48559 if (arg2 == NULL) SWIG_fail;
48560 temp2 = true;
48561 }
48562 {
48563 PyThreadState* __tstate = wxPyBeginAllowThreads();
48564 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48565 wxPyEndAllowThreads(__tstate);
48566 if (PyErr_Occurred()) SWIG_fail;
48567 }
48568 resultobj = SWIG_From_int(static_cast< int >(result));
48569 {
48570 if (temp2)
48571 delete arg2;
48572 }
48573 return resultobj;
48574 fail:
48575 {
48576 if (temp2)
48577 delete arg2;
48578 }
48579 return NULL;
48580 }
48581
48582
48583 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48584 PyObject *resultobj = 0;
48585 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48586 int arg2 ;
48587 void *argp1 = 0 ;
48588 int res1 = 0 ;
48589 int val2 ;
48590 int ecode2 = 0 ;
48591 PyObject * obj0 = 0 ;
48592 PyObject * obj1 = 0 ;
48593 char * kwnames[] = {
48594 (char *) "self",(char *) "n", NULL
48595 };
48596
48597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48599 if (!SWIG_IsOK(res1)) {
48600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48601 }
48602 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48603 ecode2 = SWIG_AsVal_int(obj1, &val2);
48604 if (!SWIG_IsOK(ecode2)) {
48605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48606 }
48607 arg2 = static_cast< int >(val2);
48608 {
48609 PyThreadState* __tstate = wxPyBeginAllowThreads();
48610 (arg1)->SetSelection(arg2);
48611 wxPyEndAllowThreads(__tstate);
48612 if (PyErr_Occurred()) SWIG_fail;
48613 }
48614 resultobj = SWIG_Py_Void();
48615 return resultobj;
48616 fail:
48617 return NULL;
48618 }
48619
48620
48621 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48622 PyObject *resultobj = 0;
48623 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48624 int result;
48625 void *argp1 = 0 ;
48626 int res1 = 0 ;
48627 PyObject *swig_obj[1] ;
48628
48629 if (!args) SWIG_fail;
48630 swig_obj[0] = args;
48631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48632 if (!SWIG_IsOK(res1)) {
48633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48634 }
48635 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48636 {
48637 PyThreadState* __tstate = wxPyBeginAllowThreads();
48638 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48639 wxPyEndAllowThreads(__tstate);
48640 if (PyErr_Occurred()) SWIG_fail;
48641 }
48642 resultobj = SWIG_From_int(static_cast< int >(result));
48643 return resultobj;
48644 fail:
48645 return NULL;
48646 }
48647
48648
48649 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48650 PyObject *resultobj = 0;
48651 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48652 wxString *arg2 = 0 ;
48653 bool result;
48654 void *argp1 = 0 ;
48655 int res1 = 0 ;
48656 bool temp2 = false ;
48657 PyObject * obj0 = 0 ;
48658 PyObject * obj1 = 0 ;
48659 char * kwnames[] = {
48660 (char *) "self",(char *) "s", NULL
48661 };
48662
48663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48665 if (!SWIG_IsOK(res1)) {
48666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48667 }
48668 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48669 {
48670 arg2 = wxString_in_helper(obj1);
48671 if (arg2 == NULL) SWIG_fail;
48672 temp2 = true;
48673 }
48674 {
48675 PyThreadState* __tstate = wxPyBeginAllowThreads();
48676 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48677 wxPyEndAllowThreads(__tstate);
48678 if (PyErr_Occurred()) SWIG_fail;
48679 }
48680 {
48681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48682 }
48683 {
48684 if (temp2)
48685 delete arg2;
48686 }
48687 return resultobj;
48688 fail:
48689 {
48690 if (temp2)
48691 delete arg2;
48692 }
48693 return NULL;
48694 }
48695
48696
48697 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48698 PyObject *resultobj = 0;
48699 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48700 wxString result;
48701 void *argp1 = 0 ;
48702 int res1 = 0 ;
48703 PyObject *swig_obj[1] ;
48704
48705 if (!args) SWIG_fail;
48706 swig_obj[0] = args;
48707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48708 if (!SWIG_IsOK(res1)) {
48709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48710 }
48711 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48712 {
48713 PyThreadState* __tstate = wxPyBeginAllowThreads();
48714 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48715 wxPyEndAllowThreads(__tstate);
48716 if (PyErr_Occurred()) SWIG_fail;
48717 }
48718 {
48719 #if wxUSE_UNICODE
48720 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48721 #else
48722 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48723 #endif
48724 }
48725 return resultobj;
48726 fail:
48727 return NULL;
48728 }
48729
48730
48731 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48732 PyObject *resultobj = 0;
48733 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48734 int arg2 ;
48735 void *argp1 = 0 ;
48736 int res1 = 0 ;
48737 int val2 ;
48738 int ecode2 = 0 ;
48739 PyObject * obj0 = 0 ;
48740 PyObject * obj1 = 0 ;
48741 char * kwnames[] = {
48742 (char *) "self",(char *) "n", NULL
48743 };
48744
48745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48747 if (!SWIG_IsOK(res1)) {
48748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48749 }
48750 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48751 ecode2 = SWIG_AsVal_int(obj1, &val2);
48752 if (!SWIG_IsOK(ecode2)) {
48753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48754 }
48755 arg2 = static_cast< int >(val2);
48756 {
48757 PyThreadState* __tstate = wxPyBeginAllowThreads();
48758 (arg1)->Select(arg2);
48759 wxPyEndAllowThreads(__tstate);
48760 if (PyErr_Occurred()) SWIG_fail;
48761 }
48762 resultobj = SWIG_Py_Void();
48763 return resultobj;
48764 fail:
48765 return NULL;
48766 }
48767
48768
48769 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48770 PyObject *obj;
48771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48772 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48773 return SWIG_Py_Void();
48774 }
48775
48776 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48777 PyObject *obj;
48778 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48779 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48780 return SWIG_Py_Void();
48781 }
48782
48783 SWIGINTERN PyObject *_wrap_new_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48784 PyObject *resultobj = 0;
48785 int arg1 = (int) 0 ;
48786 wxSizerFlags *result = 0 ;
48787 int val1 ;
48788 int ecode1 = 0 ;
48789 PyObject * obj0 = 0 ;
48790 char * kwnames[] = {
48791 (char *) "proportion", NULL
48792 };
48793
48794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_SizerFlags",kwnames,&obj0)) SWIG_fail;
48795 if (obj0) {
48796 ecode1 = SWIG_AsVal_int(obj0, &val1);
48797 if (!SWIG_IsOK(ecode1)) {
48798 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerFlags" "', expected argument " "1"" of type '" "int""'");
48799 }
48800 arg1 = static_cast< int >(val1);
48801 }
48802 {
48803 PyThreadState* __tstate = wxPyBeginAllowThreads();
48804 result = (wxSizerFlags *)new wxSizerFlags(arg1);
48805 wxPyEndAllowThreads(__tstate);
48806 if (PyErr_Occurred()) SWIG_fail;
48807 }
48808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_NEW | 0 );
48809 return resultobj;
48810 fail:
48811 return NULL;
48812 }
48813
48814
48815 SWIGINTERN PyObject *_wrap_delete_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48816 PyObject *resultobj = 0;
48817 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48818 void *argp1 = 0 ;
48819 int res1 = 0 ;
48820 PyObject *swig_obj[1] ;
48821
48822 if (!args) SWIG_fail;
48823 swig_obj[0] = args;
48824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_DISOWN | 0 );
48825 if (!SWIG_IsOK(res1)) {
48826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerFlags" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48827 }
48828 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48829 {
48830 PyThreadState* __tstate = wxPyBeginAllowThreads();
48831 delete arg1;
48832
48833 wxPyEndAllowThreads(__tstate);
48834 if (PyErr_Occurred()) SWIG_fail;
48835 }
48836 resultobj = SWIG_Py_Void();
48837 return resultobj;
48838 fail:
48839 return NULL;
48840 }
48841
48842
48843 SWIGINTERN PyObject *_wrap_SizerFlags_Proportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48844 PyObject *resultobj = 0;
48845 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48846 int arg2 ;
48847 wxSizerFlags *result = 0 ;
48848 void *argp1 = 0 ;
48849 int res1 = 0 ;
48850 int val2 ;
48851 int ecode2 = 0 ;
48852 PyObject * obj0 = 0 ;
48853 PyObject * obj1 = 0 ;
48854 char * kwnames[] = {
48855 (char *) "self",(char *) "proportion", NULL
48856 };
48857
48858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Proportion",kwnames,&obj0,&obj1)) SWIG_fail;
48859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48860 if (!SWIG_IsOK(res1)) {
48861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Proportion" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48862 }
48863 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48864 ecode2 = SWIG_AsVal_int(obj1, &val2);
48865 if (!SWIG_IsOK(ecode2)) {
48866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Proportion" "', expected argument " "2"" of type '" "int""'");
48867 }
48868 arg2 = static_cast< int >(val2);
48869 {
48870 PyThreadState* __tstate = wxPyBeginAllowThreads();
48871 {
48872 wxSizerFlags &_result_ref = (arg1)->Proportion(arg2);
48873 result = (wxSizerFlags *) &_result_ref;
48874 }
48875 wxPyEndAllowThreads(__tstate);
48876 if (PyErr_Occurred()) SWIG_fail;
48877 }
48878 {
48879 resultobj = obj0; Py_INCREF(resultobj);
48880 }
48881 return resultobj;
48882 fail:
48883 return NULL;
48884 }
48885
48886
48887 SWIGINTERN PyObject *_wrap_SizerFlags_Align(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48888 PyObject *resultobj = 0;
48889 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48890 int arg2 ;
48891 wxSizerFlags *result = 0 ;
48892 void *argp1 = 0 ;
48893 int res1 = 0 ;
48894 int val2 ;
48895 int ecode2 = 0 ;
48896 PyObject * obj0 = 0 ;
48897 PyObject * obj1 = 0 ;
48898 char * kwnames[] = {
48899 (char *) "self",(char *) "alignment", NULL
48900 };
48901
48902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Align",kwnames,&obj0,&obj1)) SWIG_fail;
48903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48904 if (!SWIG_IsOK(res1)) {
48905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Align" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48906 }
48907 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48908 ecode2 = SWIG_AsVal_int(obj1, &val2);
48909 if (!SWIG_IsOK(ecode2)) {
48910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Align" "', expected argument " "2"" of type '" "int""'");
48911 }
48912 arg2 = static_cast< int >(val2);
48913 {
48914 PyThreadState* __tstate = wxPyBeginAllowThreads();
48915 {
48916 wxSizerFlags &_result_ref = (arg1)->Align(arg2);
48917 result = (wxSizerFlags *) &_result_ref;
48918 }
48919 wxPyEndAllowThreads(__tstate);
48920 if (PyErr_Occurred()) SWIG_fail;
48921 }
48922 {
48923 resultobj = obj0; Py_INCREF(resultobj);
48924 }
48925 return resultobj;
48926 fail:
48927 return NULL;
48928 }
48929
48930
48931 SWIGINTERN PyObject *_wrap_SizerFlags_Expand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48932 PyObject *resultobj = 0;
48933 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48934 wxSizerFlags *result = 0 ;
48935 void *argp1 = 0 ;
48936 int res1 = 0 ;
48937 PyObject *swig_obj[1] ;
48938
48939 if (!args) SWIG_fail;
48940 swig_obj[0] = args;
48941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48942 if (!SWIG_IsOK(res1)) {
48943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Expand" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48944 }
48945 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48946 {
48947 PyThreadState* __tstate = wxPyBeginAllowThreads();
48948 {
48949 wxSizerFlags &_result_ref = (arg1)->Expand();
48950 result = (wxSizerFlags *) &_result_ref;
48951 }
48952 wxPyEndAllowThreads(__tstate);
48953 if (PyErr_Occurred()) SWIG_fail;
48954 }
48955 {
48956 resultobj = swig_obj[0]; Py_INCREF(resultobj);
48957 }
48958 return resultobj;
48959 fail:
48960 return NULL;
48961 }
48962
48963
48964 SWIGINTERN PyObject *_wrap_SizerFlags_Centre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48965 PyObject *resultobj = 0;
48966 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48967 wxSizerFlags *result = 0 ;
48968 void *argp1 = 0 ;
48969 int res1 = 0 ;
48970 PyObject *swig_obj[1] ;
48971
48972 if (!args) SWIG_fail;
48973 swig_obj[0] = args;
48974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48975 if (!SWIG_IsOK(res1)) {
48976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Centre" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48977 }
48978 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48979 {
48980 PyThreadState* __tstate = wxPyBeginAllowThreads();
48981 {
48982 wxSizerFlags &_result_ref = (arg1)->Centre();
48983 result = (wxSizerFlags *) &_result_ref;
48984 }
48985 wxPyEndAllowThreads(__tstate);
48986 if (PyErr_Occurred()) SWIG_fail;
48987 }
48988 {
48989 resultobj = swig_obj[0]; Py_INCREF(resultobj);
48990 }
48991 return resultobj;
48992 fail:
48993 return NULL;
48994 }
48995
48996
48997 SWIGINTERN PyObject *_wrap_SizerFlags_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48998 PyObject *resultobj = 0;
48999 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49000 wxSizerFlags *result = 0 ;
49001 void *argp1 = 0 ;
49002 int res1 = 0 ;
49003 PyObject *swig_obj[1] ;
49004
49005 if (!args) SWIG_fail;
49006 swig_obj[0] = args;
49007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49008 if (!SWIG_IsOK(res1)) {
49009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Center" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49010 }
49011 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49012 {
49013 PyThreadState* __tstate = wxPyBeginAllowThreads();
49014 {
49015 wxSizerFlags &_result_ref = (arg1)->Center();
49016 result = (wxSizerFlags *) &_result_ref;
49017 }
49018 wxPyEndAllowThreads(__tstate);
49019 if (PyErr_Occurred()) SWIG_fail;
49020 }
49021 {
49022 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49023 }
49024 return resultobj;
49025 fail:
49026 return NULL;
49027 }
49028
49029
49030 SWIGINTERN PyObject *_wrap_SizerFlags_Left(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49031 PyObject *resultobj = 0;
49032 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49033 wxSizerFlags *result = 0 ;
49034 void *argp1 = 0 ;
49035 int res1 = 0 ;
49036 PyObject *swig_obj[1] ;
49037
49038 if (!args) SWIG_fail;
49039 swig_obj[0] = args;
49040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49041 if (!SWIG_IsOK(res1)) {
49042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Left" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49043 }
49044 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49045 {
49046 PyThreadState* __tstate = wxPyBeginAllowThreads();
49047 {
49048 wxSizerFlags &_result_ref = (arg1)->Left();
49049 result = (wxSizerFlags *) &_result_ref;
49050 }
49051 wxPyEndAllowThreads(__tstate);
49052 if (PyErr_Occurred()) SWIG_fail;
49053 }
49054 {
49055 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49056 }
49057 return resultobj;
49058 fail:
49059 return NULL;
49060 }
49061
49062
49063 SWIGINTERN PyObject *_wrap_SizerFlags_Right(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49064 PyObject *resultobj = 0;
49065 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49066 wxSizerFlags *result = 0 ;
49067 void *argp1 = 0 ;
49068 int res1 = 0 ;
49069 PyObject *swig_obj[1] ;
49070
49071 if (!args) SWIG_fail;
49072 swig_obj[0] = args;
49073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49074 if (!SWIG_IsOK(res1)) {
49075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Right" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49076 }
49077 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49078 {
49079 PyThreadState* __tstate = wxPyBeginAllowThreads();
49080 {
49081 wxSizerFlags &_result_ref = (arg1)->Right();
49082 result = (wxSizerFlags *) &_result_ref;
49083 }
49084 wxPyEndAllowThreads(__tstate);
49085 if (PyErr_Occurred()) SWIG_fail;
49086 }
49087 {
49088 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49089 }
49090 return resultobj;
49091 fail:
49092 return NULL;
49093 }
49094
49095
49096 SWIGINTERN PyObject *_wrap_SizerFlags_Top(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49097 PyObject *resultobj = 0;
49098 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49099 wxSizerFlags *result = 0 ;
49100 void *argp1 = 0 ;
49101 int res1 = 0 ;
49102 PyObject *swig_obj[1] ;
49103
49104 if (!args) SWIG_fail;
49105 swig_obj[0] = args;
49106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49107 if (!SWIG_IsOK(res1)) {
49108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Top" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49109 }
49110 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49111 {
49112 PyThreadState* __tstate = wxPyBeginAllowThreads();
49113 {
49114 wxSizerFlags &_result_ref = (arg1)->Top();
49115 result = (wxSizerFlags *) &_result_ref;
49116 }
49117 wxPyEndAllowThreads(__tstate);
49118 if (PyErr_Occurred()) SWIG_fail;
49119 }
49120 {
49121 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49122 }
49123 return resultobj;
49124 fail:
49125 return NULL;
49126 }
49127
49128
49129 SWIGINTERN PyObject *_wrap_SizerFlags_Bottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49130 PyObject *resultobj = 0;
49131 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49132 wxSizerFlags *result = 0 ;
49133 void *argp1 = 0 ;
49134 int res1 = 0 ;
49135 PyObject *swig_obj[1] ;
49136
49137 if (!args) SWIG_fail;
49138 swig_obj[0] = args;
49139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49140 if (!SWIG_IsOK(res1)) {
49141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Bottom" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49142 }
49143 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49144 {
49145 PyThreadState* __tstate = wxPyBeginAllowThreads();
49146 {
49147 wxSizerFlags &_result_ref = (arg1)->Bottom();
49148 result = (wxSizerFlags *) &_result_ref;
49149 }
49150 wxPyEndAllowThreads(__tstate);
49151 if (PyErr_Occurred()) SWIG_fail;
49152 }
49153 {
49154 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49155 }
49156 return resultobj;
49157 fail:
49158 return NULL;
49159 }
49160
49161
49162 SWIGINTERN PyObject *_wrap_SizerFlags_Shaped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49163 PyObject *resultobj = 0;
49164 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49165 wxSizerFlags *result = 0 ;
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_wxSizerFlags, 0 | 0 );
49173 if (!SWIG_IsOK(res1)) {
49174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Shaped" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49175 }
49176 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49177 {
49178 PyThreadState* __tstate = wxPyBeginAllowThreads();
49179 {
49180 wxSizerFlags &_result_ref = (arg1)->Shaped();
49181 result = (wxSizerFlags *) &_result_ref;
49182 }
49183 wxPyEndAllowThreads(__tstate);
49184 if (PyErr_Occurred()) SWIG_fail;
49185 }
49186 {
49187 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49188 }
49189 return resultobj;
49190 fail:
49191 return NULL;
49192 }
49193
49194
49195 SWIGINTERN PyObject *_wrap_SizerFlags_FixedMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49196 PyObject *resultobj = 0;
49197 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49198 wxSizerFlags *result = 0 ;
49199 void *argp1 = 0 ;
49200 int res1 = 0 ;
49201 PyObject *swig_obj[1] ;
49202
49203 if (!args) SWIG_fail;
49204 swig_obj[0] = args;
49205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49206 if (!SWIG_IsOK(res1)) {
49207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_FixedMinSize" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49208 }
49209 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49210 {
49211 PyThreadState* __tstate = wxPyBeginAllowThreads();
49212 {
49213 wxSizerFlags &_result_ref = (arg1)->FixedMinSize();
49214 result = (wxSizerFlags *) &_result_ref;
49215 }
49216 wxPyEndAllowThreads(__tstate);
49217 if (PyErr_Occurred()) SWIG_fail;
49218 }
49219 {
49220 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49221 }
49222 return resultobj;
49223 fail:
49224 return NULL;
49225 }
49226
49227
49228 SWIGINTERN PyObject *_wrap_SizerFlags_Border(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49229 PyObject *resultobj = 0;
49230 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49231 int arg2 = (int) wxALL ;
49232 int arg3 = (int) -1 ;
49233 wxSizerFlags *result = 0 ;
49234 void *argp1 = 0 ;
49235 int res1 = 0 ;
49236 int val2 ;
49237 int ecode2 = 0 ;
49238 int val3 ;
49239 int ecode3 = 0 ;
49240 PyObject * obj0 = 0 ;
49241 PyObject * obj1 = 0 ;
49242 PyObject * obj2 = 0 ;
49243 char * kwnames[] = {
49244 (char *) "self",(char *) "direction",(char *) "borderInPixels", NULL
49245 };
49246
49247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:SizerFlags_Border",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49249 if (!SWIG_IsOK(res1)) {
49250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Border" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49251 }
49252 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49253 if (obj1) {
49254 ecode2 = SWIG_AsVal_int(obj1, &val2);
49255 if (!SWIG_IsOK(ecode2)) {
49256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Border" "', expected argument " "2"" of type '" "int""'");
49257 }
49258 arg2 = static_cast< int >(val2);
49259 }
49260 if (obj2) {
49261 ecode3 = SWIG_AsVal_int(obj2, &val3);
49262 if (!SWIG_IsOK(ecode3)) {
49263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerFlags_Border" "', expected argument " "3"" of type '" "int""'");
49264 }
49265 arg3 = static_cast< int >(val3);
49266 }
49267 {
49268 PyThreadState* __tstate = wxPyBeginAllowThreads();
49269 {
49270 wxSizerFlags &_result_ref = wxSizerFlags_Border(arg1,arg2,arg3);
49271 result = (wxSizerFlags *) &_result_ref;
49272 }
49273 wxPyEndAllowThreads(__tstate);
49274 if (PyErr_Occurred()) SWIG_fail;
49275 }
49276 {
49277 resultobj = obj0; Py_INCREF(resultobj);
49278 }
49279 return resultobj;
49280 fail:
49281 return NULL;
49282 }
49283
49284
49285 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49286 PyObject *resultobj = 0;
49287 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49288 int arg2 = (int) wxALL ;
49289 wxSizerFlags *result = 0 ;
49290 void *argp1 = 0 ;
49291 int res1 = 0 ;
49292 int val2 ;
49293 int ecode2 = 0 ;
49294 PyObject * obj0 = 0 ;
49295 PyObject * obj1 = 0 ;
49296 char * kwnames[] = {
49297 (char *) "self",(char *) "direction", NULL
49298 };
49299
49300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_DoubleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49302 if (!SWIG_IsOK(res1)) {
49303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49304 }
49305 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49306 if (obj1) {
49307 ecode2 = SWIG_AsVal_int(obj1, &val2);
49308 if (!SWIG_IsOK(ecode2)) {
49309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "2"" of type '" "int""'");
49310 }
49311 arg2 = static_cast< int >(val2);
49312 }
49313 {
49314 PyThreadState* __tstate = wxPyBeginAllowThreads();
49315 {
49316 wxSizerFlags &_result_ref = (arg1)->DoubleBorder(arg2);
49317 result = (wxSizerFlags *) &_result_ref;
49318 }
49319 wxPyEndAllowThreads(__tstate);
49320 if (PyErr_Occurred()) SWIG_fail;
49321 }
49322 {
49323 resultobj = obj0; Py_INCREF(resultobj);
49324 }
49325 return resultobj;
49326 fail:
49327 return NULL;
49328 }
49329
49330
49331 SWIGINTERN PyObject *_wrap_SizerFlags_TripleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49332 PyObject *resultobj = 0;
49333 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49334 int arg2 = (int) wxALL ;
49335 wxSizerFlags *result = 0 ;
49336 void *argp1 = 0 ;
49337 int res1 = 0 ;
49338 int val2 ;
49339 int ecode2 = 0 ;
49340 PyObject * obj0 = 0 ;
49341 PyObject * obj1 = 0 ;
49342 char * kwnames[] = {
49343 (char *) "self",(char *) "direction", NULL
49344 };
49345
49346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_TripleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49348 if (!SWIG_IsOK(res1)) {
49349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_TripleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49350 }
49351 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49352 if (obj1) {
49353 ecode2 = SWIG_AsVal_int(obj1, &val2);
49354 if (!SWIG_IsOK(ecode2)) {
49355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_TripleBorder" "', expected argument " "2"" of type '" "int""'");
49356 }
49357 arg2 = static_cast< int >(val2);
49358 }
49359 {
49360 PyThreadState* __tstate = wxPyBeginAllowThreads();
49361 {
49362 wxSizerFlags &_result_ref = (arg1)->TripleBorder(arg2);
49363 result = (wxSizerFlags *) &_result_ref;
49364 }
49365 wxPyEndAllowThreads(__tstate);
49366 if (PyErr_Occurred()) SWIG_fail;
49367 }
49368 {
49369 resultobj = obj0; Py_INCREF(resultobj);
49370 }
49371 return resultobj;
49372 fail:
49373 return NULL;
49374 }
49375
49376
49377 SWIGINTERN PyObject *_wrap_SizerFlags_HorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49378 PyObject *resultobj = 0;
49379 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49380 wxSizerFlags *result = 0 ;
49381 void *argp1 = 0 ;
49382 int res1 = 0 ;
49383 PyObject *swig_obj[1] ;
49384
49385 if (!args) SWIG_fail;
49386 swig_obj[0] = args;
49387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49388 if (!SWIG_IsOK(res1)) {
49389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_HorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49390 }
49391 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49392 {
49393 PyThreadState* __tstate = wxPyBeginAllowThreads();
49394 {
49395 wxSizerFlags &_result_ref = (arg1)->HorzBorder();
49396 result = (wxSizerFlags *) &_result_ref;
49397 }
49398 wxPyEndAllowThreads(__tstate);
49399 if (PyErr_Occurred()) SWIG_fail;
49400 }
49401 {
49402 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49403 }
49404 return resultobj;
49405 fail:
49406 return NULL;
49407 }
49408
49409
49410 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleHorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49411 PyObject *resultobj = 0;
49412 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49413 wxSizerFlags *result = 0 ;
49414 void *argp1 = 0 ;
49415 int res1 = 0 ;
49416 PyObject *swig_obj[1] ;
49417
49418 if (!args) SWIG_fail;
49419 swig_obj[0] = args;
49420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49421 if (!SWIG_IsOK(res1)) {
49422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleHorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49423 }
49424 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49425 {
49426 PyThreadState* __tstate = wxPyBeginAllowThreads();
49427 {
49428 wxSizerFlags &_result_ref = (arg1)->DoubleHorzBorder();
49429 result = (wxSizerFlags *) &_result_ref;
49430 }
49431 wxPyEndAllowThreads(__tstate);
49432 if (PyErr_Occurred()) SWIG_fail;
49433 }
49434 {
49435 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49436 }
49437 return resultobj;
49438 fail:
49439 return NULL;
49440 }
49441
49442
49443 SWIGINTERN PyObject *_wrap_SizerFlags_GetDefaultBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49444 PyObject *resultobj = 0;
49445 int result;
49446
49447 if (!SWIG_Python_UnpackTuple(args,"SizerFlags_GetDefaultBorder",0,0,0)) SWIG_fail;
49448 {
49449 PyThreadState* __tstate = wxPyBeginAllowThreads();
49450 result = (int)wxSizerFlags::GetDefaultBorder();
49451 wxPyEndAllowThreads(__tstate);
49452 if (PyErr_Occurred()) SWIG_fail;
49453 }
49454 resultobj = SWIG_From_int(static_cast< int >(result));
49455 return resultobj;
49456 fail:
49457 return NULL;
49458 }
49459
49460
49461 SWIGINTERN PyObject *_wrap_SizerFlags_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49462 PyObject *resultobj = 0;
49463 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49464 int result;
49465 void *argp1 = 0 ;
49466 int res1 = 0 ;
49467 PyObject *swig_obj[1] ;
49468
49469 if (!args) SWIG_fail;
49470 swig_obj[0] = args;
49471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49472 if (!SWIG_IsOK(res1)) {
49473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetProportion" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49474 }
49475 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49476 {
49477 PyThreadState* __tstate = wxPyBeginAllowThreads();
49478 result = (int)((wxSizerFlags const *)arg1)->GetProportion();
49479 wxPyEndAllowThreads(__tstate);
49480 if (PyErr_Occurred()) SWIG_fail;
49481 }
49482 resultobj = SWIG_From_int(static_cast< int >(result));
49483 return resultobj;
49484 fail:
49485 return NULL;
49486 }
49487
49488
49489 SWIGINTERN PyObject *_wrap_SizerFlags_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49490 PyObject *resultobj = 0;
49491 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49492 int result;
49493 void *argp1 = 0 ;
49494 int res1 = 0 ;
49495 PyObject *swig_obj[1] ;
49496
49497 if (!args) SWIG_fail;
49498 swig_obj[0] = args;
49499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49500 if (!SWIG_IsOK(res1)) {
49501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetFlags" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49502 }
49503 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49504 {
49505 PyThreadState* __tstate = wxPyBeginAllowThreads();
49506 result = (int)((wxSizerFlags const *)arg1)->GetFlags();
49507 wxPyEndAllowThreads(__tstate);
49508 if (PyErr_Occurred()) SWIG_fail;
49509 }
49510 resultobj = SWIG_From_int(static_cast< int >(result));
49511 return resultobj;
49512 fail:
49513 return NULL;
49514 }
49515
49516
49517 SWIGINTERN PyObject *_wrap_SizerFlags_GetBorderInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49518 PyObject *resultobj = 0;
49519 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49520 int result;
49521 void *argp1 = 0 ;
49522 int res1 = 0 ;
49523 PyObject *swig_obj[1] ;
49524
49525 if (!args) SWIG_fail;
49526 swig_obj[0] = args;
49527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49528 if (!SWIG_IsOK(res1)) {
49529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetBorderInPixels" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49530 }
49531 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49532 {
49533 PyThreadState* __tstate = wxPyBeginAllowThreads();
49534 result = (int)((wxSizerFlags const *)arg1)->GetBorderInPixels();
49535 wxPyEndAllowThreads(__tstate);
49536 if (PyErr_Occurred()) SWIG_fail;
49537 }
49538 resultobj = SWIG_From_int(static_cast< int >(result));
49539 return resultobj;
49540 fail:
49541 return NULL;
49542 }
49543
49544
49545 SWIGINTERN PyObject *SizerFlags_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49546 PyObject *obj;
49547 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49548 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerFlags, SWIG_NewClientData(obj));
49549 return SWIG_Py_Void();
49550 }
49551
49552 SWIGINTERN PyObject *SizerFlags_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49553 return SWIG_Python_InitShadowInstance(args);
49554 }
49555
49556 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49557 PyObject *resultobj = 0;
49558 wxSizerItem *result = 0 ;
49559
49560 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
49561 {
49562 PyThreadState* __tstate = wxPyBeginAllowThreads();
49563 result = (wxSizerItem *)new wxSizerItem();
49564 wxPyEndAllowThreads(__tstate);
49565 if (PyErr_Occurred()) SWIG_fail;
49566 }
49567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
49568 return resultobj;
49569 fail:
49570 return NULL;
49571 }
49572
49573
49574 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49575 PyObject *resultobj = 0;
49576 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49577 void *argp1 = 0 ;
49578 int res1 = 0 ;
49579 PyObject *swig_obj[1] ;
49580
49581 if (!args) SWIG_fail;
49582 swig_obj[0] = args;
49583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
49584 if (!SWIG_IsOK(res1)) {
49585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49586 }
49587 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49588 {
49589 PyThreadState* __tstate = wxPyBeginAllowThreads();
49590 delete arg1;
49591
49592 wxPyEndAllowThreads(__tstate);
49593 if (PyErr_Occurred()) SWIG_fail;
49594 }
49595 resultobj = SWIG_Py_Void();
49596 return resultobj;
49597 fail:
49598 return NULL;
49599 }
49600
49601
49602 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49603 PyObject *resultobj = 0;
49604 wxWindow *arg1 = (wxWindow *) 0 ;
49605 int arg2 ;
49606 int arg3 ;
49607 int arg4 ;
49608 PyObject *arg5 = (PyObject *) NULL ;
49609 wxSizerItem *result = 0 ;
49610 void *argp1 = 0 ;
49611 int res1 = 0 ;
49612 int val2 ;
49613 int ecode2 = 0 ;
49614 int val3 ;
49615 int ecode3 = 0 ;
49616 int val4 ;
49617 int ecode4 = 0 ;
49618 PyObject * obj0 = 0 ;
49619 PyObject * obj1 = 0 ;
49620 PyObject * obj2 = 0 ;
49621 PyObject * obj3 = 0 ;
49622 PyObject * obj4 = 0 ;
49623 char * kwnames[] = {
49624 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49625 };
49626
49627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
49628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49629 if (!SWIG_IsOK(res1)) {
49630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49631 }
49632 arg1 = reinterpret_cast< wxWindow * >(argp1);
49633 ecode2 = SWIG_AsVal_int(obj1, &val2);
49634 if (!SWIG_IsOK(ecode2)) {
49635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
49636 }
49637 arg2 = static_cast< int >(val2);
49638 ecode3 = SWIG_AsVal_int(obj2, &val3);
49639 if (!SWIG_IsOK(ecode3)) {
49640 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
49641 }
49642 arg3 = static_cast< int >(val3);
49643 ecode4 = SWIG_AsVal_int(obj3, &val4);
49644 if (!SWIG_IsOK(ecode4)) {
49645 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49646 }
49647 arg4 = static_cast< int >(val4);
49648 if (obj4) {
49649 arg5 = obj4;
49650 }
49651 {
49652 PyThreadState* __tstate = wxPyBeginAllowThreads();
49653 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
49654 wxPyEndAllowThreads(__tstate);
49655 if (PyErr_Occurred()) SWIG_fail;
49656 }
49657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
49658 return resultobj;
49659 fail:
49660 return NULL;
49661 }
49662
49663
49664 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49665 PyObject *resultobj = 0;
49666 int arg1 ;
49667 int arg2 ;
49668 int arg3 ;
49669 int arg4 ;
49670 int arg5 ;
49671 PyObject *arg6 = (PyObject *) NULL ;
49672 wxSizerItem *result = 0 ;
49673 int val1 ;
49674 int ecode1 = 0 ;
49675 int val2 ;
49676 int ecode2 = 0 ;
49677 int val3 ;
49678 int ecode3 = 0 ;
49679 int val4 ;
49680 int ecode4 = 0 ;
49681 int val5 ;
49682 int ecode5 = 0 ;
49683 PyObject * obj0 = 0 ;
49684 PyObject * obj1 = 0 ;
49685 PyObject * obj2 = 0 ;
49686 PyObject * obj3 = 0 ;
49687 PyObject * obj4 = 0 ;
49688 PyObject * obj5 = 0 ;
49689 char * kwnames[] = {
49690 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49691 };
49692
49693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49694 ecode1 = SWIG_AsVal_int(obj0, &val1);
49695 if (!SWIG_IsOK(ecode1)) {
49696 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49697 }
49698 arg1 = static_cast< int >(val1);
49699 ecode2 = SWIG_AsVal_int(obj1, &val2);
49700 if (!SWIG_IsOK(ecode2)) {
49701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49702 }
49703 arg2 = static_cast< int >(val2);
49704 ecode3 = SWIG_AsVal_int(obj2, &val3);
49705 if (!SWIG_IsOK(ecode3)) {
49706 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
49707 }
49708 arg3 = static_cast< int >(val3);
49709 ecode4 = SWIG_AsVal_int(obj3, &val4);
49710 if (!SWIG_IsOK(ecode4)) {
49711 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
49712 }
49713 arg4 = static_cast< int >(val4);
49714 ecode5 = SWIG_AsVal_int(obj4, &val5);
49715 if (!SWIG_IsOK(ecode5)) {
49716 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49717 }
49718 arg5 = static_cast< int >(val5);
49719 if (obj5) {
49720 arg6 = obj5;
49721 }
49722 {
49723 PyThreadState* __tstate = wxPyBeginAllowThreads();
49724 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
49725 wxPyEndAllowThreads(__tstate);
49726 if (PyErr_Occurred()) SWIG_fail;
49727 }
49728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
49729 return resultobj;
49730 fail:
49731 return NULL;
49732 }
49733
49734
49735 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49736 PyObject *resultobj = 0;
49737 wxSizer *arg1 = (wxSizer *) 0 ;
49738 int arg2 ;
49739 int arg3 ;
49740 int arg4 ;
49741 PyObject *arg5 = (PyObject *) NULL ;
49742 wxSizerItem *result = 0 ;
49743 int res1 = 0 ;
49744 int val2 ;
49745 int ecode2 = 0 ;
49746 int val3 ;
49747 int ecode3 = 0 ;
49748 int val4 ;
49749 int ecode4 = 0 ;
49750 PyObject * obj0 = 0 ;
49751 PyObject * obj1 = 0 ;
49752 PyObject * obj2 = 0 ;
49753 PyObject * obj3 = 0 ;
49754 PyObject * obj4 = 0 ;
49755 char * kwnames[] = {
49756 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49757 };
49758
49759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
49760 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49761 if (!SWIG_IsOK(res1)) {
49762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49763 }
49764 ecode2 = SWIG_AsVal_int(obj1, &val2);
49765 if (!SWIG_IsOK(ecode2)) {
49766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
49767 }
49768 arg2 = static_cast< int >(val2);
49769 ecode3 = SWIG_AsVal_int(obj2, &val3);
49770 if (!SWIG_IsOK(ecode3)) {
49771 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
49772 }
49773 arg3 = static_cast< int >(val3);
49774 ecode4 = SWIG_AsVal_int(obj3, &val4);
49775 if (!SWIG_IsOK(ecode4)) {
49776 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49777 }
49778 arg4 = static_cast< int >(val4);
49779 if (obj4) {
49780 arg5 = obj4;
49781 }
49782 {
49783 PyThreadState* __tstate = wxPyBeginAllowThreads();
49784 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
49785 wxPyEndAllowThreads(__tstate);
49786 if (PyErr_Occurred()) SWIG_fail;
49787 }
49788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
49789 return resultobj;
49790 fail:
49791 return NULL;
49792 }
49793
49794
49795 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49796 PyObject *resultobj = 0;
49797 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49798 void *argp1 = 0 ;
49799 int res1 = 0 ;
49800 PyObject *swig_obj[1] ;
49801
49802 if (!args) SWIG_fail;
49803 swig_obj[0] = args;
49804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49805 if (!SWIG_IsOK(res1)) {
49806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49807 }
49808 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49809 {
49810 PyThreadState* __tstate = wxPyBeginAllowThreads();
49811 (arg1)->DeleteWindows();
49812 wxPyEndAllowThreads(__tstate);
49813 if (PyErr_Occurred()) SWIG_fail;
49814 }
49815 resultobj = SWIG_Py_Void();
49816 return resultobj;
49817 fail:
49818 return NULL;
49819 }
49820
49821
49822 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49823 PyObject *resultobj = 0;
49824 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49825 void *argp1 = 0 ;
49826 int res1 = 0 ;
49827 PyObject *swig_obj[1] ;
49828
49829 if (!args) SWIG_fail;
49830 swig_obj[0] = args;
49831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49832 if (!SWIG_IsOK(res1)) {
49833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49834 }
49835 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49836 {
49837 PyThreadState* __tstate = wxPyBeginAllowThreads();
49838 (arg1)->DetachSizer();
49839 wxPyEndAllowThreads(__tstate);
49840 if (PyErr_Occurred()) SWIG_fail;
49841 }
49842 resultobj = SWIG_Py_Void();
49843 return resultobj;
49844 fail:
49845 return NULL;
49846 }
49847
49848
49849 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49850 PyObject *resultobj = 0;
49851 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49852 wxSize result;
49853 void *argp1 = 0 ;
49854 int res1 = 0 ;
49855 PyObject *swig_obj[1] ;
49856
49857 if (!args) SWIG_fail;
49858 swig_obj[0] = args;
49859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49860 if (!SWIG_IsOK(res1)) {
49861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49862 }
49863 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49864 {
49865 PyThreadState* __tstate = wxPyBeginAllowThreads();
49866 result = (arg1)->GetSize();
49867 wxPyEndAllowThreads(__tstate);
49868 if (PyErr_Occurred()) SWIG_fail;
49869 }
49870 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49871 return resultobj;
49872 fail:
49873 return NULL;
49874 }
49875
49876
49877 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49878 PyObject *resultobj = 0;
49879 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49880 wxSize result;
49881 void *argp1 = 0 ;
49882 int res1 = 0 ;
49883 PyObject *swig_obj[1] ;
49884
49885 if (!args) SWIG_fail;
49886 swig_obj[0] = args;
49887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49888 if (!SWIG_IsOK(res1)) {
49889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49890 }
49891 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49892 {
49893 PyThreadState* __tstate = wxPyBeginAllowThreads();
49894 result = (arg1)->CalcMin();
49895 wxPyEndAllowThreads(__tstate);
49896 if (PyErr_Occurred()) SWIG_fail;
49897 }
49898 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49899 return resultobj;
49900 fail:
49901 return NULL;
49902 }
49903
49904
49905 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49906 PyObject *resultobj = 0;
49907 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49908 wxPoint *arg2 = 0 ;
49909 wxSize *arg3 = 0 ;
49910 void *argp1 = 0 ;
49911 int res1 = 0 ;
49912 wxPoint temp2 ;
49913 wxSize temp3 ;
49914 PyObject * obj0 = 0 ;
49915 PyObject * obj1 = 0 ;
49916 PyObject * obj2 = 0 ;
49917 char * kwnames[] = {
49918 (char *) "self",(char *) "pos",(char *) "size", NULL
49919 };
49920
49921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49923 if (!SWIG_IsOK(res1)) {
49924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49925 }
49926 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49927 {
49928 arg2 = &temp2;
49929 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
49930 }
49931 {
49932 arg3 = &temp3;
49933 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
49934 }
49935 {
49936 PyThreadState* __tstate = wxPyBeginAllowThreads();
49937 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
49938 wxPyEndAllowThreads(__tstate);
49939 if (PyErr_Occurred()) SWIG_fail;
49940 }
49941 resultobj = SWIG_Py_Void();
49942 return resultobj;
49943 fail:
49944 return NULL;
49945 }
49946
49947
49948 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49949 PyObject *resultobj = 0;
49950 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49951 wxSize result;
49952 void *argp1 = 0 ;
49953 int res1 = 0 ;
49954 PyObject *swig_obj[1] ;
49955
49956 if (!args) SWIG_fail;
49957 swig_obj[0] = args;
49958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49959 if (!SWIG_IsOK(res1)) {
49960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49961 }
49962 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49963 {
49964 PyThreadState* __tstate = wxPyBeginAllowThreads();
49965 result = (arg1)->GetMinSize();
49966 wxPyEndAllowThreads(__tstate);
49967 if (PyErr_Occurred()) SWIG_fail;
49968 }
49969 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49970 return resultobj;
49971 fail:
49972 return NULL;
49973 }
49974
49975
49976 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49977 PyObject *resultobj = 0;
49978 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49979 wxSize result;
49980 void *argp1 = 0 ;
49981 int res1 = 0 ;
49982 PyObject *swig_obj[1] ;
49983
49984 if (!args) SWIG_fail;
49985 swig_obj[0] = args;
49986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49987 if (!SWIG_IsOK(res1)) {
49988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
49989 }
49990 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49991 {
49992 PyThreadState* __tstate = wxPyBeginAllowThreads();
49993 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
49994 wxPyEndAllowThreads(__tstate);
49995 if (PyErr_Occurred()) SWIG_fail;
49996 }
49997 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49998 return resultobj;
49999 fail:
50000 return NULL;
50001 }
50002
50003
50004 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50005 PyObject *resultobj = 0;
50006 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50007 int arg2 ;
50008 int arg3 ;
50009 void *argp1 = 0 ;
50010 int res1 = 0 ;
50011 int val2 ;
50012 int ecode2 = 0 ;
50013 int val3 ;
50014 int ecode3 = 0 ;
50015 PyObject * obj0 = 0 ;
50016 PyObject * obj1 = 0 ;
50017 PyObject * obj2 = 0 ;
50018 char * kwnames[] = {
50019 (char *) "self",(char *) "x",(char *) "y", NULL
50020 };
50021
50022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50024 if (!SWIG_IsOK(res1)) {
50025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50026 }
50027 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50028 ecode2 = SWIG_AsVal_int(obj1, &val2);
50029 if (!SWIG_IsOK(ecode2)) {
50030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
50031 }
50032 arg2 = static_cast< int >(val2);
50033 ecode3 = SWIG_AsVal_int(obj2, &val3);
50034 if (!SWIG_IsOK(ecode3)) {
50035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
50036 }
50037 arg3 = static_cast< int >(val3);
50038 {
50039 PyThreadState* __tstate = wxPyBeginAllowThreads();
50040 (arg1)->SetInitSize(arg2,arg3);
50041 wxPyEndAllowThreads(__tstate);
50042 if (PyErr_Occurred()) SWIG_fail;
50043 }
50044 resultobj = SWIG_Py_Void();
50045 return resultobj;
50046 fail:
50047 return NULL;
50048 }
50049
50050
50051 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50052 PyObject *resultobj = 0;
50053 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50054 int arg2 ;
50055 int arg3 ;
50056 void *argp1 = 0 ;
50057 int res1 = 0 ;
50058 int val2 ;
50059 int ecode2 = 0 ;
50060 int val3 ;
50061 int ecode3 = 0 ;
50062 PyObject * obj0 = 0 ;
50063 PyObject * obj1 = 0 ;
50064 PyObject * obj2 = 0 ;
50065 char * kwnames[] = {
50066 (char *) "self",(char *) "width",(char *) "height", NULL
50067 };
50068
50069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50071 if (!SWIG_IsOK(res1)) {
50072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50073 }
50074 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50075 ecode2 = SWIG_AsVal_int(obj1, &val2);
50076 if (!SWIG_IsOK(ecode2)) {
50077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
50078 }
50079 arg2 = static_cast< int >(val2);
50080 ecode3 = SWIG_AsVal_int(obj2, &val3);
50081 if (!SWIG_IsOK(ecode3)) {
50082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
50083 }
50084 arg3 = static_cast< int >(val3);
50085 {
50086 PyThreadState* __tstate = wxPyBeginAllowThreads();
50087 (arg1)->SetRatio(arg2,arg3);
50088 wxPyEndAllowThreads(__tstate);
50089 if (PyErr_Occurred()) SWIG_fail;
50090 }
50091 resultobj = SWIG_Py_Void();
50092 return resultobj;
50093 fail:
50094 return NULL;
50095 }
50096
50097
50098 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50099 PyObject *resultobj = 0;
50100 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50101 wxSize *arg2 = 0 ;
50102 void *argp1 = 0 ;
50103 int res1 = 0 ;
50104 wxSize temp2 ;
50105 PyObject * obj0 = 0 ;
50106 PyObject * obj1 = 0 ;
50107 char * kwnames[] = {
50108 (char *) "self",(char *) "size", NULL
50109 };
50110
50111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
50112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50113 if (!SWIG_IsOK(res1)) {
50114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50115 }
50116 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50117 {
50118 arg2 = &temp2;
50119 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50120 }
50121 {
50122 PyThreadState* __tstate = wxPyBeginAllowThreads();
50123 (arg1)->SetRatio((wxSize const &)*arg2);
50124 wxPyEndAllowThreads(__tstate);
50125 if (PyErr_Occurred()) SWIG_fail;
50126 }
50127 resultobj = SWIG_Py_Void();
50128 return resultobj;
50129 fail:
50130 return NULL;
50131 }
50132
50133
50134 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50135 PyObject *resultobj = 0;
50136 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50137 float arg2 ;
50138 void *argp1 = 0 ;
50139 int res1 = 0 ;
50140 float val2 ;
50141 int ecode2 = 0 ;
50142 PyObject * obj0 = 0 ;
50143 PyObject * obj1 = 0 ;
50144 char * kwnames[] = {
50145 (char *) "self",(char *) "ratio", NULL
50146 };
50147
50148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
50149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50150 if (!SWIG_IsOK(res1)) {
50151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50152 }
50153 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50154 ecode2 = SWIG_AsVal_float(obj1, &val2);
50155 if (!SWIG_IsOK(ecode2)) {
50156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
50157 }
50158 arg2 = static_cast< float >(val2);
50159 {
50160 PyThreadState* __tstate = wxPyBeginAllowThreads();
50161 (arg1)->SetRatio(arg2);
50162 wxPyEndAllowThreads(__tstate);
50163 if (PyErr_Occurred()) SWIG_fail;
50164 }
50165 resultobj = SWIG_Py_Void();
50166 return resultobj;
50167 fail:
50168 return NULL;
50169 }
50170
50171
50172 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50173 PyObject *resultobj = 0;
50174 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50175 float result;
50176 void *argp1 = 0 ;
50177 int res1 = 0 ;
50178 PyObject *swig_obj[1] ;
50179
50180 if (!args) SWIG_fail;
50181 swig_obj[0] = args;
50182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50183 if (!SWIG_IsOK(res1)) {
50184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50185 }
50186 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50187 {
50188 PyThreadState* __tstate = wxPyBeginAllowThreads();
50189 result = (float)(arg1)->GetRatio();
50190 wxPyEndAllowThreads(__tstate);
50191 if (PyErr_Occurred()) SWIG_fail;
50192 }
50193 resultobj = SWIG_From_float(static_cast< float >(result));
50194 return resultobj;
50195 fail:
50196 return NULL;
50197 }
50198
50199
50200 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50201 PyObject *resultobj = 0;
50202 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50203 wxRect result;
50204 void *argp1 = 0 ;
50205 int res1 = 0 ;
50206 PyObject *swig_obj[1] ;
50207
50208 if (!args) SWIG_fail;
50209 swig_obj[0] = args;
50210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50211 if (!SWIG_IsOK(res1)) {
50212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50213 }
50214 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50215 {
50216 PyThreadState* __tstate = wxPyBeginAllowThreads();
50217 result = (arg1)->GetRect();
50218 wxPyEndAllowThreads(__tstate);
50219 if (PyErr_Occurred()) SWIG_fail;
50220 }
50221 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
50222 return resultobj;
50223 fail:
50224 return NULL;
50225 }
50226
50227
50228 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50229 PyObject *resultobj = 0;
50230 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50231 bool result;
50232 void *argp1 = 0 ;
50233 int res1 = 0 ;
50234 PyObject *swig_obj[1] ;
50235
50236 if (!args) SWIG_fail;
50237 swig_obj[0] = args;
50238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50239 if (!SWIG_IsOK(res1)) {
50240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50241 }
50242 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50243 {
50244 PyThreadState* __tstate = wxPyBeginAllowThreads();
50245 result = (bool)(arg1)->IsWindow();
50246 wxPyEndAllowThreads(__tstate);
50247 if (PyErr_Occurred()) SWIG_fail;
50248 }
50249 {
50250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50251 }
50252 return resultobj;
50253 fail:
50254 return NULL;
50255 }
50256
50257
50258 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50259 PyObject *resultobj = 0;
50260 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50261 bool result;
50262 void *argp1 = 0 ;
50263 int res1 = 0 ;
50264 PyObject *swig_obj[1] ;
50265
50266 if (!args) SWIG_fail;
50267 swig_obj[0] = args;
50268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50269 if (!SWIG_IsOK(res1)) {
50270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50271 }
50272 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50273 {
50274 PyThreadState* __tstate = wxPyBeginAllowThreads();
50275 result = (bool)(arg1)->IsSizer();
50276 wxPyEndAllowThreads(__tstate);
50277 if (PyErr_Occurred()) SWIG_fail;
50278 }
50279 {
50280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50281 }
50282 return resultobj;
50283 fail:
50284 return NULL;
50285 }
50286
50287
50288 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50289 PyObject *resultobj = 0;
50290 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50291 bool result;
50292 void *argp1 = 0 ;
50293 int res1 = 0 ;
50294 PyObject *swig_obj[1] ;
50295
50296 if (!args) SWIG_fail;
50297 swig_obj[0] = args;
50298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50299 if (!SWIG_IsOK(res1)) {
50300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50301 }
50302 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50303 {
50304 PyThreadState* __tstate = wxPyBeginAllowThreads();
50305 result = (bool)(arg1)->IsSpacer();
50306 wxPyEndAllowThreads(__tstate);
50307 if (PyErr_Occurred()) SWIG_fail;
50308 }
50309 {
50310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50311 }
50312 return resultobj;
50313 fail:
50314 return NULL;
50315 }
50316
50317
50318 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50319 PyObject *resultobj = 0;
50320 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50321 int arg2 ;
50322 void *argp1 = 0 ;
50323 int res1 = 0 ;
50324 int val2 ;
50325 int ecode2 = 0 ;
50326 PyObject * obj0 = 0 ;
50327 PyObject * obj1 = 0 ;
50328 char * kwnames[] = {
50329 (char *) "self",(char *) "proportion", NULL
50330 };
50331
50332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
50333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50334 if (!SWIG_IsOK(res1)) {
50335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50336 }
50337 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50338 ecode2 = SWIG_AsVal_int(obj1, &val2);
50339 if (!SWIG_IsOK(ecode2)) {
50340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
50341 }
50342 arg2 = static_cast< int >(val2);
50343 {
50344 PyThreadState* __tstate = wxPyBeginAllowThreads();
50345 (arg1)->SetProportion(arg2);
50346 wxPyEndAllowThreads(__tstate);
50347 if (PyErr_Occurred()) SWIG_fail;
50348 }
50349 resultobj = SWIG_Py_Void();
50350 return resultobj;
50351 fail:
50352 return NULL;
50353 }
50354
50355
50356 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50357 PyObject *resultobj = 0;
50358 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50359 int result;
50360 void *argp1 = 0 ;
50361 int res1 = 0 ;
50362 PyObject *swig_obj[1] ;
50363
50364 if (!args) SWIG_fail;
50365 swig_obj[0] = args;
50366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50367 if (!SWIG_IsOK(res1)) {
50368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50369 }
50370 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50371 {
50372 PyThreadState* __tstate = wxPyBeginAllowThreads();
50373 result = (int)(arg1)->GetProportion();
50374 wxPyEndAllowThreads(__tstate);
50375 if (PyErr_Occurred()) SWIG_fail;
50376 }
50377 resultobj = SWIG_From_int(static_cast< int >(result));
50378 return resultobj;
50379 fail:
50380 return NULL;
50381 }
50382
50383
50384 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50385 PyObject *resultobj = 0;
50386 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50387 int arg2 ;
50388 void *argp1 = 0 ;
50389 int res1 = 0 ;
50390 int val2 ;
50391 int ecode2 = 0 ;
50392 PyObject * obj0 = 0 ;
50393 PyObject * obj1 = 0 ;
50394 char * kwnames[] = {
50395 (char *) "self",(char *) "flag", NULL
50396 };
50397
50398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
50399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50400 if (!SWIG_IsOK(res1)) {
50401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50402 }
50403 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50404 ecode2 = SWIG_AsVal_int(obj1, &val2);
50405 if (!SWIG_IsOK(ecode2)) {
50406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
50407 }
50408 arg2 = static_cast< int >(val2);
50409 {
50410 PyThreadState* __tstate = wxPyBeginAllowThreads();
50411 (arg1)->SetFlag(arg2);
50412 wxPyEndAllowThreads(__tstate);
50413 if (PyErr_Occurred()) SWIG_fail;
50414 }
50415 resultobj = SWIG_Py_Void();
50416 return resultobj;
50417 fail:
50418 return NULL;
50419 }
50420
50421
50422 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50423 PyObject *resultobj = 0;
50424 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50425 int result;
50426 void *argp1 = 0 ;
50427 int res1 = 0 ;
50428 PyObject *swig_obj[1] ;
50429
50430 if (!args) SWIG_fail;
50431 swig_obj[0] = args;
50432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50433 if (!SWIG_IsOK(res1)) {
50434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50435 }
50436 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50437 {
50438 PyThreadState* __tstate = wxPyBeginAllowThreads();
50439 result = (int)(arg1)->GetFlag();
50440 wxPyEndAllowThreads(__tstate);
50441 if (PyErr_Occurred()) SWIG_fail;
50442 }
50443 resultobj = SWIG_From_int(static_cast< int >(result));
50444 return resultobj;
50445 fail:
50446 return NULL;
50447 }
50448
50449
50450 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50451 PyObject *resultobj = 0;
50452 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50453 int arg2 ;
50454 void *argp1 = 0 ;
50455 int res1 = 0 ;
50456 int val2 ;
50457 int ecode2 = 0 ;
50458 PyObject * obj0 = 0 ;
50459 PyObject * obj1 = 0 ;
50460 char * kwnames[] = {
50461 (char *) "self",(char *) "border", NULL
50462 };
50463
50464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
50465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50466 if (!SWIG_IsOK(res1)) {
50467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50468 }
50469 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50470 ecode2 = SWIG_AsVal_int(obj1, &val2);
50471 if (!SWIG_IsOK(ecode2)) {
50472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
50473 }
50474 arg2 = static_cast< int >(val2);
50475 {
50476 PyThreadState* __tstate = wxPyBeginAllowThreads();
50477 (arg1)->SetBorder(arg2);
50478 wxPyEndAllowThreads(__tstate);
50479 if (PyErr_Occurred()) SWIG_fail;
50480 }
50481 resultobj = SWIG_Py_Void();
50482 return resultobj;
50483 fail:
50484 return NULL;
50485 }
50486
50487
50488 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50489 PyObject *resultobj = 0;
50490 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50491 int result;
50492 void *argp1 = 0 ;
50493 int res1 = 0 ;
50494 PyObject *swig_obj[1] ;
50495
50496 if (!args) SWIG_fail;
50497 swig_obj[0] = args;
50498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50499 if (!SWIG_IsOK(res1)) {
50500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50501 }
50502 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50503 {
50504 PyThreadState* __tstate = wxPyBeginAllowThreads();
50505 result = (int)(arg1)->GetBorder();
50506 wxPyEndAllowThreads(__tstate);
50507 if (PyErr_Occurred()) SWIG_fail;
50508 }
50509 resultobj = SWIG_From_int(static_cast< int >(result));
50510 return resultobj;
50511 fail:
50512 return NULL;
50513 }
50514
50515
50516 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50517 PyObject *resultobj = 0;
50518 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50519 wxWindow *result = 0 ;
50520 void *argp1 = 0 ;
50521 int res1 = 0 ;
50522 PyObject *swig_obj[1] ;
50523
50524 if (!args) SWIG_fail;
50525 swig_obj[0] = args;
50526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50527 if (!SWIG_IsOK(res1)) {
50528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50529 }
50530 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50531 {
50532 PyThreadState* __tstate = wxPyBeginAllowThreads();
50533 result = (wxWindow *)(arg1)->GetWindow();
50534 wxPyEndAllowThreads(__tstate);
50535 if (PyErr_Occurred()) SWIG_fail;
50536 }
50537 {
50538 resultobj = wxPyMake_wxObject(result, 0);
50539 }
50540 return resultobj;
50541 fail:
50542 return NULL;
50543 }
50544
50545
50546 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50547 PyObject *resultobj = 0;
50548 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50549 wxSizer *result = 0 ;
50550 void *argp1 = 0 ;
50551 int res1 = 0 ;
50552 PyObject *swig_obj[1] ;
50553
50554 if (!args) SWIG_fail;
50555 swig_obj[0] = args;
50556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50557 if (!SWIG_IsOK(res1)) {
50558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50559 }
50560 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50561 {
50562 PyThreadState* __tstate = wxPyBeginAllowThreads();
50563 result = (wxSizer *)(arg1)->GetSizer();
50564 wxPyEndAllowThreads(__tstate);
50565 if (PyErr_Occurred()) SWIG_fail;
50566 }
50567 {
50568 resultobj = wxPyMake_wxObject(result, (bool)0);
50569 }
50570 return resultobj;
50571 fail:
50572 return NULL;
50573 }
50574
50575
50576 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50577 PyObject *resultobj = 0;
50578 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50579 wxSize result;
50580 void *argp1 = 0 ;
50581 int res1 = 0 ;
50582 PyObject *swig_obj[1] ;
50583
50584 if (!args) SWIG_fail;
50585 swig_obj[0] = args;
50586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50587 if (!SWIG_IsOK(res1)) {
50588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50589 }
50590 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50591 {
50592 PyThreadState* __tstate = wxPyBeginAllowThreads();
50593 result = (arg1)->GetSpacer();
50594 wxPyEndAllowThreads(__tstate);
50595 if (PyErr_Occurred()) SWIG_fail;
50596 }
50597 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50598 return resultobj;
50599 fail:
50600 return NULL;
50601 }
50602
50603
50604 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50605 PyObject *resultobj = 0;
50606 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50607 wxWindow *arg2 = (wxWindow *) 0 ;
50608 void *argp1 = 0 ;
50609 int res1 = 0 ;
50610 void *argp2 = 0 ;
50611 int res2 = 0 ;
50612 PyObject * obj0 = 0 ;
50613 PyObject * obj1 = 0 ;
50614 char * kwnames[] = {
50615 (char *) "self",(char *) "window", NULL
50616 };
50617
50618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50620 if (!SWIG_IsOK(res1)) {
50621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50622 }
50623 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50624 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50625 if (!SWIG_IsOK(res2)) {
50626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50627 }
50628 arg2 = reinterpret_cast< wxWindow * >(argp2);
50629 {
50630 PyThreadState* __tstate = wxPyBeginAllowThreads();
50631 (arg1)->SetWindow(arg2);
50632 wxPyEndAllowThreads(__tstate);
50633 if (PyErr_Occurred()) SWIG_fail;
50634 }
50635 resultobj = SWIG_Py_Void();
50636 return resultobj;
50637 fail:
50638 return NULL;
50639 }
50640
50641
50642 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50643 PyObject *resultobj = 0;
50644 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50645 wxSizer *arg2 = (wxSizer *) 0 ;
50646 void *argp1 = 0 ;
50647 int res1 = 0 ;
50648 int res2 = 0 ;
50649 PyObject * obj0 = 0 ;
50650 PyObject * obj1 = 0 ;
50651 char * kwnames[] = {
50652 (char *) "self",(char *) "sizer", NULL
50653 };
50654
50655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50657 if (!SWIG_IsOK(res1)) {
50658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50659 }
50660 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50661 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50662 if (!SWIG_IsOK(res2)) {
50663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50664 }
50665 {
50666 PyThreadState* __tstate = wxPyBeginAllowThreads();
50667 (arg1)->SetSizer(arg2);
50668 wxPyEndAllowThreads(__tstate);
50669 if (PyErr_Occurred()) SWIG_fail;
50670 }
50671 resultobj = SWIG_Py_Void();
50672 return resultobj;
50673 fail:
50674 return NULL;
50675 }
50676
50677
50678 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50679 PyObject *resultobj = 0;
50680 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50681 wxSize *arg2 = 0 ;
50682 void *argp1 = 0 ;
50683 int res1 = 0 ;
50684 wxSize temp2 ;
50685 PyObject * obj0 = 0 ;
50686 PyObject * obj1 = 0 ;
50687 char * kwnames[] = {
50688 (char *) "self",(char *) "size", NULL
50689 };
50690
50691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
50692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50693 if (!SWIG_IsOK(res1)) {
50694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50695 }
50696 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50697 {
50698 arg2 = &temp2;
50699 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50700 }
50701 {
50702 PyThreadState* __tstate = wxPyBeginAllowThreads();
50703 (arg1)->SetSpacer((wxSize const &)*arg2);
50704 wxPyEndAllowThreads(__tstate);
50705 if (PyErr_Occurred()) SWIG_fail;
50706 }
50707 resultobj = SWIG_Py_Void();
50708 return resultobj;
50709 fail:
50710 return NULL;
50711 }
50712
50713
50714 SWIGINTERN PyObject *_wrap_SizerItem_AssignWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50715 PyObject *resultobj = 0;
50716 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50717 wxWindow *arg2 = (wxWindow *) 0 ;
50718 void *argp1 = 0 ;
50719 int res1 = 0 ;
50720 void *argp2 = 0 ;
50721 int res2 = 0 ;
50722 PyObject * obj0 = 0 ;
50723 PyObject * obj1 = 0 ;
50724 char * kwnames[] = {
50725 (char *) "self",(char *) "window", NULL
50726 };
50727
50728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50730 if (!SWIG_IsOK(res1)) {
50731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50732 }
50733 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50734 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50735 if (!SWIG_IsOK(res2)) {
50736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_AssignWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50737 }
50738 arg2 = reinterpret_cast< wxWindow * >(argp2);
50739 {
50740 PyThreadState* __tstate = wxPyBeginAllowThreads();
50741 (arg1)->AssignWindow(arg2);
50742 wxPyEndAllowThreads(__tstate);
50743 if (PyErr_Occurred()) SWIG_fail;
50744 }
50745 resultobj = SWIG_Py_Void();
50746 return resultobj;
50747 fail:
50748 return NULL;
50749 }
50750
50751
50752 SWIGINTERN PyObject *_wrap_SizerItem_AssignSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50753 PyObject *resultobj = 0;
50754 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50755 wxSizer *arg2 = (wxSizer *) 0 ;
50756 void *argp1 = 0 ;
50757 int res1 = 0 ;
50758 void *argp2 = 0 ;
50759 int res2 = 0 ;
50760 PyObject * obj0 = 0 ;
50761 PyObject * obj1 = 0 ;
50762 char * kwnames[] = {
50763 (char *) "self",(char *) "sizer", NULL
50764 };
50765
50766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50768 if (!SWIG_IsOK(res1)) {
50769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50770 }
50771 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50772 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50773 if (!SWIG_IsOK(res2)) {
50774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_AssignSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50775 }
50776 arg2 = reinterpret_cast< wxSizer * >(argp2);
50777 {
50778 PyThreadState* __tstate = wxPyBeginAllowThreads();
50779 (arg1)->AssignSizer(arg2);
50780 wxPyEndAllowThreads(__tstate);
50781 if (PyErr_Occurred()) SWIG_fail;
50782 }
50783 resultobj = SWIG_Py_Void();
50784 return resultobj;
50785 fail:
50786 return NULL;
50787 }
50788
50789
50790 SWIGINTERN PyObject *_wrap_SizerItem_AssignSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50791 PyObject *resultobj = 0;
50792 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50793 wxSize *arg2 = 0 ;
50794 void *argp1 = 0 ;
50795 int res1 = 0 ;
50796 wxSize temp2 ;
50797 PyObject * obj0 = 0 ;
50798 PyObject * obj1 = 0 ;
50799 char * kwnames[] = {
50800 (char *) "self",(char *) "size", NULL
50801 };
50802
50803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
50804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50805 if (!SWIG_IsOK(res1)) {
50806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50807 }
50808 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50809 {
50810 arg2 = &temp2;
50811 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50812 }
50813 {
50814 PyThreadState* __tstate = wxPyBeginAllowThreads();
50815 (arg1)->AssignSpacer((wxSize const &)*arg2);
50816 wxPyEndAllowThreads(__tstate);
50817 if (PyErr_Occurred()) SWIG_fail;
50818 }
50819 resultobj = SWIG_Py_Void();
50820 return resultobj;
50821 fail:
50822 return NULL;
50823 }
50824
50825
50826 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50827 PyObject *resultobj = 0;
50828 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50829 bool arg2 ;
50830 void *argp1 = 0 ;
50831 int res1 = 0 ;
50832 bool val2 ;
50833 int ecode2 = 0 ;
50834 PyObject * obj0 = 0 ;
50835 PyObject * obj1 = 0 ;
50836 char * kwnames[] = {
50837 (char *) "self",(char *) "show", NULL
50838 };
50839
50840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
50841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50842 if (!SWIG_IsOK(res1)) {
50843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50844 }
50845 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50846 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50847 if (!SWIG_IsOK(ecode2)) {
50848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
50849 }
50850 arg2 = static_cast< bool >(val2);
50851 {
50852 PyThreadState* __tstate = wxPyBeginAllowThreads();
50853 (arg1)->Show(arg2);
50854 wxPyEndAllowThreads(__tstate);
50855 if (PyErr_Occurred()) SWIG_fail;
50856 }
50857 resultobj = SWIG_Py_Void();
50858 return resultobj;
50859 fail:
50860 return NULL;
50861 }
50862
50863
50864 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50865 PyObject *resultobj = 0;
50866 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50867 bool result;
50868 void *argp1 = 0 ;
50869 int res1 = 0 ;
50870 PyObject *swig_obj[1] ;
50871
50872 if (!args) SWIG_fail;
50873 swig_obj[0] = args;
50874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50875 if (!SWIG_IsOK(res1)) {
50876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50877 }
50878 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50879 {
50880 PyThreadState* __tstate = wxPyBeginAllowThreads();
50881 result = (bool)(arg1)->IsShown();
50882 wxPyEndAllowThreads(__tstate);
50883 if (PyErr_Occurred()) SWIG_fail;
50884 }
50885 {
50886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50887 }
50888 return resultobj;
50889 fail:
50890 return NULL;
50891 }
50892
50893
50894 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50895 PyObject *resultobj = 0;
50896 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50897 wxPoint result;
50898 void *argp1 = 0 ;
50899 int res1 = 0 ;
50900 PyObject *swig_obj[1] ;
50901
50902 if (!args) SWIG_fail;
50903 swig_obj[0] = args;
50904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50905 if (!SWIG_IsOK(res1)) {
50906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50907 }
50908 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50909 {
50910 PyThreadState* __tstate = wxPyBeginAllowThreads();
50911 result = (arg1)->GetPosition();
50912 wxPyEndAllowThreads(__tstate);
50913 if (PyErr_Occurred()) SWIG_fail;
50914 }
50915 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50916 return resultobj;
50917 fail:
50918 return NULL;
50919 }
50920
50921
50922 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50923 PyObject *resultobj = 0;
50924 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50925 PyObject *result = 0 ;
50926 void *argp1 = 0 ;
50927 int res1 = 0 ;
50928 PyObject *swig_obj[1] ;
50929
50930 if (!args) SWIG_fail;
50931 swig_obj[0] = args;
50932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50933 if (!SWIG_IsOK(res1)) {
50934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50935 }
50936 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50937 {
50938 PyThreadState* __tstate = wxPyBeginAllowThreads();
50939 result = (PyObject *)wxSizerItem_GetUserData(arg1);
50940 wxPyEndAllowThreads(__tstate);
50941 if (PyErr_Occurred()) SWIG_fail;
50942 }
50943 resultobj = result;
50944 return resultobj;
50945 fail:
50946 return NULL;
50947 }
50948
50949
50950 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50951 PyObject *resultobj = 0;
50952 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50953 PyObject *arg2 = (PyObject *) 0 ;
50954 void *argp1 = 0 ;
50955 int res1 = 0 ;
50956 PyObject * obj0 = 0 ;
50957 PyObject * obj1 = 0 ;
50958 char * kwnames[] = {
50959 (char *) "self",(char *) "userData", NULL
50960 };
50961
50962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
50963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50964 if (!SWIG_IsOK(res1)) {
50965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50966 }
50967 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50968 arg2 = obj1;
50969 {
50970 PyThreadState* __tstate = wxPyBeginAllowThreads();
50971 wxSizerItem_SetUserData(arg1,arg2);
50972 wxPyEndAllowThreads(__tstate);
50973 if (PyErr_Occurred()) SWIG_fail;
50974 }
50975 resultobj = SWIG_Py_Void();
50976 return resultobj;
50977 fail:
50978 return NULL;
50979 }
50980
50981
50982 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50983 PyObject *obj;
50984 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50985 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
50986 return SWIG_Py_Void();
50987 }
50988
50989 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50990 return SWIG_Python_InitShadowInstance(args);
50991 }
50992
50993 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50994 PyObject *resultobj = 0;
50995 wxSizer *arg1 = (wxSizer *) 0 ;
50996 void *argp1 = 0 ;
50997 int res1 = 0 ;
50998 PyObject *swig_obj[1] ;
50999
51000 if (!args) SWIG_fail;
51001 swig_obj[0] = args;
51002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51003 if (!SWIG_IsOK(res1)) {
51004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51005 }
51006 arg1 = reinterpret_cast< wxSizer * >(argp1);
51007 {
51008 PyThreadState* __tstate = wxPyBeginAllowThreads();
51009 delete arg1;
51010
51011 wxPyEndAllowThreads(__tstate);
51012 if (PyErr_Occurred()) SWIG_fail;
51013 }
51014 resultobj = SWIG_Py_Void();
51015 return resultobj;
51016 fail:
51017 return NULL;
51018 }
51019
51020
51021 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51022 PyObject *resultobj = 0;
51023 wxSizer *arg1 = (wxSizer *) 0 ;
51024 PyObject *arg2 = (PyObject *) 0 ;
51025 void *argp1 = 0 ;
51026 int res1 = 0 ;
51027 PyObject * obj0 = 0 ;
51028 PyObject * obj1 = 0 ;
51029 char * kwnames[] = {
51030 (char *) "self",(char *) "_self", NULL
51031 };
51032
51033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
51034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51035 if (!SWIG_IsOK(res1)) {
51036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
51037 }
51038 arg1 = reinterpret_cast< wxSizer * >(argp1);
51039 arg2 = obj1;
51040 {
51041 PyThreadState* __tstate = wxPyBeginAllowThreads();
51042 wxSizer__setOORInfo(arg1,arg2);
51043 wxPyEndAllowThreads(__tstate);
51044 if (PyErr_Occurred()) SWIG_fail;
51045 }
51046 resultobj = SWIG_Py_Void();
51047 return resultobj;
51048 fail:
51049 return NULL;
51050 }
51051
51052
51053 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51054 PyObject *resultobj = 0;
51055 wxSizer *arg1 = (wxSizer *) 0 ;
51056 PyObject *arg2 = (PyObject *) 0 ;
51057 int arg3 = (int) 0 ;
51058 int arg4 = (int) 0 ;
51059 int arg5 = (int) 0 ;
51060 PyObject *arg6 = (PyObject *) NULL ;
51061 wxSizerItem *result = 0 ;
51062 void *argp1 = 0 ;
51063 int res1 = 0 ;
51064 int val3 ;
51065 int ecode3 = 0 ;
51066 int val4 ;
51067 int ecode4 = 0 ;
51068 int val5 ;
51069 int ecode5 = 0 ;
51070 PyObject * obj0 = 0 ;
51071 PyObject * obj1 = 0 ;
51072 PyObject * obj2 = 0 ;
51073 PyObject * obj3 = 0 ;
51074 PyObject * obj4 = 0 ;
51075 PyObject * obj5 = 0 ;
51076 char * kwnames[] = {
51077 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51078 };
51079
51080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51082 if (!SWIG_IsOK(res1)) {
51083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
51084 }
51085 arg1 = reinterpret_cast< wxSizer * >(argp1);
51086 arg2 = obj1;
51087 if (obj2) {
51088 ecode3 = SWIG_AsVal_int(obj2, &val3);
51089 if (!SWIG_IsOK(ecode3)) {
51090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
51091 }
51092 arg3 = static_cast< int >(val3);
51093 }
51094 if (obj3) {
51095 ecode4 = SWIG_AsVal_int(obj3, &val4);
51096 if (!SWIG_IsOK(ecode4)) {
51097 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
51098 }
51099 arg4 = static_cast< int >(val4);
51100 }
51101 if (obj4) {
51102 ecode5 = SWIG_AsVal_int(obj4, &val5);
51103 if (!SWIG_IsOK(ecode5)) {
51104 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
51105 }
51106 arg5 = static_cast< int >(val5);
51107 }
51108 if (obj5) {
51109 arg6 = obj5;
51110 }
51111 {
51112 PyThreadState* __tstate = wxPyBeginAllowThreads();
51113 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
51114 wxPyEndAllowThreads(__tstate);
51115 if (PyErr_Occurred()) SWIG_fail;
51116 }
51117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51118 return resultobj;
51119 fail:
51120 return NULL;
51121 }
51122
51123
51124 SWIGINTERN PyObject *_wrap_Sizer_AddF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51125 PyObject *resultobj = 0;
51126 wxSizer *arg1 = (wxSizer *) 0 ;
51127 PyObject *arg2 = (PyObject *) 0 ;
51128 wxSizerFlags *arg3 = 0 ;
51129 wxSizerItem *result = 0 ;
51130 void *argp1 = 0 ;
51131 int res1 = 0 ;
51132 void *argp3 = 0 ;
51133 int res3 = 0 ;
51134 PyObject * obj0 = 0 ;
51135 PyObject * obj1 = 0 ;
51136 PyObject * obj2 = 0 ;
51137 char * kwnames[] = {
51138 (char *) "self",(char *) "item",(char *) "flags", NULL
51139 };
51140
51141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_AddF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51143 if (!SWIG_IsOK(res1)) {
51144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddF" "', expected argument " "1"" of type '" "wxSizer *""'");
51145 }
51146 arg1 = reinterpret_cast< wxSizer * >(argp1);
51147 arg2 = obj1;
51148 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51149 if (!SWIG_IsOK(res3)) {
51150 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51151 }
51152 if (!argp3) {
51153 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51154 }
51155 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51156 {
51157 PyThreadState* __tstate = wxPyBeginAllowThreads();
51158 result = (wxSizerItem *)wxSizer_AddF(arg1,arg2,*arg3);
51159 wxPyEndAllowThreads(__tstate);
51160 if (PyErr_Occurred()) SWIG_fail;
51161 }
51162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51163 return resultobj;
51164 fail:
51165 return NULL;
51166 }
51167
51168
51169 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51170 PyObject *resultobj = 0;
51171 wxSizer *arg1 = (wxSizer *) 0 ;
51172 int arg2 ;
51173 PyObject *arg3 = (PyObject *) 0 ;
51174 int arg4 = (int) 0 ;
51175 int arg5 = (int) 0 ;
51176 int arg6 = (int) 0 ;
51177 PyObject *arg7 = (PyObject *) NULL ;
51178 wxSizerItem *result = 0 ;
51179 void *argp1 = 0 ;
51180 int res1 = 0 ;
51181 int val2 ;
51182 int ecode2 = 0 ;
51183 int val4 ;
51184 int ecode4 = 0 ;
51185 int val5 ;
51186 int ecode5 = 0 ;
51187 int val6 ;
51188 int ecode6 = 0 ;
51189 PyObject * obj0 = 0 ;
51190 PyObject * obj1 = 0 ;
51191 PyObject * obj2 = 0 ;
51192 PyObject * obj3 = 0 ;
51193 PyObject * obj4 = 0 ;
51194 PyObject * obj5 = 0 ;
51195 PyObject * obj6 = 0 ;
51196 char * kwnames[] = {
51197 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51198 };
51199
51200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51202 if (!SWIG_IsOK(res1)) {
51203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
51204 }
51205 arg1 = reinterpret_cast< wxSizer * >(argp1);
51206 ecode2 = SWIG_AsVal_int(obj1, &val2);
51207 if (!SWIG_IsOK(ecode2)) {
51208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
51209 }
51210 arg2 = static_cast< int >(val2);
51211 arg3 = obj2;
51212 if (obj3) {
51213 ecode4 = SWIG_AsVal_int(obj3, &val4);
51214 if (!SWIG_IsOK(ecode4)) {
51215 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
51216 }
51217 arg4 = static_cast< int >(val4);
51218 }
51219 if (obj4) {
51220 ecode5 = SWIG_AsVal_int(obj4, &val5);
51221 if (!SWIG_IsOK(ecode5)) {
51222 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
51223 }
51224 arg5 = static_cast< int >(val5);
51225 }
51226 if (obj5) {
51227 ecode6 = SWIG_AsVal_int(obj5, &val6);
51228 if (!SWIG_IsOK(ecode6)) {
51229 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
51230 }
51231 arg6 = static_cast< int >(val6);
51232 }
51233 if (obj6) {
51234 arg7 = obj6;
51235 }
51236 {
51237 PyThreadState* __tstate = wxPyBeginAllowThreads();
51238 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
51239 wxPyEndAllowThreads(__tstate);
51240 if (PyErr_Occurred()) SWIG_fail;
51241 }
51242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51243 return resultobj;
51244 fail:
51245 return NULL;
51246 }
51247
51248
51249 SWIGINTERN PyObject *_wrap_Sizer_InsertF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51250 PyObject *resultobj = 0;
51251 wxSizer *arg1 = (wxSizer *) 0 ;
51252 int arg2 ;
51253 PyObject *arg3 = (PyObject *) 0 ;
51254 wxSizerFlags *arg4 = 0 ;
51255 wxSizerItem *result = 0 ;
51256 void *argp1 = 0 ;
51257 int res1 = 0 ;
51258 int val2 ;
51259 int ecode2 = 0 ;
51260 void *argp4 = 0 ;
51261 int res4 = 0 ;
51262 PyObject * obj0 = 0 ;
51263 PyObject * obj1 = 0 ;
51264 PyObject * obj2 = 0 ;
51265 PyObject * obj3 = 0 ;
51266 char * kwnames[] = {
51267 (char *) "self",(char *) "before",(char *) "item",(char *) "flags", NULL
51268 };
51269
51270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Sizer_InsertF",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51272 if (!SWIG_IsOK(res1)) {
51273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertF" "', expected argument " "1"" of type '" "wxSizer *""'");
51274 }
51275 arg1 = reinterpret_cast< wxSizer * >(argp1);
51276 ecode2 = SWIG_AsVal_int(obj1, &val2);
51277 if (!SWIG_IsOK(ecode2)) {
51278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertF" "', expected argument " "2"" of type '" "int""'");
51279 }
51280 arg2 = static_cast< int >(val2);
51281 arg3 = obj2;
51282 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxSizerFlags, 0 );
51283 if (!SWIG_IsOK(res4)) {
51284 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51285 }
51286 if (!argp4) {
51287 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51288 }
51289 arg4 = reinterpret_cast< wxSizerFlags * >(argp4);
51290 {
51291 PyThreadState* __tstate = wxPyBeginAllowThreads();
51292 result = (wxSizerItem *)wxSizer_InsertF(arg1,arg2,arg3,*arg4);
51293 wxPyEndAllowThreads(__tstate);
51294 if (PyErr_Occurred()) SWIG_fail;
51295 }
51296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51297 return resultobj;
51298 fail:
51299 return NULL;
51300 }
51301
51302
51303 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51304 PyObject *resultobj = 0;
51305 wxSizer *arg1 = (wxSizer *) 0 ;
51306 PyObject *arg2 = (PyObject *) 0 ;
51307 int arg3 = (int) 0 ;
51308 int arg4 = (int) 0 ;
51309 int arg5 = (int) 0 ;
51310 PyObject *arg6 = (PyObject *) NULL ;
51311 wxSizerItem *result = 0 ;
51312 void *argp1 = 0 ;
51313 int res1 = 0 ;
51314 int val3 ;
51315 int ecode3 = 0 ;
51316 int val4 ;
51317 int ecode4 = 0 ;
51318 int val5 ;
51319 int ecode5 = 0 ;
51320 PyObject * obj0 = 0 ;
51321 PyObject * obj1 = 0 ;
51322 PyObject * obj2 = 0 ;
51323 PyObject * obj3 = 0 ;
51324 PyObject * obj4 = 0 ;
51325 PyObject * obj5 = 0 ;
51326 char * kwnames[] = {
51327 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51328 };
51329
51330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51332 if (!SWIG_IsOK(res1)) {
51333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
51334 }
51335 arg1 = reinterpret_cast< wxSizer * >(argp1);
51336 arg2 = obj1;
51337 if (obj2) {
51338 ecode3 = SWIG_AsVal_int(obj2, &val3);
51339 if (!SWIG_IsOK(ecode3)) {
51340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
51341 }
51342 arg3 = static_cast< int >(val3);
51343 }
51344 if (obj3) {
51345 ecode4 = SWIG_AsVal_int(obj3, &val4);
51346 if (!SWIG_IsOK(ecode4)) {
51347 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
51348 }
51349 arg4 = static_cast< int >(val4);
51350 }
51351 if (obj4) {
51352 ecode5 = SWIG_AsVal_int(obj4, &val5);
51353 if (!SWIG_IsOK(ecode5)) {
51354 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
51355 }
51356 arg5 = static_cast< int >(val5);
51357 }
51358 if (obj5) {
51359 arg6 = obj5;
51360 }
51361 {
51362 PyThreadState* __tstate = wxPyBeginAllowThreads();
51363 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
51364 wxPyEndAllowThreads(__tstate);
51365 if (PyErr_Occurred()) SWIG_fail;
51366 }
51367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51368 return resultobj;
51369 fail:
51370 return NULL;
51371 }
51372
51373
51374 SWIGINTERN PyObject *_wrap_Sizer_PrependF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51375 PyObject *resultobj = 0;
51376 wxSizer *arg1 = (wxSizer *) 0 ;
51377 PyObject *arg2 = (PyObject *) 0 ;
51378 wxSizerFlags *arg3 = 0 ;
51379 wxSizerItem *result = 0 ;
51380 void *argp1 = 0 ;
51381 int res1 = 0 ;
51382 void *argp3 = 0 ;
51383 int res3 = 0 ;
51384 PyObject * obj0 = 0 ;
51385 PyObject * obj1 = 0 ;
51386 PyObject * obj2 = 0 ;
51387 char * kwnames[] = {
51388 (char *) "self",(char *) "item",(char *) "flags", NULL
51389 };
51390
51391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_PrependF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51393 if (!SWIG_IsOK(res1)) {
51394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependF" "', expected argument " "1"" of type '" "wxSizer *""'");
51395 }
51396 arg1 = reinterpret_cast< wxSizer * >(argp1);
51397 arg2 = obj1;
51398 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51399 if (!SWIG_IsOK(res3)) {
51400 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51401 }
51402 if (!argp3) {
51403 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51404 }
51405 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51406 {
51407 PyThreadState* __tstate = wxPyBeginAllowThreads();
51408 result = (wxSizerItem *)wxSizer_PrependF(arg1,arg2,*arg3);
51409 wxPyEndAllowThreads(__tstate);
51410 if (PyErr_Occurred()) SWIG_fail;
51411 }
51412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51413 return resultobj;
51414 fail:
51415 return NULL;
51416 }
51417
51418
51419 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51420 PyObject *resultobj = 0;
51421 wxSizer *arg1 = (wxSizer *) 0 ;
51422 PyObject *arg2 = (PyObject *) 0 ;
51423 bool result;
51424 void *argp1 = 0 ;
51425 int res1 = 0 ;
51426 PyObject * obj0 = 0 ;
51427 PyObject * obj1 = 0 ;
51428 char * kwnames[] = {
51429 (char *) "self",(char *) "item", NULL
51430 };
51431
51432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
51433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51434 if (!SWIG_IsOK(res1)) {
51435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
51436 }
51437 arg1 = reinterpret_cast< wxSizer * >(argp1);
51438 arg2 = obj1;
51439 {
51440 PyThreadState* __tstate = wxPyBeginAllowThreads();
51441 result = (bool)wxSizer_Remove(arg1,arg2);
51442 wxPyEndAllowThreads(__tstate);
51443 if (PyErr_Occurred()) SWIG_fail;
51444 }
51445 {
51446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51447 }
51448 return resultobj;
51449 fail:
51450 return NULL;
51451 }
51452
51453
51454 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51455 PyObject *resultobj = 0;
51456 wxSizer *arg1 = (wxSizer *) 0 ;
51457 PyObject *arg2 = (PyObject *) 0 ;
51458 bool result;
51459 void *argp1 = 0 ;
51460 int res1 = 0 ;
51461 PyObject * obj0 = 0 ;
51462 PyObject * obj1 = 0 ;
51463 char * kwnames[] = {
51464 (char *) "self",(char *) "item", NULL
51465 };
51466
51467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
51468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51469 if (!SWIG_IsOK(res1)) {
51470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
51471 }
51472 arg1 = reinterpret_cast< wxSizer * >(argp1);
51473 arg2 = obj1;
51474 {
51475 PyThreadState* __tstate = wxPyBeginAllowThreads();
51476 result = (bool)wxSizer_Detach(arg1,arg2);
51477 wxPyEndAllowThreads(__tstate);
51478 if (PyErr_Occurred()) SWIG_fail;
51479 }
51480 {
51481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51482 }
51483 return resultobj;
51484 fail:
51485 return NULL;
51486 }
51487
51488
51489 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51490 PyObject *resultobj = 0;
51491 wxSizer *arg1 = (wxSizer *) 0 ;
51492 PyObject *arg2 = (PyObject *) 0 ;
51493 bool arg3 = (bool) false ;
51494 wxSizerItem *result = 0 ;
51495 void *argp1 = 0 ;
51496 int res1 = 0 ;
51497 bool val3 ;
51498 int ecode3 = 0 ;
51499 PyObject * obj0 = 0 ;
51500 PyObject * obj1 = 0 ;
51501 PyObject * obj2 = 0 ;
51502 char * kwnames[] = {
51503 (char *) "self",(char *) "item",(char *) "recursive", NULL
51504 };
51505
51506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Sizer_GetItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51508 if (!SWIG_IsOK(res1)) {
51509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51510 }
51511 arg1 = reinterpret_cast< wxSizer * >(argp1);
51512 arg2 = obj1;
51513 if (obj2) {
51514 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51515 if (!SWIG_IsOK(ecode3)) {
51516 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_GetItem" "', expected argument " "3"" of type '" "bool""'");
51517 }
51518 arg3 = static_cast< bool >(val3);
51519 }
51520 {
51521 PyThreadState* __tstate = wxPyBeginAllowThreads();
51522 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2,arg3);
51523 wxPyEndAllowThreads(__tstate);
51524 if (PyErr_Occurred()) SWIG_fail;
51525 }
51526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51527 return resultobj;
51528 fail:
51529 return NULL;
51530 }
51531
51532
51533 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51534 PyObject *resultobj = 0;
51535 wxSizer *arg1 = (wxSizer *) 0 ;
51536 PyObject *arg2 = (PyObject *) 0 ;
51537 wxSize *arg3 = 0 ;
51538 void *argp1 = 0 ;
51539 int res1 = 0 ;
51540 wxSize temp3 ;
51541 PyObject * obj0 = 0 ;
51542 PyObject * obj1 = 0 ;
51543 PyObject * obj2 = 0 ;
51544 char * kwnames[] = {
51545 (char *) "self",(char *) "item",(char *) "size", NULL
51546 };
51547
51548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51550 if (!SWIG_IsOK(res1)) {
51551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
51552 }
51553 arg1 = reinterpret_cast< wxSizer * >(argp1);
51554 arg2 = obj1;
51555 {
51556 arg3 = &temp3;
51557 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
51558 }
51559 {
51560 PyThreadState* __tstate = wxPyBeginAllowThreads();
51561 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
51562 wxPyEndAllowThreads(__tstate);
51563 if (PyErr_Occurred()) SWIG_fail;
51564 }
51565 resultobj = SWIG_Py_Void();
51566 return resultobj;
51567 fail:
51568 return NULL;
51569 }
51570
51571
51572 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51573 PyObject *resultobj = 0;
51574 wxSizer *arg1 = (wxSizer *) 0 ;
51575 wxWindow *arg2 = (wxWindow *) 0 ;
51576 wxWindow *arg3 = (wxWindow *) 0 ;
51577 bool arg4 = (bool) false ;
51578 bool result;
51579 void *argp1 = 0 ;
51580 int res1 = 0 ;
51581 void *argp2 = 0 ;
51582 int res2 = 0 ;
51583 void *argp3 = 0 ;
51584 int res3 = 0 ;
51585 bool val4 ;
51586 int ecode4 = 0 ;
51587 PyObject * obj0 = 0 ;
51588 PyObject * obj1 = 0 ;
51589 PyObject * obj2 = 0 ;
51590 PyObject * obj3 = 0 ;
51591 char * kwnames[] = {
51592 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
51593 };
51594
51595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51597 if (!SWIG_IsOK(res1)) {
51598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
51599 }
51600 arg1 = reinterpret_cast< wxSizer * >(argp1);
51601 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51602 if (!SWIG_IsOK(res2)) {
51603 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
51604 }
51605 arg2 = reinterpret_cast< wxWindow * >(argp2);
51606 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51607 if (!SWIG_IsOK(res3)) {
51608 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
51609 }
51610 arg3 = reinterpret_cast< wxWindow * >(argp3);
51611 if (obj3) {
51612 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51613 if (!SWIG_IsOK(ecode4)) {
51614 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
51615 }
51616 arg4 = static_cast< bool >(val4);
51617 }
51618 {
51619 PyThreadState* __tstate = wxPyBeginAllowThreads();
51620 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
51621 wxPyEndAllowThreads(__tstate);
51622 if (PyErr_Occurred()) SWIG_fail;
51623 }
51624 {
51625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51626 }
51627 return resultobj;
51628 fail:
51629 return NULL;
51630 }
51631
51632
51633 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51634 PyObject *resultobj = 0;
51635 wxSizer *arg1 = (wxSizer *) 0 ;
51636 wxSizer *arg2 = (wxSizer *) 0 ;
51637 wxSizer *arg3 = (wxSizer *) 0 ;
51638 bool arg4 = (bool) false ;
51639 bool result;
51640 void *argp1 = 0 ;
51641 int res1 = 0 ;
51642 void *argp2 = 0 ;
51643 int res2 = 0 ;
51644 void *argp3 = 0 ;
51645 int res3 = 0 ;
51646 bool val4 ;
51647 int ecode4 = 0 ;
51648 PyObject * obj0 = 0 ;
51649 PyObject * obj1 = 0 ;
51650 PyObject * obj2 = 0 ;
51651 PyObject * obj3 = 0 ;
51652 char * kwnames[] = {
51653 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
51654 };
51655
51656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51658 if (!SWIG_IsOK(res1)) {
51659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51660 }
51661 arg1 = reinterpret_cast< wxSizer * >(argp1);
51662 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51663 if (!SWIG_IsOK(res2)) {
51664 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
51665 }
51666 arg2 = reinterpret_cast< wxSizer * >(argp2);
51667 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
51668 if (!SWIG_IsOK(res3)) {
51669 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
51670 }
51671 arg3 = reinterpret_cast< wxSizer * >(argp3);
51672 if (obj3) {
51673 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51674 if (!SWIG_IsOK(ecode4)) {
51675 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
51676 }
51677 arg4 = static_cast< bool >(val4);
51678 }
51679 {
51680 PyThreadState* __tstate = wxPyBeginAllowThreads();
51681 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
51682 wxPyEndAllowThreads(__tstate);
51683 if (PyErr_Occurred()) SWIG_fail;
51684 }
51685 {
51686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51687 }
51688 return resultobj;
51689 fail:
51690 return NULL;
51691 }
51692
51693
51694 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51695 PyObject *resultobj = 0;
51696 wxSizer *arg1 = (wxSizer *) 0 ;
51697 size_t arg2 ;
51698 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
51699 bool result;
51700 void *argp1 = 0 ;
51701 int res1 = 0 ;
51702 size_t val2 ;
51703 int ecode2 = 0 ;
51704 void *argp3 = 0 ;
51705 int res3 = 0 ;
51706 PyObject * obj0 = 0 ;
51707 PyObject * obj1 = 0 ;
51708 PyObject * obj2 = 0 ;
51709 char * kwnames[] = {
51710 (char *) "self",(char *) "index",(char *) "newitem", NULL
51711 };
51712
51713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51715 if (!SWIG_IsOK(res1)) {
51716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51717 }
51718 arg1 = reinterpret_cast< wxSizer * >(argp1);
51719 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51720 if (!SWIG_IsOK(ecode2)) {
51721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
51722 }
51723 arg2 = static_cast< size_t >(val2);
51724 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51725 if (!SWIG_IsOK(res3)) {
51726 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
51727 }
51728 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
51729 {
51730 PyThreadState* __tstate = wxPyBeginAllowThreads();
51731 result = (bool)(arg1)->Replace(arg2,arg3);
51732 wxPyEndAllowThreads(__tstate);
51733 if (PyErr_Occurred()) SWIG_fail;
51734 }
51735 {
51736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51737 }
51738 return resultobj;
51739 fail:
51740 return NULL;
51741 }
51742
51743
51744 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51745 PyObject *resultobj = 0;
51746 wxSizer *arg1 = (wxSizer *) 0 ;
51747 wxWindow *arg2 = (wxWindow *) 0 ;
51748 void *argp1 = 0 ;
51749 int res1 = 0 ;
51750 void *argp2 = 0 ;
51751 int res2 = 0 ;
51752 PyObject * obj0 = 0 ;
51753 PyObject * obj1 = 0 ;
51754 char * kwnames[] = {
51755 (char *) "self",(char *) "window", NULL
51756 };
51757
51758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
51759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51760 if (!SWIG_IsOK(res1)) {
51761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
51762 }
51763 arg1 = reinterpret_cast< wxSizer * >(argp1);
51764 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51765 if (!SWIG_IsOK(res2)) {
51766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
51767 }
51768 arg2 = reinterpret_cast< wxWindow * >(argp2);
51769 {
51770 PyThreadState* __tstate = wxPyBeginAllowThreads();
51771 (arg1)->SetContainingWindow(arg2);
51772 wxPyEndAllowThreads(__tstate);
51773 if (PyErr_Occurred()) SWIG_fail;
51774 }
51775 resultobj = SWIG_Py_Void();
51776 return resultobj;
51777 fail:
51778 return NULL;
51779 }
51780
51781
51782 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51783 PyObject *resultobj = 0;
51784 wxSizer *arg1 = (wxSizer *) 0 ;
51785 wxWindow *result = 0 ;
51786 void *argp1 = 0 ;
51787 int res1 = 0 ;
51788 PyObject *swig_obj[1] ;
51789
51790 if (!args) SWIG_fail;
51791 swig_obj[0] = args;
51792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51793 if (!SWIG_IsOK(res1)) {
51794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
51795 }
51796 arg1 = reinterpret_cast< wxSizer * >(argp1);
51797 {
51798 PyThreadState* __tstate = wxPyBeginAllowThreads();
51799 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
51800 wxPyEndAllowThreads(__tstate);
51801 if (PyErr_Occurred()) SWIG_fail;
51802 }
51803 {
51804 resultobj = wxPyMake_wxObject(result, 0);
51805 }
51806 return resultobj;
51807 fail:
51808 return NULL;
51809 }
51810
51811
51812 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51813 PyObject *resultobj = 0;
51814 wxSizer *arg1 = (wxSizer *) 0 ;
51815 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
51816 wxSizerItem *result = 0 ;
51817 void *argp1 = 0 ;
51818 int res1 = 0 ;
51819 int res2 = 0 ;
51820 PyObject * obj0 = 0 ;
51821 PyObject * obj1 = 0 ;
51822 char * kwnames[] = {
51823 (char *) "self",(char *) "item", NULL
51824 };
51825
51826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51828 if (!SWIG_IsOK(res1)) {
51829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51830 }
51831 arg1 = reinterpret_cast< wxSizer * >(argp1);
51832 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
51833 if (!SWIG_IsOK(res2)) {
51834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
51835 }
51836 {
51837 PyThreadState* __tstate = wxPyBeginAllowThreads();
51838 result = (wxSizerItem *)(arg1)->Add(arg2);
51839 wxPyEndAllowThreads(__tstate);
51840 if (PyErr_Occurred()) SWIG_fail;
51841 }
51842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51843 return resultobj;
51844 fail:
51845 return NULL;
51846 }
51847
51848
51849 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51850 PyObject *resultobj = 0;
51851 wxSizer *arg1 = (wxSizer *) 0 ;
51852 size_t arg2 ;
51853 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
51854 wxSizerItem *result = 0 ;
51855 void *argp1 = 0 ;
51856 int res1 = 0 ;
51857 size_t val2 ;
51858 int ecode2 = 0 ;
51859 int res3 = 0 ;
51860 PyObject * obj0 = 0 ;
51861 PyObject * obj1 = 0 ;
51862 PyObject * obj2 = 0 ;
51863 char * kwnames[] = {
51864 (char *) "self",(char *) "index",(char *) "item", NULL
51865 };
51866
51867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51869 if (!SWIG_IsOK(res1)) {
51870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51871 }
51872 arg1 = reinterpret_cast< wxSizer * >(argp1);
51873 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51874 if (!SWIG_IsOK(ecode2)) {
51875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
51876 }
51877 arg2 = static_cast< size_t >(val2);
51878 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
51879 if (!SWIG_IsOK(res3)) {
51880 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
51881 }
51882 {
51883 PyThreadState* __tstate = wxPyBeginAllowThreads();
51884 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
51885 wxPyEndAllowThreads(__tstate);
51886 if (PyErr_Occurred()) SWIG_fail;
51887 }
51888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51889 return resultobj;
51890 fail:
51891 return NULL;
51892 }
51893
51894
51895 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51896 PyObject *resultobj = 0;
51897 wxSizer *arg1 = (wxSizer *) 0 ;
51898 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
51899 wxSizerItem *result = 0 ;
51900 void *argp1 = 0 ;
51901 int res1 = 0 ;
51902 int res2 = 0 ;
51903 PyObject * obj0 = 0 ;
51904 PyObject * obj1 = 0 ;
51905 char * kwnames[] = {
51906 (char *) "self",(char *) "item", NULL
51907 };
51908
51909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
51910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51911 if (!SWIG_IsOK(res1)) {
51912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51913 }
51914 arg1 = reinterpret_cast< wxSizer * >(argp1);
51915 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
51916 if (!SWIG_IsOK(res2)) {
51917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
51918 }
51919 {
51920 PyThreadState* __tstate = wxPyBeginAllowThreads();
51921 result = (wxSizerItem *)(arg1)->Prepend(arg2);
51922 wxPyEndAllowThreads(__tstate);
51923 if (PyErr_Occurred()) SWIG_fail;
51924 }
51925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51926 return resultobj;
51927 fail:
51928 return NULL;
51929 }
51930
51931
51932 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51933 PyObject *resultobj = 0;
51934 wxSizer *arg1 = (wxSizer *) 0 ;
51935 int arg2 ;
51936 int arg3 ;
51937 int arg4 ;
51938 int arg5 ;
51939 void *argp1 = 0 ;
51940 int res1 = 0 ;
51941 int val2 ;
51942 int ecode2 = 0 ;
51943 int val3 ;
51944 int ecode3 = 0 ;
51945 int val4 ;
51946 int ecode4 = 0 ;
51947 int val5 ;
51948 int ecode5 = 0 ;
51949 PyObject * obj0 = 0 ;
51950 PyObject * obj1 = 0 ;
51951 PyObject * obj2 = 0 ;
51952 PyObject * obj3 = 0 ;
51953 PyObject * obj4 = 0 ;
51954 char * kwnames[] = {
51955 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
51956 };
51957
51958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
51959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51960 if (!SWIG_IsOK(res1)) {
51961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
51962 }
51963 arg1 = reinterpret_cast< wxSizer * >(argp1);
51964 ecode2 = SWIG_AsVal_int(obj1, &val2);
51965 if (!SWIG_IsOK(ecode2)) {
51966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
51967 }
51968 arg2 = static_cast< int >(val2);
51969 ecode3 = SWIG_AsVal_int(obj2, &val3);
51970 if (!SWIG_IsOK(ecode3)) {
51971 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
51972 }
51973 arg3 = static_cast< int >(val3);
51974 ecode4 = SWIG_AsVal_int(obj3, &val4);
51975 if (!SWIG_IsOK(ecode4)) {
51976 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
51977 }
51978 arg4 = static_cast< int >(val4);
51979 ecode5 = SWIG_AsVal_int(obj4, &val5);
51980 if (!SWIG_IsOK(ecode5)) {
51981 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
51982 }
51983 arg5 = static_cast< int >(val5);
51984 {
51985 PyThreadState* __tstate = wxPyBeginAllowThreads();
51986 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
51987 wxPyEndAllowThreads(__tstate);
51988 if (PyErr_Occurred()) SWIG_fail;
51989 }
51990 resultobj = SWIG_Py_Void();
51991 return resultobj;
51992 fail:
51993 return NULL;
51994 }
51995
51996
51997 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51998 PyObject *resultobj = 0;
51999 wxSizer *arg1 = (wxSizer *) 0 ;
52000 wxSize *arg2 = 0 ;
52001 void *argp1 = 0 ;
52002 int res1 = 0 ;
52003 wxSize temp2 ;
52004 PyObject * obj0 = 0 ;
52005 PyObject * obj1 = 0 ;
52006 char * kwnames[] = {
52007 (char *) "self",(char *) "size", NULL
52008 };
52009
52010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
52011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52012 if (!SWIG_IsOK(res1)) {
52013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52014 }
52015 arg1 = reinterpret_cast< wxSizer * >(argp1);
52016 {
52017 arg2 = &temp2;
52018 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
52019 }
52020 {
52021 PyThreadState* __tstate = wxPyBeginAllowThreads();
52022 (arg1)->SetMinSize((wxSize const &)*arg2);
52023 wxPyEndAllowThreads(__tstate);
52024 if (PyErr_Occurred()) SWIG_fail;
52025 }
52026 resultobj = SWIG_Py_Void();
52027 return resultobj;
52028 fail:
52029 return NULL;
52030 }
52031
52032
52033 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52034 PyObject *resultobj = 0;
52035 wxSizer *arg1 = (wxSizer *) 0 ;
52036 wxSize result;
52037 void *argp1 = 0 ;
52038 int res1 = 0 ;
52039 PyObject *swig_obj[1] ;
52040
52041 if (!args) SWIG_fail;
52042 swig_obj[0] = args;
52043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52044 if (!SWIG_IsOK(res1)) {
52045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52046 }
52047 arg1 = reinterpret_cast< wxSizer * >(argp1);
52048 {
52049 PyThreadState* __tstate = wxPyBeginAllowThreads();
52050 result = (arg1)->GetSize();
52051 wxPyEndAllowThreads(__tstate);
52052 if (PyErr_Occurred()) SWIG_fail;
52053 }
52054 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52055 return resultobj;
52056 fail:
52057 return NULL;
52058 }
52059
52060
52061 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52062 PyObject *resultobj = 0;
52063 wxSizer *arg1 = (wxSizer *) 0 ;
52064 wxPoint result;
52065 void *argp1 = 0 ;
52066 int res1 = 0 ;
52067 PyObject *swig_obj[1] ;
52068
52069 if (!args) SWIG_fail;
52070 swig_obj[0] = args;
52071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52072 if (!SWIG_IsOK(res1)) {
52073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
52074 }
52075 arg1 = reinterpret_cast< wxSizer * >(argp1);
52076 {
52077 PyThreadState* __tstate = wxPyBeginAllowThreads();
52078 result = (arg1)->GetPosition();
52079 wxPyEndAllowThreads(__tstate);
52080 if (PyErr_Occurred()) SWIG_fail;
52081 }
52082 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
52083 return resultobj;
52084 fail:
52085 return NULL;
52086 }
52087
52088
52089 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52090 PyObject *resultobj = 0;
52091 wxSizer *arg1 = (wxSizer *) 0 ;
52092 wxSize result;
52093 void *argp1 = 0 ;
52094 int res1 = 0 ;
52095 PyObject *swig_obj[1] ;
52096
52097 if (!args) SWIG_fail;
52098 swig_obj[0] = args;
52099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52100 if (!SWIG_IsOK(res1)) {
52101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52102 }
52103 arg1 = reinterpret_cast< wxSizer * >(argp1);
52104 {
52105 PyThreadState* __tstate = wxPyBeginAllowThreads();
52106 result = (arg1)->GetMinSize();
52107 wxPyEndAllowThreads(__tstate);
52108 if (PyErr_Occurred()) SWIG_fail;
52109 }
52110 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52111 return resultobj;
52112 fail:
52113 return NULL;
52114 }
52115
52116
52117 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52118 PyObject *resultobj = 0;
52119 wxSizer *arg1 = (wxSizer *) 0 ;
52120 void *argp1 = 0 ;
52121 int res1 = 0 ;
52122 PyObject *swig_obj[1] ;
52123
52124 if (!args) SWIG_fail;
52125 swig_obj[0] = args;
52126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52127 if (!SWIG_IsOK(res1)) {
52128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
52129 }
52130 arg1 = reinterpret_cast< wxSizer * >(argp1);
52131 {
52132 PyThreadState* __tstate = wxPyBeginAllowThreads();
52133 (arg1)->RecalcSizes();
52134 wxPyEndAllowThreads(__tstate);
52135 if (PyErr_Occurred()) SWIG_fail;
52136 }
52137 resultobj = SWIG_Py_Void();
52138 return resultobj;
52139 fail:
52140 return NULL;
52141 }
52142
52143
52144 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52145 PyObject *resultobj = 0;
52146 wxSizer *arg1 = (wxSizer *) 0 ;
52147 wxSize result;
52148 void *argp1 = 0 ;
52149 int res1 = 0 ;
52150 PyObject *swig_obj[1] ;
52151
52152 if (!args) SWIG_fail;
52153 swig_obj[0] = args;
52154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52155 if (!SWIG_IsOK(res1)) {
52156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
52157 }
52158 arg1 = reinterpret_cast< wxSizer * >(argp1);
52159 {
52160 PyThreadState* __tstate = wxPyBeginAllowThreads();
52161 result = (arg1)->CalcMin();
52162 wxPyEndAllowThreads(__tstate);
52163 if (PyErr_Occurred()) SWIG_fail;
52164 }
52165 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52166 return resultobj;
52167 fail:
52168 return NULL;
52169 }
52170
52171
52172 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52173 PyObject *resultobj = 0;
52174 wxSizer *arg1 = (wxSizer *) 0 ;
52175 void *argp1 = 0 ;
52176 int res1 = 0 ;
52177 PyObject *swig_obj[1] ;
52178
52179 if (!args) SWIG_fail;
52180 swig_obj[0] = args;
52181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52182 if (!SWIG_IsOK(res1)) {
52183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
52184 }
52185 arg1 = reinterpret_cast< wxSizer * >(argp1);
52186 {
52187 PyThreadState* __tstate = wxPyBeginAllowThreads();
52188 (arg1)->Layout();
52189 wxPyEndAllowThreads(__tstate);
52190 if (PyErr_Occurred()) SWIG_fail;
52191 }
52192 resultobj = SWIG_Py_Void();
52193 return resultobj;
52194 fail:
52195 return NULL;
52196 }
52197
52198
52199 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52200 PyObject *resultobj = 0;
52201 wxSizer *arg1 = (wxSizer *) 0 ;
52202 wxWindow *arg2 = (wxWindow *) 0 ;
52203 wxSize result;
52204 void *argp1 = 0 ;
52205 int res1 = 0 ;
52206 void *argp2 = 0 ;
52207 int res2 = 0 ;
52208 PyObject * obj0 = 0 ;
52209 PyObject * obj1 = 0 ;
52210 char * kwnames[] = {
52211 (char *) "self",(char *) "window", NULL
52212 };
52213
52214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
52215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52216 if (!SWIG_IsOK(res1)) {
52217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
52218 }
52219 arg1 = reinterpret_cast< wxSizer * >(argp1);
52220 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52221 if (!SWIG_IsOK(res2)) {
52222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
52223 }
52224 arg2 = reinterpret_cast< wxWindow * >(argp2);
52225 {
52226 PyThreadState* __tstate = wxPyBeginAllowThreads();
52227 result = (arg1)->Fit(arg2);
52228 wxPyEndAllowThreads(__tstate);
52229 if (PyErr_Occurred()) SWIG_fail;
52230 }
52231 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52232 return resultobj;
52233 fail:
52234 return NULL;
52235 }
52236
52237
52238 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52239 PyObject *resultobj = 0;
52240 wxSizer *arg1 = (wxSizer *) 0 ;
52241 wxWindow *arg2 = (wxWindow *) 0 ;
52242 void *argp1 = 0 ;
52243 int res1 = 0 ;
52244 void *argp2 = 0 ;
52245 int res2 = 0 ;
52246 PyObject * obj0 = 0 ;
52247 PyObject * obj1 = 0 ;
52248 char * kwnames[] = {
52249 (char *) "self",(char *) "window", NULL
52250 };
52251
52252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
52253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52254 if (!SWIG_IsOK(res1)) {
52255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
52256 }
52257 arg1 = reinterpret_cast< wxSizer * >(argp1);
52258 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52259 if (!SWIG_IsOK(res2)) {
52260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
52261 }
52262 arg2 = reinterpret_cast< wxWindow * >(argp2);
52263 {
52264 PyThreadState* __tstate = wxPyBeginAllowThreads();
52265 (arg1)->FitInside(arg2);
52266 wxPyEndAllowThreads(__tstate);
52267 if (PyErr_Occurred()) SWIG_fail;
52268 }
52269 resultobj = SWIG_Py_Void();
52270 return resultobj;
52271 fail:
52272 return NULL;
52273 }
52274
52275
52276 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52277 PyObject *resultobj = 0;
52278 wxSizer *arg1 = (wxSizer *) 0 ;
52279 wxWindow *arg2 = (wxWindow *) 0 ;
52280 void *argp1 = 0 ;
52281 int res1 = 0 ;
52282 void *argp2 = 0 ;
52283 int res2 = 0 ;
52284 PyObject * obj0 = 0 ;
52285 PyObject * obj1 = 0 ;
52286 char * kwnames[] = {
52287 (char *) "self",(char *) "window", NULL
52288 };
52289
52290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52292 if (!SWIG_IsOK(res1)) {
52293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52294 }
52295 arg1 = reinterpret_cast< wxSizer * >(argp1);
52296 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52297 if (!SWIG_IsOK(res2)) {
52298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52299 }
52300 arg2 = reinterpret_cast< wxWindow * >(argp2);
52301 {
52302 PyThreadState* __tstate = wxPyBeginAllowThreads();
52303 (arg1)->SetSizeHints(arg2);
52304 wxPyEndAllowThreads(__tstate);
52305 if (PyErr_Occurred()) SWIG_fail;
52306 }
52307 resultobj = SWIG_Py_Void();
52308 return resultobj;
52309 fail:
52310 return NULL;
52311 }
52312
52313
52314 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52315 PyObject *resultobj = 0;
52316 wxSizer *arg1 = (wxSizer *) 0 ;
52317 wxWindow *arg2 = (wxWindow *) 0 ;
52318 void *argp1 = 0 ;
52319 int res1 = 0 ;
52320 void *argp2 = 0 ;
52321 int res2 = 0 ;
52322 PyObject * obj0 = 0 ;
52323 PyObject * obj1 = 0 ;
52324 char * kwnames[] = {
52325 (char *) "self",(char *) "window", NULL
52326 };
52327
52328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52330 if (!SWIG_IsOK(res1)) {
52331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52332 }
52333 arg1 = reinterpret_cast< wxSizer * >(argp1);
52334 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52335 if (!SWIG_IsOK(res2)) {
52336 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52337 }
52338 arg2 = reinterpret_cast< wxWindow * >(argp2);
52339 {
52340 PyThreadState* __tstate = wxPyBeginAllowThreads();
52341 (arg1)->SetVirtualSizeHints(arg2);
52342 wxPyEndAllowThreads(__tstate);
52343 if (PyErr_Occurred()) SWIG_fail;
52344 }
52345 resultobj = SWIG_Py_Void();
52346 return resultobj;
52347 fail:
52348 return NULL;
52349 }
52350
52351
52352 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52353 PyObject *resultobj = 0;
52354 wxSizer *arg1 = (wxSizer *) 0 ;
52355 bool arg2 = (bool) false ;
52356 void *argp1 = 0 ;
52357 int res1 = 0 ;
52358 bool val2 ;
52359 int ecode2 = 0 ;
52360 PyObject * obj0 = 0 ;
52361 PyObject * obj1 = 0 ;
52362 char * kwnames[] = {
52363 (char *) "self",(char *) "deleteWindows", NULL
52364 };
52365
52366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
52367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52368 if (!SWIG_IsOK(res1)) {
52369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
52370 }
52371 arg1 = reinterpret_cast< wxSizer * >(argp1);
52372 if (obj1) {
52373 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52374 if (!SWIG_IsOK(ecode2)) {
52375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
52376 }
52377 arg2 = static_cast< bool >(val2);
52378 }
52379 {
52380 PyThreadState* __tstate = wxPyBeginAllowThreads();
52381 (arg1)->Clear(arg2);
52382 wxPyEndAllowThreads(__tstate);
52383 if (PyErr_Occurred()) SWIG_fail;
52384 }
52385 resultobj = SWIG_Py_Void();
52386 return resultobj;
52387 fail:
52388 return NULL;
52389 }
52390
52391
52392 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52393 PyObject *resultobj = 0;
52394 wxSizer *arg1 = (wxSizer *) 0 ;
52395 void *argp1 = 0 ;
52396 int res1 = 0 ;
52397 PyObject *swig_obj[1] ;
52398
52399 if (!args) SWIG_fail;
52400 swig_obj[0] = args;
52401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52402 if (!SWIG_IsOK(res1)) {
52403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
52404 }
52405 arg1 = reinterpret_cast< wxSizer * >(argp1);
52406 {
52407 PyThreadState* __tstate = wxPyBeginAllowThreads();
52408 (arg1)->DeleteWindows();
52409 wxPyEndAllowThreads(__tstate);
52410 if (PyErr_Occurred()) SWIG_fail;
52411 }
52412 resultobj = SWIG_Py_Void();
52413 return resultobj;
52414 fail:
52415 return NULL;
52416 }
52417
52418
52419 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52420 PyObject *resultobj = 0;
52421 wxSizer *arg1 = (wxSizer *) 0 ;
52422 PyObject *result = 0 ;
52423 void *argp1 = 0 ;
52424 int res1 = 0 ;
52425 PyObject *swig_obj[1] ;
52426
52427 if (!args) SWIG_fail;
52428 swig_obj[0] = args;
52429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52430 if (!SWIG_IsOK(res1)) {
52431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
52432 }
52433 arg1 = reinterpret_cast< wxSizer * >(argp1);
52434 {
52435 PyThreadState* __tstate = wxPyBeginAllowThreads();
52436 result = (PyObject *)wxSizer_GetChildren(arg1);
52437 wxPyEndAllowThreads(__tstate);
52438 if (PyErr_Occurred()) SWIG_fail;
52439 }
52440 resultobj = result;
52441 return resultobj;
52442 fail:
52443 return NULL;
52444 }
52445
52446
52447 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52448 PyObject *resultobj = 0;
52449 wxSizer *arg1 = (wxSizer *) 0 ;
52450 PyObject *arg2 = (PyObject *) 0 ;
52451 bool arg3 = (bool) true ;
52452 bool arg4 = (bool) false ;
52453 bool result;
52454 void *argp1 = 0 ;
52455 int res1 = 0 ;
52456 bool val3 ;
52457 int ecode3 = 0 ;
52458 bool val4 ;
52459 int ecode4 = 0 ;
52460 PyObject * obj0 = 0 ;
52461 PyObject * obj1 = 0 ;
52462 PyObject * obj2 = 0 ;
52463 PyObject * obj3 = 0 ;
52464 char * kwnames[] = {
52465 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
52466 };
52467
52468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52470 if (!SWIG_IsOK(res1)) {
52471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
52472 }
52473 arg1 = reinterpret_cast< wxSizer * >(argp1);
52474 arg2 = obj1;
52475 if (obj2) {
52476 ecode3 = SWIG_AsVal_bool(obj2, &val3);
52477 if (!SWIG_IsOK(ecode3)) {
52478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
52479 }
52480 arg3 = static_cast< bool >(val3);
52481 }
52482 if (obj3) {
52483 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52484 if (!SWIG_IsOK(ecode4)) {
52485 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
52486 }
52487 arg4 = static_cast< bool >(val4);
52488 }
52489 {
52490 PyThreadState* __tstate = wxPyBeginAllowThreads();
52491 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
52492 wxPyEndAllowThreads(__tstate);
52493 if (PyErr_Occurred()) SWIG_fail;
52494 }
52495 {
52496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52497 }
52498 return resultobj;
52499 fail:
52500 return NULL;
52501 }
52502
52503
52504 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52505 PyObject *resultobj = 0;
52506 wxSizer *arg1 = (wxSizer *) 0 ;
52507 PyObject *arg2 = (PyObject *) 0 ;
52508 bool result;
52509 void *argp1 = 0 ;
52510 int res1 = 0 ;
52511 PyObject * obj0 = 0 ;
52512 PyObject * obj1 = 0 ;
52513 char * kwnames[] = {
52514 (char *) "self",(char *) "item", NULL
52515 };
52516
52517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
52518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52519 if (!SWIG_IsOK(res1)) {
52520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
52521 }
52522 arg1 = reinterpret_cast< wxSizer * >(argp1);
52523 arg2 = obj1;
52524 {
52525 PyThreadState* __tstate = wxPyBeginAllowThreads();
52526 result = (bool)wxSizer_IsShown(arg1,arg2);
52527 wxPyEndAllowThreads(__tstate);
52528 if (PyErr_Occurred()) SWIG_fail;
52529 }
52530 {
52531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52532 }
52533 return resultobj;
52534 fail:
52535 return NULL;
52536 }
52537
52538
52539 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52540 PyObject *resultobj = 0;
52541 wxSizer *arg1 = (wxSizer *) 0 ;
52542 bool arg2 ;
52543 void *argp1 = 0 ;
52544 int res1 = 0 ;
52545 bool val2 ;
52546 int ecode2 = 0 ;
52547 PyObject * obj0 = 0 ;
52548 PyObject * obj1 = 0 ;
52549 char * kwnames[] = {
52550 (char *) "self",(char *) "show", NULL
52551 };
52552
52553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
52554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52555 if (!SWIG_IsOK(res1)) {
52556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
52557 }
52558 arg1 = reinterpret_cast< wxSizer * >(argp1);
52559 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52560 if (!SWIG_IsOK(ecode2)) {
52561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
52562 }
52563 arg2 = static_cast< bool >(val2);
52564 {
52565 PyThreadState* __tstate = wxPyBeginAllowThreads();
52566 (arg1)->ShowItems(arg2);
52567 wxPyEndAllowThreads(__tstate);
52568 if (PyErr_Occurred()) SWIG_fail;
52569 }
52570 resultobj = SWIG_Py_Void();
52571 return resultobj;
52572 fail:
52573 return NULL;
52574 }
52575
52576
52577 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52578 PyObject *obj;
52579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52580 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
52581 return SWIG_Py_Void();
52582 }
52583
52584 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52585 PyObject *resultobj = 0;
52586 wxPySizer *result = 0 ;
52587
52588 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
52589 {
52590 PyThreadState* __tstate = wxPyBeginAllowThreads();
52591 result = (wxPySizer *)new wxPySizer();
52592 wxPyEndAllowThreads(__tstate);
52593 if (PyErr_Occurred()) SWIG_fail;
52594 }
52595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
52596 return resultobj;
52597 fail:
52598 return NULL;
52599 }
52600
52601
52602 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52603 PyObject *resultobj = 0;
52604 wxPySizer *arg1 = (wxPySizer *) 0 ;
52605 PyObject *arg2 = (PyObject *) 0 ;
52606 PyObject *arg3 = (PyObject *) 0 ;
52607 void *argp1 = 0 ;
52608 int res1 = 0 ;
52609 PyObject * obj0 = 0 ;
52610 PyObject * obj1 = 0 ;
52611 PyObject * obj2 = 0 ;
52612 char * kwnames[] = {
52613 (char *) "self",(char *) "self",(char *) "_class", NULL
52614 };
52615
52616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
52618 if (!SWIG_IsOK(res1)) {
52619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
52620 }
52621 arg1 = reinterpret_cast< wxPySizer * >(argp1);
52622 arg2 = obj1;
52623 arg3 = obj2;
52624 {
52625 PyThreadState* __tstate = wxPyBeginAllowThreads();
52626 (arg1)->_setCallbackInfo(arg2,arg3);
52627 wxPyEndAllowThreads(__tstate);
52628 if (PyErr_Occurred()) SWIG_fail;
52629 }
52630 resultobj = SWIG_Py_Void();
52631 return resultobj;
52632 fail:
52633 return NULL;
52634 }
52635
52636
52637 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52638 PyObject *obj;
52639 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52640 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
52641 return SWIG_Py_Void();
52642 }
52643
52644 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52645 return SWIG_Python_InitShadowInstance(args);
52646 }
52647
52648 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52649 PyObject *resultobj = 0;
52650 int arg1 = (int) wxHORIZONTAL ;
52651 wxBoxSizer *result = 0 ;
52652 int val1 ;
52653 int ecode1 = 0 ;
52654 PyObject * obj0 = 0 ;
52655 char * kwnames[] = {
52656 (char *) "orient", NULL
52657 };
52658
52659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
52660 if (obj0) {
52661 ecode1 = SWIG_AsVal_int(obj0, &val1);
52662 if (!SWIG_IsOK(ecode1)) {
52663 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
52664 }
52665 arg1 = static_cast< int >(val1);
52666 }
52667 {
52668 PyThreadState* __tstate = wxPyBeginAllowThreads();
52669 result = (wxBoxSizer *)new wxBoxSizer(arg1);
52670 wxPyEndAllowThreads(__tstate);
52671 if (PyErr_Occurred()) SWIG_fail;
52672 }
52673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
52674 return resultobj;
52675 fail:
52676 return NULL;
52677 }
52678
52679
52680 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52681 PyObject *resultobj = 0;
52682 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
52683 int result;
52684 void *argp1 = 0 ;
52685 int res1 = 0 ;
52686 PyObject *swig_obj[1] ;
52687
52688 if (!args) SWIG_fail;
52689 swig_obj[0] = args;
52690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
52691 if (!SWIG_IsOK(res1)) {
52692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
52693 }
52694 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
52695 {
52696 PyThreadState* __tstate = wxPyBeginAllowThreads();
52697 result = (int)(arg1)->GetOrientation();
52698 wxPyEndAllowThreads(__tstate);
52699 if (PyErr_Occurred()) SWIG_fail;
52700 }
52701 resultobj = SWIG_From_int(static_cast< int >(result));
52702 return resultobj;
52703 fail:
52704 return NULL;
52705 }
52706
52707
52708 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52709 PyObject *resultobj = 0;
52710 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
52711 int arg2 ;
52712 void *argp1 = 0 ;
52713 int res1 = 0 ;
52714 int val2 ;
52715 int ecode2 = 0 ;
52716 PyObject * obj0 = 0 ;
52717 PyObject * obj1 = 0 ;
52718 char * kwnames[] = {
52719 (char *) "self",(char *) "orient", NULL
52720 };
52721
52722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
52723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
52724 if (!SWIG_IsOK(res1)) {
52725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
52726 }
52727 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
52728 ecode2 = SWIG_AsVal_int(obj1, &val2);
52729 if (!SWIG_IsOK(ecode2)) {
52730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
52731 }
52732 arg2 = static_cast< int >(val2);
52733 {
52734 PyThreadState* __tstate = wxPyBeginAllowThreads();
52735 (arg1)->SetOrientation(arg2);
52736 wxPyEndAllowThreads(__tstate);
52737 if (PyErr_Occurred()) SWIG_fail;
52738 }
52739 resultobj = SWIG_Py_Void();
52740 return resultobj;
52741 fail:
52742 return NULL;
52743 }
52744
52745
52746 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52747 PyObject *obj;
52748 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52749 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
52750 return SWIG_Py_Void();
52751 }
52752
52753 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52754 return SWIG_Python_InitShadowInstance(args);
52755 }
52756
52757 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52758 PyObject *resultobj = 0;
52759 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
52760 int arg2 = (int) wxHORIZONTAL ;
52761 wxStaticBoxSizer *result = 0 ;
52762 void *argp1 = 0 ;
52763 int res1 = 0 ;
52764 int val2 ;
52765 int ecode2 = 0 ;
52766 PyObject * obj0 = 0 ;
52767 PyObject * obj1 = 0 ;
52768 char * kwnames[] = {
52769 (char *) "box",(char *) "orient", NULL
52770 };
52771
52772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
52773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
52774 if (!SWIG_IsOK(res1)) {
52775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
52776 }
52777 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
52778 if (obj1) {
52779 ecode2 = SWIG_AsVal_int(obj1, &val2);
52780 if (!SWIG_IsOK(ecode2)) {
52781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
52782 }
52783 arg2 = static_cast< int >(val2);
52784 }
52785 {
52786 PyThreadState* __tstate = wxPyBeginAllowThreads();
52787 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
52788 wxPyEndAllowThreads(__tstate);
52789 if (PyErr_Occurred()) SWIG_fail;
52790 }
52791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
52792 return resultobj;
52793 fail:
52794 return NULL;
52795 }
52796
52797
52798 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52799 PyObject *resultobj = 0;
52800 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
52801 wxStaticBox *result = 0 ;
52802 void *argp1 = 0 ;
52803 int res1 = 0 ;
52804 PyObject *swig_obj[1] ;
52805
52806 if (!args) SWIG_fail;
52807 swig_obj[0] = args;
52808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
52809 if (!SWIG_IsOK(res1)) {
52810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
52811 }
52812 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
52813 {
52814 PyThreadState* __tstate = wxPyBeginAllowThreads();
52815 result = (wxStaticBox *)(arg1)->GetStaticBox();
52816 wxPyEndAllowThreads(__tstate);
52817 if (PyErr_Occurred()) SWIG_fail;
52818 }
52819 {
52820 resultobj = wxPyMake_wxObject(result, (bool)0);
52821 }
52822 return resultobj;
52823 fail:
52824 return NULL;
52825 }
52826
52827
52828 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52829 PyObject *obj;
52830 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52831 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
52832 return SWIG_Py_Void();
52833 }
52834
52835 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52836 return SWIG_Python_InitShadowInstance(args);
52837 }
52838
52839 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52840 PyObject *resultobj = 0;
52841 int arg1 = (int) 1 ;
52842 int arg2 = (int) 0 ;
52843 int arg3 = (int) 0 ;
52844 int arg4 = (int) 0 ;
52845 wxGridSizer *result = 0 ;
52846 int val1 ;
52847 int ecode1 = 0 ;
52848 int val2 ;
52849 int ecode2 = 0 ;
52850 int val3 ;
52851 int ecode3 = 0 ;
52852 int val4 ;
52853 int ecode4 = 0 ;
52854 PyObject * obj0 = 0 ;
52855 PyObject * obj1 = 0 ;
52856 PyObject * obj2 = 0 ;
52857 PyObject * obj3 = 0 ;
52858 char * kwnames[] = {
52859 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
52860 };
52861
52862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52863 if (obj0) {
52864 ecode1 = SWIG_AsVal_int(obj0, &val1);
52865 if (!SWIG_IsOK(ecode1)) {
52866 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
52867 }
52868 arg1 = static_cast< int >(val1);
52869 }
52870 if (obj1) {
52871 ecode2 = SWIG_AsVal_int(obj1, &val2);
52872 if (!SWIG_IsOK(ecode2)) {
52873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
52874 }
52875 arg2 = static_cast< int >(val2);
52876 }
52877 if (obj2) {
52878 ecode3 = SWIG_AsVal_int(obj2, &val3);
52879 if (!SWIG_IsOK(ecode3)) {
52880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
52881 }
52882 arg3 = static_cast< int >(val3);
52883 }
52884 if (obj3) {
52885 ecode4 = SWIG_AsVal_int(obj3, &val4);
52886 if (!SWIG_IsOK(ecode4)) {
52887 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
52888 }
52889 arg4 = static_cast< int >(val4);
52890 }
52891 {
52892 PyThreadState* __tstate = wxPyBeginAllowThreads();
52893 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
52894 wxPyEndAllowThreads(__tstate);
52895 if (PyErr_Occurred()) SWIG_fail;
52896 }
52897 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
52898 return resultobj;
52899 fail:
52900 return NULL;
52901 }
52902
52903
52904 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52905 PyObject *resultobj = 0;
52906 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52907 int arg2 ;
52908 void *argp1 = 0 ;
52909 int res1 = 0 ;
52910 int val2 ;
52911 int ecode2 = 0 ;
52912 PyObject * obj0 = 0 ;
52913 PyObject * obj1 = 0 ;
52914 char * kwnames[] = {
52915 (char *) "self",(char *) "cols", NULL
52916 };
52917
52918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
52919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52920 if (!SWIG_IsOK(res1)) {
52921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52922 }
52923 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52924 ecode2 = SWIG_AsVal_int(obj1, &val2);
52925 if (!SWIG_IsOK(ecode2)) {
52926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
52927 }
52928 arg2 = static_cast< int >(val2);
52929 {
52930 PyThreadState* __tstate = wxPyBeginAllowThreads();
52931 (arg1)->SetCols(arg2);
52932 wxPyEndAllowThreads(__tstate);
52933 if (PyErr_Occurred()) SWIG_fail;
52934 }
52935 resultobj = SWIG_Py_Void();
52936 return resultobj;
52937 fail:
52938 return NULL;
52939 }
52940
52941
52942 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52943 PyObject *resultobj = 0;
52944 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52945 int arg2 ;
52946 void *argp1 = 0 ;
52947 int res1 = 0 ;
52948 int val2 ;
52949 int ecode2 = 0 ;
52950 PyObject * obj0 = 0 ;
52951 PyObject * obj1 = 0 ;
52952 char * kwnames[] = {
52953 (char *) "self",(char *) "rows", NULL
52954 };
52955
52956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
52957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52958 if (!SWIG_IsOK(res1)) {
52959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52960 }
52961 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52962 ecode2 = SWIG_AsVal_int(obj1, &val2);
52963 if (!SWIG_IsOK(ecode2)) {
52964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
52965 }
52966 arg2 = static_cast< int >(val2);
52967 {
52968 PyThreadState* __tstate = wxPyBeginAllowThreads();
52969 (arg1)->SetRows(arg2);
52970 wxPyEndAllowThreads(__tstate);
52971 if (PyErr_Occurred()) SWIG_fail;
52972 }
52973 resultobj = SWIG_Py_Void();
52974 return resultobj;
52975 fail:
52976 return NULL;
52977 }
52978
52979
52980 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52981 PyObject *resultobj = 0;
52982 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52983 int arg2 ;
52984 void *argp1 = 0 ;
52985 int res1 = 0 ;
52986 int val2 ;
52987 int ecode2 = 0 ;
52988 PyObject * obj0 = 0 ;
52989 PyObject * obj1 = 0 ;
52990 char * kwnames[] = {
52991 (char *) "self",(char *) "gap", NULL
52992 };
52993
52994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
52995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52996 if (!SWIG_IsOK(res1)) {
52997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52998 }
52999 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53000 ecode2 = SWIG_AsVal_int(obj1, &val2);
53001 if (!SWIG_IsOK(ecode2)) {
53002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
53003 }
53004 arg2 = static_cast< int >(val2);
53005 {
53006 PyThreadState* __tstate = wxPyBeginAllowThreads();
53007 (arg1)->SetVGap(arg2);
53008 wxPyEndAllowThreads(__tstate);
53009 if (PyErr_Occurred()) SWIG_fail;
53010 }
53011 resultobj = SWIG_Py_Void();
53012 return resultobj;
53013 fail:
53014 return NULL;
53015 }
53016
53017
53018 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53019 PyObject *resultobj = 0;
53020 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53021 int arg2 ;
53022 void *argp1 = 0 ;
53023 int res1 = 0 ;
53024 int val2 ;
53025 int ecode2 = 0 ;
53026 PyObject * obj0 = 0 ;
53027 PyObject * obj1 = 0 ;
53028 char * kwnames[] = {
53029 (char *) "self",(char *) "gap", NULL
53030 };
53031
53032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
53033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53034 if (!SWIG_IsOK(res1)) {
53035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53036 }
53037 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53038 ecode2 = SWIG_AsVal_int(obj1, &val2);
53039 if (!SWIG_IsOK(ecode2)) {
53040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
53041 }
53042 arg2 = static_cast< int >(val2);
53043 {
53044 PyThreadState* __tstate = wxPyBeginAllowThreads();
53045 (arg1)->SetHGap(arg2);
53046 wxPyEndAllowThreads(__tstate);
53047 if (PyErr_Occurred()) SWIG_fail;
53048 }
53049 resultobj = SWIG_Py_Void();
53050 return resultobj;
53051 fail:
53052 return NULL;
53053 }
53054
53055
53056 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53057 PyObject *resultobj = 0;
53058 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53059 int result;
53060 void *argp1 = 0 ;
53061 int res1 = 0 ;
53062 PyObject *swig_obj[1] ;
53063
53064 if (!args) SWIG_fail;
53065 swig_obj[0] = args;
53066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53067 if (!SWIG_IsOK(res1)) {
53068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53069 }
53070 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53071 {
53072 PyThreadState* __tstate = wxPyBeginAllowThreads();
53073 result = (int)(arg1)->GetCols();
53074 wxPyEndAllowThreads(__tstate);
53075 if (PyErr_Occurred()) SWIG_fail;
53076 }
53077 resultobj = SWIG_From_int(static_cast< int >(result));
53078 return resultobj;
53079 fail:
53080 return NULL;
53081 }
53082
53083
53084 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53085 PyObject *resultobj = 0;
53086 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53087 int result;
53088 void *argp1 = 0 ;
53089 int res1 = 0 ;
53090 PyObject *swig_obj[1] ;
53091
53092 if (!args) SWIG_fail;
53093 swig_obj[0] = args;
53094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53095 if (!SWIG_IsOK(res1)) {
53096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53097 }
53098 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53099 {
53100 PyThreadState* __tstate = wxPyBeginAllowThreads();
53101 result = (int)(arg1)->GetRows();
53102 wxPyEndAllowThreads(__tstate);
53103 if (PyErr_Occurred()) SWIG_fail;
53104 }
53105 resultobj = SWIG_From_int(static_cast< int >(result));
53106 return resultobj;
53107 fail:
53108 return NULL;
53109 }
53110
53111
53112 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53113 PyObject *resultobj = 0;
53114 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53115 int result;
53116 void *argp1 = 0 ;
53117 int res1 = 0 ;
53118 PyObject *swig_obj[1] ;
53119
53120 if (!args) SWIG_fail;
53121 swig_obj[0] = args;
53122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53123 if (!SWIG_IsOK(res1)) {
53124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53125 }
53126 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53127 {
53128 PyThreadState* __tstate = wxPyBeginAllowThreads();
53129 result = (int)(arg1)->GetVGap();
53130 wxPyEndAllowThreads(__tstate);
53131 if (PyErr_Occurred()) SWIG_fail;
53132 }
53133 resultobj = SWIG_From_int(static_cast< int >(result));
53134 return resultobj;
53135 fail:
53136 return NULL;
53137 }
53138
53139
53140 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53141 PyObject *resultobj = 0;
53142 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53143 int result;
53144 void *argp1 = 0 ;
53145 int res1 = 0 ;
53146 PyObject *swig_obj[1] ;
53147
53148 if (!args) SWIG_fail;
53149 swig_obj[0] = args;
53150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53151 if (!SWIG_IsOK(res1)) {
53152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53153 }
53154 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53155 {
53156 PyThreadState* __tstate = wxPyBeginAllowThreads();
53157 result = (int)(arg1)->GetHGap();
53158 wxPyEndAllowThreads(__tstate);
53159 if (PyErr_Occurred()) SWIG_fail;
53160 }
53161 resultobj = SWIG_From_int(static_cast< int >(result));
53162 return resultobj;
53163 fail:
53164 return NULL;
53165 }
53166
53167
53168 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53169 PyObject *obj;
53170 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53171 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
53172 return SWIG_Py_Void();
53173 }
53174
53175 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53176 return SWIG_Python_InitShadowInstance(args);
53177 }
53178
53179 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53180 PyObject *resultobj = 0;
53181 int arg1 = (int) 1 ;
53182 int arg2 = (int) 0 ;
53183 int arg3 = (int) 0 ;
53184 int arg4 = (int) 0 ;
53185 wxFlexGridSizer *result = 0 ;
53186 int val1 ;
53187 int ecode1 = 0 ;
53188 int val2 ;
53189 int ecode2 = 0 ;
53190 int val3 ;
53191 int ecode3 = 0 ;
53192 int val4 ;
53193 int ecode4 = 0 ;
53194 PyObject * obj0 = 0 ;
53195 PyObject * obj1 = 0 ;
53196 PyObject * obj2 = 0 ;
53197 PyObject * obj3 = 0 ;
53198 char * kwnames[] = {
53199 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
53200 };
53201
53202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53203 if (obj0) {
53204 ecode1 = SWIG_AsVal_int(obj0, &val1);
53205 if (!SWIG_IsOK(ecode1)) {
53206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
53207 }
53208 arg1 = static_cast< int >(val1);
53209 }
53210 if (obj1) {
53211 ecode2 = SWIG_AsVal_int(obj1, &val2);
53212 if (!SWIG_IsOK(ecode2)) {
53213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
53214 }
53215 arg2 = static_cast< int >(val2);
53216 }
53217 if (obj2) {
53218 ecode3 = SWIG_AsVal_int(obj2, &val3);
53219 if (!SWIG_IsOK(ecode3)) {
53220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
53221 }
53222 arg3 = static_cast< int >(val3);
53223 }
53224 if (obj3) {
53225 ecode4 = SWIG_AsVal_int(obj3, &val4);
53226 if (!SWIG_IsOK(ecode4)) {
53227 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
53228 }
53229 arg4 = static_cast< int >(val4);
53230 }
53231 {
53232 PyThreadState* __tstate = wxPyBeginAllowThreads();
53233 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
53234 wxPyEndAllowThreads(__tstate);
53235 if (PyErr_Occurred()) SWIG_fail;
53236 }
53237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
53238 return resultobj;
53239 fail:
53240 return NULL;
53241 }
53242
53243
53244 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53245 PyObject *resultobj = 0;
53246 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53247 size_t arg2 ;
53248 int arg3 = (int) 0 ;
53249 void *argp1 = 0 ;
53250 int res1 = 0 ;
53251 size_t val2 ;
53252 int ecode2 = 0 ;
53253 int val3 ;
53254 int ecode3 = 0 ;
53255 PyObject * obj0 = 0 ;
53256 PyObject * obj1 = 0 ;
53257 PyObject * obj2 = 0 ;
53258 char * kwnames[] = {
53259 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53260 };
53261
53262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53264 if (!SWIG_IsOK(res1)) {
53265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53266 }
53267 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53268 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53269 if (!SWIG_IsOK(ecode2)) {
53270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53271 }
53272 arg2 = static_cast< size_t >(val2);
53273 if (obj2) {
53274 ecode3 = SWIG_AsVal_int(obj2, &val3);
53275 if (!SWIG_IsOK(ecode3)) {
53276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
53277 }
53278 arg3 = static_cast< int >(val3);
53279 }
53280 {
53281 PyThreadState* __tstate = wxPyBeginAllowThreads();
53282 (arg1)->AddGrowableRow(arg2,arg3);
53283 wxPyEndAllowThreads(__tstate);
53284 if (PyErr_Occurred()) SWIG_fail;
53285 }
53286 resultobj = SWIG_Py_Void();
53287 return resultobj;
53288 fail:
53289 return NULL;
53290 }
53291
53292
53293 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53294 PyObject *resultobj = 0;
53295 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53296 size_t arg2 ;
53297 void *argp1 = 0 ;
53298 int res1 = 0 ;
53299 size_t val2 ;
53300 int ecode2 = 0 ;
53301 PyObject * obj0 = 0 ;
53302 PyObject * obj1 = 0 ;
53303 char * kwnames[] = {
53304 (char *) "self",(char *) "idx", NULL
53305 };
53306
53307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
53308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53309 if (!SWIG_IsOK(res1)) {
53310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53311 }
53312 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53313 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53314 if (!SWIG_IsOK(ecode2)) {
53315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53316 }
53317 arg2 = static_cast< size_t >(val2);
53318 {
53319 PyThreadState* __tstate = wxPyBeginAllowThreads();
53320 (arg1)->RemoveGrowableRow(arg2);
53321 wxPyEndAllowThreads(__tstate);
53322 if (PyErr_Occurred()) SWIG_fail;
53323 }
53324 resultobj = SWIG_Py_Void();
53325 return resultobj;
53326 fail:
53327 return NULL;
53328 }
53329
53330
53331 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53332 PyObject *resultobj = 0;
53333 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53334 size_t arg2 ;
53335 int arg3 = (int) 0 ;
53336 void *argp1 = 0 ;
53337 int res1 = 0 ;
53338 size_t val2 ;
53339 int ecode2 = 0 ;
53340 int val3 ;
53341 int ecode3 = 0 ;
53342 PyObject * obj0 = 0 ;
53343 PyObject * obj1 = 0 ;
53344 PyObject * obj2 = 0 ;
53345 char * kwnames[] = {
53346 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53347 };
53348
53349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53351 if (!SWIG_IsOK(res1)) {
53352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53353 }
53354 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53355 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53356 if (!SWIG_IsOK(ecode2)) {
53357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53358 }
53359 arg2 = static_cast< size_t >(val2);
53360 if (obj2) {
53361 ecode3 = SWIG_AsVal_int(obj2, &val3);
53362 if (!SWIG_IsOK(ecode3)) {
53363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
53364 }
53365 arg3 = static_cast< int >(val3);
53366 }
53367 {
53368 PyThreadState* __tstate = wxPyBeginAllowThreads();
53369 (arg1)->AddGrowableCol(arg2,arg3);
53370 wxPyEndAllowThreads(__tstate);
53371 if (PyErr_Occurred()) SWIG_fail;
53372 }
53373 resultobj = SWIG_Py_Void();
53374 return resultobj;
53375 fail:
53376 return NULL;
53377 }
53378
53379
53380 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53381 PyObject *resultobj = 0;
53382 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53383 size_t arg2 ;
53384 void *argp1 = 0 ;
53385 int res1 = 0 ;
53386 size_t val2 ;
53387 int ecode2 = 0 ;
53388 PyObject * obj0 = 0 ;
53389 PyObject * obj1 = 0 ;
53390 char * kwnames[] = {
53391 (char *) "self",(char *) "idx", NULL
53392 };
53393
53394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
53395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53396 if (!SWIG_IsOK(res1)) {
53397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53398 }
53399 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53400 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53401 if (!SWIG_IsOK(ecode2)) {
53402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53403 }
53404 arg2 = static_cast< size_t >(val2);
53405 {
53406 PyThreadState* __tstate = wxPyBeginAllowThreads();
53407 (arg1)->RemoveGrowableCol(arg2);
53408 wxPyEndAllowThreads(__tstate);
53409 if (PyErr_Occurred()) SWIG_fail;
53410 }
53411 resultobj = SWIG_Py_Void();
53412 return resultobj;
53413 fail:
53414 return NULL;
53415 }
53416
53417
53418 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53419 PyObject *resultobj = 0;
53420 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53421 int arg2 ;
53422 void *argp1 = 0 ;
53423 int res1 = 0 ;
53424 int val2 ;
53425 int ecode2 = 0 ;
53426 PyObject * obj0 = 0 ;
53427 PyObject * obj1 = 0 ;
53428 char * kwnames[] = {
53429 (char *) "self",(char *) "direction", NULL
53430 };
53431
53432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
53433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53434 if (!SWIG_IsOK(res1)) {
53435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53436 }
53437 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53438 ecode2 = SWIG_AsVal_int(obj1, &val2);
53439 if (!SWIG_IsOK(ecode2)) {
53440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
53441 }
53442 arg2 = static_cast< int >(val2);
53443 {
53444 PyThreadState* __tstate = wxPyBeginAllowThreads();
53445 (arg1)->SetFlexibleDirection(arg2);
53446 wxPyEndAllowThreads(__tstate);
53447 if (PyErr_Occurred()) SWIG_fail;
53448 }
53449 resultobj = SWIG_Py_Void();
53450 return resultobj;
53451 fail:
53452 return NULL;
53453 }
53454
53455
53456 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53457 PyObject *resultobj = 0;
53458 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53459 int result;
53460 void *argp1 = 0 ;
53461 int res1 = 0 ;
53462 PyObject *swig_obj[1] ;
53463
53464 if (!args) SWIG_fail;
53465 swig_obj[0] = args;
53466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53467 if (!SWIG_IsOK(res1)) {
53468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53469 }
53470 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53471 {
53472 PyThreadState* __tstate = wxPyBeginAllowThreads();
53473 result = (int)(arg1)->GetFlexibleDirection();
53474 wxPyEndAllowThreads(__tstate);
53475 if (PyErr_Occurred()) SWIG_fail;
53476 }
53477 resultobj = SWIG_From_int(static_cast< int >(result));
53478 return resultobj;
53479 fail:
53480 return NULL;
53481 }
53482
53483
53484 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53485 PyObject *resultobj = 0;
53486 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53487 wxFlexSizerGrowMode arg2 ;
53488 void *argp1 = 0 ;
53489 int res1 = 0 ;
53490 int val2 ;
53491 int ecode2 = 0 ;
53492 PyObject * obj0 = 0 ;
53493 PyObject * obj1 = 0 ;
53494 char * kwnames[] = {
53495 (char *) "self",(char *) "mode", NULL
53496 };
53497
53498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
53499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53500 if (!SWIG_IsOK(res1)) {
53501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53502 }
53503 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53504 ecode2 = SWIG_AsVal_int(obj1, &val2);
53505 if (!SWIG_IsOK(ecode2)) {
53506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
53507 }
53508 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
53509 {
53510 PyThreadState* __tstate = wxPyBeginAllowThreads();
53511 (arg1)->SetNonFlexibleGrowMode(arg2);
53512 wxPyEndAllowThreads(__tstate);
53513 if (PyErr_Occurred()) SWIG_fail;
53514 }
53515 resultobj = SWIG_Py_Void();
53516 return resultobj;
53517 fail:
53518 return NULL;
53519 }
53520
53521
53522 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53523 PyObject *resultobj = 0;
53524 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53525 wxFlexSizerGrowMode result;
53526 void *argp1 = 0 ;
53527 int res1 = 0 ;
53528 PyObject *swig_obj[1] ;
53529
53530 if (!args) SWIG_fail;
53531 swig_obj[0] = args;
53532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53533 if (!SWIG_IsOK(res1)) {
53534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53535 }
53536 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53537 {
53538 PyThreadState* __tstate = wxPyBeginAllowThreads();
53539 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
53540 wxPyEndAllowThreads(__tstate);
53541 if (PyErr_Occurred()) SWIG_fail;
53542 }
53543 resultobj = SWIG_From_int(static_cast< int >(result));
53544 return resultobj;
53545 fail:
53546 return NULL;
53547 }
53548
53549
53550 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53551 PyObject *resultobj = 0;
53552 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53553 wxArrayInt *result = 0 ;
53554 void *argp1 = 0 ;
53555 int res1 = 0 ;
53556 PyObject *swig_obj[1] ;
53557
53558 if (!args) SWIG_fail;
53559 swig_obj[0] = args;
53560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53561 if (!SWIG_IsOK(res1)) {
53562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
53563 }
53564 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53565 {
53566 PyThreadState* __tstate = wxPyBeginAllowThreads();
53567 {
53568 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
53569 result = (wxArrayInt *) &_result_ref;
53570 }
53571 wxPyEndAllowThreads(__tstate);
53572 if (PyErr_Occurred()) SWIG_fail;
53573 }
53574 {
53575 resultobj = wxArrayInt2PyList_helper(*result);
53576 }
53577 return resultobj;
53578 fail:
53579 return NULL;
53580 }
53581
53582
53583 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53584 PyObject *resultobj = 0;
53585 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53586 wxArrayInt *result = 0 ;
53587 void *argp1 = 0 ;
53588 int res1 = 0 ;
53589 PyObject *swig_obj[1] ;
53590
53591 if (!args) SWIG_fail;
53592 swig_obj[0] = args;
53593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53594 if (!SWIG_IsOK(res1)) {
53595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
53596 }
53597 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53598 {
53599 PyThreadState* __tstate = wxPyBeginAllowThreads();
53600 {
53601 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
53602 result = (wxArrayInt *) &_result_ref;
53603 }
53604 wxPyEndAllowThreads(__tstate);
53605 if (PyErr_Occurred()) SWIG_fail;
53606 }
53607 {
53608 resultobj = wxArrayInt2PyList_helper(*result);
53609 }
53610 return resultobj;
53611 fail:
53612 return NULL;
53613 }
53614
53615
53616 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53617 PyObject *obj;
53618 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53619 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
53620 return SWIG_Py_Void();
53621 }
53622
53623 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53624 return SWIG_Python_InitShadowInstance(args);
53625 }
53626
53627 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53628 PyObject *resultobj = 0;
53629 wxStdDialogButtonSizer *result = 0 ;
53630
53631 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
53632 {
53633 PyThreadState* __tstate = wxPyBeginAllowThreads();
53634 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
53635 wxPyEndAllowThreads(__tstate);
53636 if (PyErr_Occurred()) SWIG_fail;
53637 }
53638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
53639 return resultobj;
53640 fail:
53641 return NULL;
53642 }
53643
53644
53645 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53646 PyObject *resultobj = 0;
53647 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53648 wxButton *arg2 = (wxButton *) 0 ;
53649 void *argp1 = 0 ;
53650 int res1 = 0 ;
53651 void *argp2 = 0 ;
53652 int res2 = 0 ;
53653 PyObject * obj0 = 0 ;
53654 PyObject * obj1 = 0 ;
53655 char * kwnames[] = {
53656 (char *) "self",(char *) "button", NULL
53657 };
53658
53659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
53660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53661 if (!SWIG_IsOK(res1)) {
53662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53663 }
53664 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53665 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53666 if (!SWIG_IsOK(res2)) {
53667 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
53668 }
53669 arg2 = reinterpret_cast< wxButton * >(argp2);
53670 {
53671 PyThreadState* __tstate = wxPyBeginAllowThreads();
53672 (arg1)->AddButton(arg2);
53673 wxPyEndAllowThreads(__tstate);
53674 if (PyErr_Occurred()) SWIG_fail;
53675 }
53676 resultobj = SWIG_Py_Void();
53677 return resultobj;
53678 fail:
53679 return NULL;
53680 }
53681
53682
53683 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53684 PyObject *resultobj = 0;
53685 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53686 void *argp1 = 0 ;
53687 int res1 = 0 ;
53688 PyObject *swig_obj[1] ;
53689
53690 if (!args) SWIG_fail;
53691 swig_obj[0] = args;
53692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53693 if (!SWIG_IsOK(res1)) {
53694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53695 }
53696 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53697 {
53698 PyThreadState* __tstate = wxPyBeginAllowThreads();
53699 (arg1)->Realize();
53700 wxPyEndAllowThreads(__tstate);
53701 if (PyErr_Occurred()) SWIG_fail;
53702 }
53703 resultobj = SWIG_Py_Void();
53704 return resultobj;
53705 fail:
53706 return NULL;
53707 }
53708
53709
53710 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53711 PyObject *resultobj = 0;
53712 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53713 wxButton *arg2 = (wxButton *) 0 ;
53714 void *argp1 = 0 ;
53715 int res1 = 0 ;
53716 void *argp2 = 0 ;
53717 int res2 = 0 ;
53718 PyObject * obj0 = 0 ;
53719 PyObject * obj1 = 0 ;
53720 char * kwnames[] = {
53721 (char *) "self",(char *) "button", NULL
53722 };
53723
53724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
53725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53726 if (!SWIG_IsOK(res1)) {
53727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53728 }
53729 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53730 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53731 if (!SWIG_IsOK(res2)) {
53732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
53733 }
53734 arg2 = reinterpret_cast< wxButton * >(argp2);
53735 {
53736 PyThreadState* __tstate = wxPyBeginAllowThreads();
53737 (arg1)->SetAffirmativeButton(arg2);
53738 wxPyEndAllowThreads(__tstate);
53739 if (PyErr_Occurred()) SWIG_fail;
53740 }
53741 resultobj = SWIG_Py_Void();
53742 return resultobj;
53743 fail:
53744 return NULL;
53745 }
53746
53747
53748 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53749 PyObject *resultobj = 0;
53750 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53751 wxButton *arg2 = (wxButton *) 0 ;
53752 void *argp1 = 0 ;
53753 int res1 = 0 ;
53754 void *argp2 = 0 ;
53755 int res2 = 0 ;
53756 PyObject * obj0 = 0 ;
53757 PyObject * obj1 = 0 ;
53758 char * kwnames[] = {
53759 (char *) "self",(char *) "button", NULL
53760 };
53761
53762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
53763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53764 if (!SWIG_IsOK(res1)) {
53765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53766 }
53767 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53768 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53769 if (!SWIG_IsOK(res2)) {
53770 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
53771 }
53772 arg2 = reinterpret_cast< wxButton * >(argp2);
53773 {
53774 PyThreadState* __tstate = wxPyBeginAllowThreads();
53775 (arg1)->SetNegativeButton(arg2);
53776 wxPyEndAllowThreads(__tstate);
53777 if (PyErr_Occurred()) SWIG_fail;
53778 }
53779 resultobj = SWIG_Py_Void();
53780 return resultobj;
53781 fail:
53782 return NULL;
53783 }
53784
53785
53786 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53787 PyObject *resultobj = 0;
53788 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53789 wxButton *arg2 = (wxButton *) 0 ;
53790 void *argp1 = 0 ;
53791 int res1 = 0 ;
53792 void *argp2 = 0 ;
53793 int res2 = 0 ;
53794 PyObject * obj0 = 0 ;
53795 PyObject * obj1 = 0 ;
53796 char * kwnames[] = {
53797 (char *) "self",(char *) "button", NULL
53798 };
53799
53800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
53801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53802 if (!SWIG_IsOK(res1)) {
53803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53804 }
53805 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53806 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53807 if (!SWIG_IsOK(res2)) {
53808 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
53809 }
53810 arg2 = reinterpret_cast< wxButton * >(argp2);
53811 {
53812 PyThreadState* __tstate = wxPyBeginAllowThreads();
53813 (arg1)->SetCancelButton(arg2);
53814 wxPyEndAllowThreads(__tstate);
53815 if (PyErr_Occurred()) SWIG_fail;
53816 }
53817 resultobj = SWIG_Py_Void();
53818 return resultobj;
53819 fail:
53820 return NULL;
53821 }
53822
53823
53824 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53825 PyObject *resultobj = 0;
53826 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53827 wxButton *result = 0 ;
53828 void *argp1 = 0 ;
53829 int res1 = 0 ;
53830 PyObject *swig_obj[1] ;
53831
53832 if (!args) SWIG_fail;
53833 swig_obj[0] = args;
53834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53835 if (!SWIG_IsOK(res1)) {
53836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53837 }
53838 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53839 {
53840 PyThreadState* __tstate = wxPyBeginAllowThreads();
53841 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
53842 wxPyEndAllowThreads(__tstate);
53843 if (PyErr_Occurred()) SWIG_fail;
53844 }
53845 {
53846 resultobj = wxPyMake_wxObject(result, (bool)0);
53847 }
53848 return resultobj;
53849 fail:
53850 return NULL;
53851 }
53852
53853
53854 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53855 PyObject *resultobj = 0;
53856 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53857 wxButton *result = 0 ;
53858 void *argp1 = 0 ;
53859 int res1 = 0 ;
53860 PyObject *swig_obj[1] ;
53861
53862 if (!args) SWIG_fail;
53863 swig_obj[0] = args;
53864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53865 if (!SWIG_IsOK(res1)) {
53866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53867 }
53868 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53869 {
53870 PyThreadState* __tstate = wxPyBeginAllowThreads();
53871 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
53872 wxPyEndAllowThreads(__tstate);
53873 if (PyErr_Occurred()) SWIG_fail;
53874 }
53875 {
53876 resultobj = wxPyMake_wxObject(result, (bool)0);
53877 }
53878 return resultobj;
53879 fail:
53880 return NULL;
53881 }
53882
53883
53884 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53885 PyObject *resultobj = 0;
53886 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53887 wxButton *result = 0 ;
53888 void *argp1 = 0 ;
53889 int res1 = 0 ;
53890 PyObject *swig_obj[1] ;
53891
53892 if (!args) SWIG_fail;
53893 swig_obj[0] = args;
53894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53895 if (!SWIG_IsOK(res1)) {
53896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53897 }
53898 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53899 {
53900 PyThreadState* __tstate = wxPyBeginAllowThreads();
53901 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
53902 wxPyEndAllowThreads(__tstate);
53903 if (PyErr_Occurred()) SWIG_fail;
53904 }
53905 {
53906 resultobj = wxPyMake_wxObject(result, (bool)0);
53907 }
53908 return resultobj;
53909 fail:
53910 return NULL;
53911 }
53912
53913
53914 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53915 PyObject *resultobj = 0;
53916 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53917 wxButton *result = 0 ;
53918 void *argp1 = 0 ;
53919 int res1 = 0 ;
53920 PyObject *swig_obj[1] ;
53921
53922 if (!args) SWIG_fail;
53923 swig_obj[0] = args;
53924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53925 if (!SWIG_IsOK(res1)) {
53926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53927 }
53928 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53929 {
53930 PyThreadState* __tstate = wxPyBeginAllowThreads();
53931 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
53932 wxPyEndAllowThreads(__tstate);
53933 if (PyErr_Occurred()) SWIG_fail;
53934 }
53935 {
53936 resultobj = wxPyMake_wxObject(result, (bool)0);
53937 }
53938 return resultobj;
53939 fail:
53940 return NULL;
53941 }
53942
53943
53944 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53945 PyObject *resultobj = 0;
53946 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53947 wxButton *result = 0 ;
53948 void *argp1 = 0 ;
53949 int res1 = 0 ;
53950 PyObject *swig_obj[1] ;
53951
53952 if (!args) SWIG_fail;
53953 swig_obj[0] = args;
53954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53955 if (!SWIG_IsOK(res1)) {
53956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53957 }
53958 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53959 {
53960 PyThreadState* __tstate = wxPyBeginAllowThreads();
53961 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
53962 wxPyEndAllowThreads(__tstate);
53963 if (PyErr_Occurred()) SWIG_fail;
53964 }
53965 {
53966 resultobj = wxPyMake_wxObject(result, (bool)0);
53967 }
53968 return resultobj;
53969 fail:
53970 return NULL;
53971 }
53972
53973
53974 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53975 PyObject *obj;
53976 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53977 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
53978 return SWIG_Py_Void();
53979 }
53980
53981 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53982 return SWIG_Python_InitShadowInstance(args);
53983 }
53984
53985 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53986 PyObject *resultobj = 0;
53987 int arg1 = (int) 0 ;
53988 int arg2 = (int) 0 ;
53989 wxGBPosition *result = 0 ;
53990 int val1 ;
53991 int ecode1 = 0 ;
53992 int val2 ;
53993 int ecode2 = 0 ;
53994 PyObject * obj0 = 0 ;
53995 PyObject * obj1 = 0 ;
53996 char * kwnames[] = {
53997 (char *) "row",(char *) "col", NULL
53998 };
53999
54000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54001 if (obj0) {
54002 ecode1 = SWIG_AsVal_int(obj0, &val1);
54003 if (!SWIG_IsOK(ecode1)) {
54004 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
54005 }
54006 arg1 = static_cast< int >(val1);
54007 }
54008 if (obj1) {
54009 ecode2 = SWIG_AsVal_int(obj1, &val2);
54010 if (!SWIG_IsOK(ecode2)) {
54011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
54012 }
54013 arg2 = static_cast< int >(val2);
54014 }
54015 {
54016 PyThreadState* __tstate = wxPyBeginAllowThreads();
54017 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
54018 wxPyEndAllowThreads(__tstate);
54019 if (PyErr_Occurred()) SWIG_fail;
54020 }
54021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
54022 return resultobj;
54023 fail:
54024 return NULL;
54025 }
54026
54027
54028 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54029 PyObject *resultobj = 0;
54030 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
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_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
54038 if (!SWIG_IsOK(res1)) {
54039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54040 }
54041 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54042 {
54043 PyThreadState* __tstate = wxPyBeginAllowThreads();
54044 delete arg1;
54045
54046 wxPyEndAllowThreads(__tstate);
54047 if (PyErr_Occurred()) SWIG_fail;
54048 }
54049 resultobj = SWIG_Py_Void();
54050 return resultobj;
54051 fail:
54052 return NULL;
54053 }
54054
54055
54056 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54057 PyObject *resultobj = 0;
54058 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54059 int result;
54060 void *argp1 = 0 ;
54061 int res1 = 0 ;
54062 PyObject *swig_obj[1] ;
54063
54064 if (!args) SWIG_fail;
54065 swig_obj[0] = args;
54066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54067 if (!SWIG_IsOK(res1)) {
54068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
54069 }
54070 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54071 {
54072 PyThreadState* __tstate = wxPyBeginAllowThreads();
54073 result = (int)((wxGBPosition const *)arg1)->GetRow();
54074 wxPyEndAllowThreads(__tstate);
54075 if (PyErr_Occurred()) SWIG_fail;
54076 }
54077 resultobj = SWIG_From_int(static_cast< int >(result));
54078 return resultobj;
54079 fail:
54080 return NULL;
54081 }
54082
54083
54084 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54085 PyObject *resultobj = 0;
54086 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54087 int result;
54088 void *argp1 = 0 ;
54089 int res1 = 0 ;
54090 PyObject *swig_obj[1] ;
54091
54092 if (!args) SWIG_fail;
54093 swig_obj[0] = args;
54094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54095 if (!SWIG_IsOK(res1)) {
54096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
54097 }
54098 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54099 {
54100 PyThreadState* __tstate = wxPyBeginAllowThreads();
54101 result = (int)((wxGBPosition const *)arg1)->GetCol();
54102 wxPyEndAllowThreads(__tstate);
54103 if (PyErr_Occurred()) SWIG_fail;
54104 }
54105 resultobj = SWIG_From_int(static_cast< int >(result));
54106 return resultobj;
54107 fail:
54108 return NULL;
54109 }
54110
54111
54112 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54113 PyObject *resultobj = 0;
54114 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54115 int arg2 ;
54116 void *argp1 = 0 ;
54117 int res1 = 0 ;
54118 int val2 ;
54119 int ecode2 = 0 ;
54120 PyObject * obj0 = 0 ;
54121 PyObject * obj1 = 0 ;
54122 char * kwnames[] = {
54123 (char *) "self",(char *) "row", NULL
54124 };
54125
54126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
54127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54128 if (!SWIG_IsOK(res1)) {
54129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54130 }
54131 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54132 ecode2 = SWIG_AsVal_int(obj1, &val2);
54133 if (!SWIG_IsOK(ecode2)) {
54134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
54135 }
54136 arg2 = static_cast< int >(val2);
54137 {
54138 PyThreadState* __tstate = wxPyBeginAllowThreads();
54139 (arg1)->SetRow(arg2);
54140 wxPyEndAllowThreads(__tstate);
54141 if (PyErr_Occurred()) SWIG_fail;
54142 }
54143 resultobj = SWIG_Py_Void();
54144 return resultobj;
54145 fail:
54146 return NULL;
54147 }
54148
54149
54150 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54151 PyObject *resultobj = 0;
54152 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54153 int arg2 ;
54154 void *argp1 = 0 ;
54155 int res1 = 0 ;
54156 int val2 ;
54157 int ecode2 = 0 ;
54158 PyObject * obj0 = 0 ;
54159 PyObject * obj1 = 0 ;
54160 char * kwnames[] = {
54161 (char *) "self",(char *) "col", NULL
54162 };
54163
54164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
54165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54166 if (!SWIG_IsOK(res1)) {
54167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54168 }
54169 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54170 ecode2 = SWIG_AsVal_int(obj1, &val2);
54171 if (!SWIG_IsOK(ecode2)) {
54172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
54173 }
54174 arg2 = static_cast< int >(val2);
54175 {
54176 PyThreadState* __tstate = wxPyBeginAllowThreads();
54177 (arg1)->SetCol(arg2);
54178 wxPyEndAllowThreads(__tstate);
54179 if (PyErr_Occurred()) SWIG_fail;
54180 }
54181 resultobj = SWIG_Py_Void();
54182 return resultobj;
54183 fail:
54184 return NULL;
54185 }
54186
54187
54188 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54189 PyObject *resultobj = 0;
54190 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54191 PyObject *arg2 = (PyObject *) 0 ;
54192 bool result;
54193 void *argp1 = 0 ;
54194 int res1 = 0 ;
54195 PyObject * obj0 = 0 ;
54196 PyObject * obj1 = 0 ;
54197 char * kwnames[] = {
54198 (char *) "self",(char *) "other", NULL
54199 };
54200
54201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
54202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54203 if (!SWIG_IsOK(res1)) {
54204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54205 }
54206 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54207 arg2 = obj1;
54208 {
54209 result = (bool)wxGBPosition___eq__(arg1,arg2);
54210 if (PyErr_Occurred()) SWIG_fail;
54211 }
54212 {
54213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54214 }
54215 return resultobj;
54216 fail:
54217 return NULL;
54218 }
54219
54220
54221 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54222 PyObject *resultobj = 0;
54223 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54224 PyObject *arg2 = (PyObject *) 0 ;
54225 bool result;
54226 void *argp1 = 0 ;
54227 int res1 = 0 ;
54228 PyObject * obj0 = 0 ;
54229 PyObject * obj1 = 0 ;
54230 char * kwnames[] = {
54231 (char *) "self",(char *) "other", NULL
54232 };
54233
54234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
54235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54236 if (!SWIG_IsOK(res1)) {
54237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54238 }
54239 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54240 arg2 = obj1;
54241 {
54242 result = (bool)wxGBPosition___ne__(arg1,arg2);
54243 if (PyErr_Occurred()) SWIG_fail;
54244 }
54245 {
54246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54247 }
54248 return resultobj;
54249 fail:
54250 return NULL;
54251 }
54252
54253
54254 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54255 PyObject *resultobj = 0;
54256 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54257 int arg2 = (int) 0 ;
54258 int arg3 = (int) 0 ;
54259 void *argp1 = 0 ;
54260 int res1 = 0 ;
54261 int val2 ;
54262 int ecode2 = 0 ;
54263 int val3 ;
54264 int ecode3 = 0 ;
54265 PyObject * obj0 = 0 ;
54266 PyObject * obj1 = 0 ;
54267 PyObject * obj2 = 0 ;
54268 char * kwnames[] = {
54269 (char *) "self",(char *) "row",(char *) "col", NULL
54270 };
54271
54272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54274 if (!SWIG_IsOK(res1)) {
54275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54276 }
54277 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54278 if (obj1) {
54279 ecode2 = SWIG_AsVal_int(obj1, &val2);
54280 if (!SWIG_IsOK(ecode2)) {
54281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
54282 }
54283 arg2 = static_cast< int >(val2);
54284 }
54285 if (obj2) {
54286 ecode3 = SWIG_AsVal_int(obj2, &val3);
54287 if (!SWIG_IsOK(ecode3)) {
54288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
54289 }
54290 arg3 = static_cast< int >(val3);
54291 }
54292 {
54293 PyThreadState* __tstate = wxPyBeginAllowThreads();
54294 wxGBPosition_Set(arg1,arg2,arg3);
54295 wxPyEndAllowThreads(__tstate);
54296 if (PyErr_Occurred()) SWIG_fail;
54297 }
54298 resultobj = SWIG_Py_Void();
54299 return resultobj;
54300 fail:
54301 return NULL;
54302 }
54303
54304
54305 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54306 PyObject *resultobj = 0;
54307 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54308 PyObject *result = 0 ;
54309 void *argp1 = 0 ;
54310 int res1 = 0 ;
54311 PyObject *swig_obj[1] ;
54312
54313 if (!args) SWIG_fail;
54314 swig_obj[0] = args;
54315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54316 if (!SWIG_IsOK(res1)) {
54317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54318 }
54319 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54320 {
54321 PyThreadState* __tstate = wxPyBeginAllowThreads();
54322 result = (PyObject *)wxGBPosition_Get(arg1);
54323 wxPyEndAllowThreads(__tstate);
54324 if (PyErr_Occurred()) SWIG_fail;
54325 }
54326 resultobj = result;
54327 return resultobj;
54328 fail:
54329 return NULL;
54330 }
54331
54332
54333 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54334 PyObject *obj;
54335 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54336 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
54337 return SWIG_Py_Void();
54338 }
54339
54340 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54341 return SWIG_Python_InitShadowInstance(args);
54342 }
54343
54344 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54345 PyObject *resultobj = 0;
54346 int arg1 = (int) 1 ;
54347 int arg2 = (int) 1 ;
54348 wxGBSpan *result = 0 ;
54349 int val1 ;
54350 int ecode1 = 0 ;
54351 int val2 ;
54352 int ecode2 = 0 ;
54353 PyObject * obj0 = 0 ;
54354 PyObject * obj1 = 0 ;
54355 char * kwnames[] = {
54356 (char *) "rowspan",(char *) "colspan", NULL
54357 };
54358
54359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
54360 if (obj0) {
54361 ecode1 = SWIG_AsVal_int(obj0, &val1);
54362 if (!SWIG_IsOK(ecode1)) {
54363 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
54364 }
54365 arg1 = static_cast< int >(val1);
54366 }
54367 if (obj1) {
54368 ecode2 = SWIG_AsVal_int(obj1, &val2);
54369 if (!SWIG_IsOK(ecode2)) {
54370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
54371 }
54372 arg2 = static_cast< int >(val2);
54373 }
54374 {
54375 PyThreadState* __tstate = wxPyBeginAllowThreads();
54376 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
54377 wxPyEndAllowThreads(__tstate);
54378 if (PyErr_Occurred()) SWIG_fail;
54379 }
54380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
54381 return resultobj;
54382 fail:
54383 return NULL;
54384 }
54385
54386
54387 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54388 PyObject *resultobj = 0;
54389 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54390 void *argp1 = 0 ;
54391 int res1 = 0 ;
54392 PyObject *swig_obj[1] ;
54393
54394 if (!args) SWIG_fail;
54395 swig_obj[0] = args;
54396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
54397 if (!SWIG_IsOK(res1)) {
54398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54399 }
54400 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54401 {
54402 PyThreadState* __tstate = wxPyBeginAllowThreads();
54403 delete arg1;
54404
54405 wxPyEndAllowThreads(__tstate);
54406 if (PyErr_Occurred()) SWIG_fail;
54407 }
54408 resultobj = SWIG_Py_Void();
54409 return resultobj;
54410 fail:
54411 return NULL;
54412 }
54413
54414
54415 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54416 PyObject *resultobj = 0;
54417 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54418 int result;
54419 void *argp1 = 0 ;
54420 int res1 = 0 ;
54421 PyObject *swig_obj[1] ;
54422
54423 if (!args) SWIG_fail;
54424 swig_obj[0] = args;
54425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54426 if (!SWIG_IsOK(res1)) {
54427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54428 }
54429 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54430 {
54431 PyThreadState* __tstate = wxPyBeginAllowThreads();
54432 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
54433 wxPyEndAllowThreads(__tstate);
54434 if (PyErr_Occurred()) SWIG_fail;
54435 }
54436 resultobj = SWIG_From_int(static_cast< int >(result));
54437 return resultobj;
54438 fail:
54439 return NULL;
54440 }
54441
54442
54443 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54444 PyObject *resultobj = 0;
54445 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54446 int result;
54447 void *argp1 = 0 ;
54448 int res1 = 0 ;
54449 PyObject *swig_obj[1] ;
54450
54451 if (!args) SWIG_fail;
54452 swig_obj[0] = args;
54453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54454 if (!SWIG_IsOK(res1)) {
54455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54456 }
54457 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54458 {
54459 PyThreadState* __tstate = wxPyBeginAllowThreads();
54460 result = (int)((wxGBSpan const *)arg1)->GetColspan();
54461 wxPyEndAllowThreads(__tstate);
54462 if (PyErr_Occurred()) SWIG_fail;
54463 }
54464 resultobj = SWIG_From_int(static_cast< int >(result));
54465 return resultobj;
54466 fail:
54467 return NULL;
54468 }
54469
54470
54471 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54472 PyObject *resultobj = 0;
54473 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54474 int arg2 ;
54475 void *argp1 = 0 ;
54476 int res1 = 0 ;
54477 int val2 ;
54478 int ecode2 = 0 ;
54479 PyObject * obj0 = 0 ;
54480 PyObject * obj1 = 0 ;
54481 char * kwnames[] = {
54482 (char *) "self",(char *) "rowspan", NULL
54483 };
54484
54485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
54486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54487 if (!SWIG_IsOK(res1)) {
54488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54489 }
54490 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54491 ecode2 = SWIG_AsVal_int(obj1, &val2);
54492 if (!SWIG_IsOK(ecode2)) {
54493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
54494 }
54495 arg2 = static_cast< int >(val2);
54496 {
54497 PyThreadState* __tstate = wxPyBeginAllowThreads();
54498 (arg1)->SetRowspan(arg2);
54499 wxPyEndAllowThreads(__tstate);
54500 if (PyErr_Occurred()) SWIG_fail;
54501 }
54502 resultobj = SWIG_Py_Void();
54503 return resultobj;
54504 fail:
54505 return NULL;
54506 }
54507
54508
54509 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54510 PyObject *resultobj = 0;
54511 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54512 int arg2 ;
54513 void *argp1 = 0 ;
54514 int res1 = 0 ;
54515 int val2 ;
54516 int ecode2 = 0 ;
54517 PyObject * obj0 = 0 ;
54518 PyObject * obj1 = 0 ;
54519 char * kwnames[] = {
54520 (char *) "self",(char *) "colspan", NULL
54521 };
54522
54523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
54524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54525 if (!SWIG_IsOK(res1)) {
54526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54527 }
54528 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54529 ecode2 = SWIG_AsVal_int(obj1, &val2);
54530 if (!SWIG_IsOK(ecode2)) {
54531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
54532 }
54533 arg2 = static_cast< int >(val2);
54534 {
54535 PyThreadState* __tstate = wxPyBeginAllowThreads();
54536 (arg1)->SetColspan(arg2);
54537 wxPyEndAllowThreads(__tstate);
54538 if (PyErr_Occurred()) SWIG_fail;
54539 }
54540 resultobj = SWIG_Py_Void();
54541 return resultobj;
54542 fail:
54543 return NULL;
54544 }
54545
54546
54547 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54548 PyObject *resultobj = 0;
54549 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54550 PyObject *arg2 = (PyObject *) 0 ;
54551 bool result;
54552 void *argp1 = 0 ;
54553 int res1 = 0 ;
54554 PyObject * obj0 = 0 ;
54555 PyObject * obj1 = 0 ;
54556 char * kwnames[] = {
54557 (char *) "self",(char *) "other", NULL
54558 };
54559
54560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
54561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54562 if (!SWIG_IsOK(res1)) {
54563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54564 }
54565 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54566 arg2 = obj1;
54567 {
54568 result = (bool)wxGBSpan___eq__(arg1,arg2);
54569 if (PyErr_Occurred()) SWIG_fail;
54570 }
54571 {
54572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54573 }
54574 return resultobj;
54575 fail:
54576 return NULL;
54577 }
54578
54579
54580 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54581 PyObject *resultobj = 0;
54582 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54583 PyObject *arg2 = (PyObject *) 0 ;
54584 bool result;
54585 void *argp1 = 0 ;
54586 int res1 = 0 ;
54587 PyObject * obj0 = 0 ;
54588 PyObject * obj1 = 0 ;
54589 char * kwnames[] = {
54590 (char *) "self",(char *) "other", NULL
54591 };
54592
54593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
54594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54595 if (!SWIG_IsOK(res1)) {
54596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54597 }
54598 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54599 arg2 = obj1;
54600 {
54601 result = (bool)wxGBSpan___ne__(arg1,arg2);
54602 if (PyErr_Occurred()) SWIG_fail;
54603 }
54604 {
54605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54606 }
54607 return resultobj;
54608 fail:
54609 return NULL;
54610 }
54611
54612
54613 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54614 PyObject *resultobj = 0;
54615 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54616 int arg2 = (int) 1 ;
54617 int arg3 = (int) 1 ;
54618 void *argp1 = 0 ;
54619 int res1 = 0 ;
54620 int val2 ;
54621 int ecode2 = 0 ;
54622 int val3 ;
54623 int ecode3 = 0 ;
54624 PyObject * obj0 = 0 ;
54625 PyObject * obj1 = 0 ;
54626 PyObject * obj2 = 0 ;
54627 char * kwnames[] = {
54628 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
54629 };
54630
54631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54633 if (!SWIG_IsOK(res1)) {
54634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54635 }
54636 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54637 if (obj1) {
54638 ecode2 = SWIG_AsVal_int(obj1, &val2);
54639 if (!SWIG_IsOK(ecode2)) {
54640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
54641 }
54642 arg2 = static_cast< int >(val2);
54643 }
54644 if (obj2) {
54645 ecode3 = SWIG_AsVal_int(obj2, &val3);
54646 if (!SWIG_IsOK(ecode3)) {
54647 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
54648 }
54649 arg3 = static_cast< int >(val3);
54650 }
54651 {
54652 PyThreadState* __tstate = wxPyBeginAllowThreads();
54653 wxGBSpan_Set(arg1,arg2,arg3);
54654 wxPyEndAllowThreads(__tstate);
54655 if (PyErr_Occurred()) SWIG_fail;
54656 }
54657 resultobj = SWIG_Py_Void();
54658 return resultobj;
54659 fail:
54660 return NULL;
54661 }
54662
54663
54664 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54665 PyObject *resultobj = 0;
54666 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54667 PyObject *result = 0 ;
54668 void *argp1 = 0 ;
54669 int res1 = 0 ;
54670 PyObject *swig_obj[1] ;
54671
54672 if (!args) SWIG_fail;
54673 swig_obj[0] = args;
54674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54675 if (!SWIG_IsOK(res1)) {
54676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54677 }
54678 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54679 {
54680 PyThreadState* __tstate = wxPyBeginAllowThreads();
54681 result = (PyObject *)wxGBSpan_Get(arg1);
54682 wxPyEndAllowThreads(__tstate);
54683 if (PyErr_Occurred()) SWIG_fail;
54684 }
54685 resultobj = result;
54686 return resultobj;
54687 fail:
54688 return NULL;
54689 }
54690
54691
54692 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54693 PyObject *obj;
54694 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54695 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
54696 return SWIG_Py_Void();
54697 }
54698
54699 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54700 return SWIG_Python_InitShadowInstance(args);
54701 }
54702
54703 SWIGINTERN int DefaultSpan_set(PyObject *) {
54704 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
54705 return 1;
54706 }
54707
54708
54709 SWIGINTERN PyObject *DefaultSpan_get(void) {
54710 PyObject *pyobj = 0;
54711
54712 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
54713 return pyobj;
54714 }
54715
54716
54717 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54718 PyObject *resultobj = 0;
54719 wxGBSizerItem *result = 0 ;
54720
54721 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
54722 {
54723 PyThreadState* __tstate = wxPyBeginAllowThreads();
54724 result = (wxGBSizerItem *)new wxGBSizerItem();
54725 wxPyEndAllowThreads(__tstate);
54726 if (PyErr_Occurred()) SWIG_fail;
54727 }
54728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
54729 return resultobj;
54730 fail:
54731 return NULL;
54732 }
54733
54734
54735 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54736 PyObject *resultobj = 0;
54737 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54738 void *argp1 = 0 ;
54739 int res1 = 0 ;
54740 PyObject *swig_obj[1] ;
54741
54742 if (!args) SWIG_fail;
54743 swig_obj[0] = args;
54744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
54745 if (!SWIG_IsOK(res1)) {
54746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
54747 }
54748 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54749 {
54750 PyThreadState* __tstate = wxPyBeginAllowThreads();
54751 delete arg1;
54752
54753 wxPyEndAllowThreads(__tstate);
54754 if (PyErr_Occurred()) SWIG_fail;
54755 }
54756 resultobj = SWIG_Py_Void();
54757 return resultobj;
54758 fail:
54759 return NULL;
54760 }
54761
54762
54763 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54764 PyObject *resultobj = 0;
54765 wxWindow *arg1 = (wxWindow *) 0 ;
54766 wxGBPosition *arg2 = 0 ;
54767 wxGBSpan *arg3 = 0 ;
54768 int arg4 ;
54769 int arg5 ;
54770 PyObject *arg6 = (PyObject *) NULL ;
54771 wxGBSizerItem *result = 0 ;
54772 void *argp1 = 0 ;
54773 int res1 = 0 ;
54774 wxGBPosition temp2 ;
54775 wxGBSpan temp3 ;
54776 int val4 ;
54777 int ecode4 = 0 ;
54778 int val5 ;
54779 int ecode5 = 0 ;
54780 PyObject * obj0 = 0 ;
54781 PyObject * obj1 = 0 ;
54782 PyObject * obj2 = 0 ;
54783 PyObject * obj3 = 0 ;
54784 PyObject * obj4 = 0 ;
54785 PyObject * obj5 = 0 ;
54786 char * kwnames[] = {
54787 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54788 };
54789
54790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
54791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
54792 if (!SWIG_IsOK(res1)) {
54793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
54794 }
54795 arg1 = reinterpret_cast< wxWindow * >(argp1);
54796 {
54797 arg2 = &temp2;
54798 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54799 }
54800 {
54801 arg3 = &temp3;
54802 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54803 }
54804 ecode4 = SWIG_AsVal_int(obj3, &val4);
54805 if (!SWIG_IsOK(ecode4)) {
54806 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
54807 }
54808 arg4 = static_cast< int >(val4);
54809 ecode5 = SWIG_AsVal_int(obj4, &val5);
54810 if (!SWIG_IsOK(ecode5)) {
54811 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
54812 }
54813 arg5 = static_cast< int >(val5);
54814 if (obj5) {
54815 arg6 = obj5;
54816 }
54817 {
54818 PyThreadState* __tstate = wxPyBeginAllowThreads();
54819 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
54820 wxPyEndAllowThreads(__tstate);
54821 if (PyErr_Occurred()) SWIG_fail;
54822 }
54823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
54824 return resultobj;
54825 fail:
54826 return NULL;
54827 }
54828
54829
54830 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54831 PyObject *resultobj = 0;
54832 wxSizer *arg1 = (wxSizer *) 0 ;
54833 wxGBPosition *arg2 = 0 ;
54834 wxGBSpan *arg3 = 0 ;
54835 int arg4 ;
54836 int arg5 ;
54837 PyObject *arg6 = (PyObject *) NULL ;
54838 wxGBSizerItem *result = 0 ;
54839 int res1 = 0 ;
54840 wxGBPosition temp2 ;
54841 wxGBSpan temp3 ;
54842 int val4 ;
54843 int ecode4 = 0 ;
54844 int val5 ;
54845 int ecode5 = 0 ;
54846 PyObject * obj0 = 0 ;
54847 PyObject * obj1 = 0 ;
54848 PyObject * obj2 = 0 ;
54849 PyObject * obj3 = 0 ;
54850 PyObject * obj4 = 0 ;
54851 PyObject * obj5 = 0 ;
54852 char * kwnames[] = {
54853 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54854 };
54855
54856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
54857 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
54858 if (!SWIG_IsOK(res1)) {
54859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
54860 }
54861 {
54862 arg2 = &temp2;
54863 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54864 }
54865 {
54866 arg3 = &temp3;
54867 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54868 }
54869 ecode4 = SWIG_AsVal_int(obj3, &val4);
54870 if (!SWIG_IsOK(ecode4)) {
54871 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
54872 }
54873 arg4 = static_cast< int >(val4);
54874 ecode5 = SWIG_AsVal_int(obj4, &val5);
54875 if (!SWIG_IsOK(ecode5)) {
54876 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
54877 }
54878 arg5 = static_cast< int >(val5);
54879 if (obj5) {
54880 arg6 = obj5;
54881 }
54882 {
54883 PyThreadState* __tstate = wxPyBeginAllowThreads();
54884 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
54885 wxPyEndAllowThreads(__tstate);
54886 if (PyErr_Occurred()) SWIG_fail;
54887 }
54888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
54889 return resultobj;
54890 fail:
54891 return NULL;
54892 }
54893
54894
54895 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54896 PyObject *resultobj = 0;
54897 int arg1 ;
54898 int arg2 ;
54899 wxGBPosition *arg3 = 0 ;
54900 wxGBSpan *arg4 = 0 ;
54901 int arg5 ;
54902 int arg6 ;
54903 PyObject *arg7 = (PyObject *) NULL ;
54904 wxGBSizerItem *result = 0 ;
54905 int val1 ;
54906 int ecode1 = 0 ;
54907 int val2 ;
54908 int ecode2 = 0 ;
54909 wxGBPosition temp3 ;
54910 wxGBSpan temp4 ;
54911 int val5 ;
54912 int ecode5 = 0 ;
54913 int val6 ;
54914 int ecode6 = 0 ;
54915 PyObject * obj0 = 0 ;
54916 PyObject * obj1 = 0 ;
54917 PyObject * obj2 = 0 ;
54918 PyObject * obj3 = 0 ;
54919 PyObject * obj4 = 0 ;
54920 PyObject * obj5 = 0 ;
54921 PyObject * obj6 = 0 ;
54922 char * kwnames[] = {
54923 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54924 };
54925
54926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
54927 ecode1 = SWIG_AsVal_int(obj0, &val1);
54928 if (!SWIG_IsOK(ecode1)) {
54929 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
54930 }
54931 arg1 = static_cast< int >(val1);
54932 ecode2 = SWIG_AsVal_int(obj1, &val2);
54933 if (!SWIG_IsOK(ecode2)) {
54934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
54935 }
54936 arg2 = static_cast< int >(val2);
54937 {
54938 arg3 = &temp3;
54939 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
54940 }
54941 {
54942 arg4 = &temp4;
54943 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
54944 }
54945 ecode5 = SWIG_AsVal_int(obj4, &val5);
54946 if (!SWIG_IsOK(ecode5)) {
54947 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
54948 }
54949 arg5 = static_cast< int >(val5);
54950 ecode6 = SWIG_AsVal_int(obj5, &val6);
54951 if (!SWIG_IsOK(ecode6)) {
54952 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
54953 }
54954 arg6 = static_cast< int >(val6);
54955 if (obj6) {
54956 arg7 = obj6;
54957 }
54958 {
54959 PyThreadState* __tstate = wxPyBeginAllowThreads();
54960 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
54961 wxPyEndAllowThreads(__tstate);
54962 if (PyErr_Occurred()) SWIG_fail;
54963 }
54964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
54965 return resultobj;
54966 fail:
54967 return NULL;
54968 }
54969
54970
54971 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54972 PyObject *resultobj = 0;
54973 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54974 wxGBPosition result;
54975 void *argp1 = 0 ;
54976 int res1 = 0 ;
54977 PyObject *swig_obj[1] ;
54978
54979 if (!args) SWIG_fail;
54980 swig_obj[0] = args;
54981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54982 if (!SWIG_IsOK(res1)) {
54983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
54984 }
54985 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54986 {
54987 PyThreadState* __tstate = wxPyBeginAllowThreads();
54988 result = ((wxGBSizerItem const *)arg1)->GetPos();
54989 wxPyEndAllowThreads(__tstate);
54990 if (PyErr_Occurred()) SWIG_fail;
54991 }
54992 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54993 return resultobj;
54994 fail:
54995 return NULL;
54996 }
54997
54998
54999 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55000 PyObject *resultobj = 0;
55001 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55002 wxGBSpan result;
55003 void *argp1 = 0 ;
55004 int res1 = 0 ;
55005 PyObject *swig_obj[1] ;
55006
55007 if (!args) SWIG_fail;
55008 swig_obj[0] = args;
55009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55010 if (!SWIG_IsOK(res1)) {
55011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55012 }
55013 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55014 {
55015 PyThreadState* __tstate = wxPyBeginAllowThreads();
55016 result = ((wxGBSizerItem const *)arg1)->GetSpan();
55017 wxPyEndAllowThreads(__tstate);
55018 if (PyErr_Occurred()) SWIG_fail;
55019 }
55020 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55021 return resultobj;
55022 fail:
55023 return NULL;
55024 }
55025
55026
55027 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55028 PyObject *resultobj = 0;
55029 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55030 wxGBPosition *arg2 = 0 ;
55031 bool result;
55032 void *argp1 = 0 ;
55033 int res1 = 0 ;
55034 wxGBPosition temp2 ;
55035 PyObject * obj0 = 0 ;
55036 PyObject * obj1 = 0 ;
55037 char * kwnames[] = {
55038 (char *) "self",(char *) "pos", NULL
55039 };
55040
55041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
55042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55043 if (!SWIG_IsOK(res1)) {
55044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55045 }
55046 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55047 {
55048 arg2 = &temp2;
55049 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55050 }
55051 {
55052 PyThreadState* __tstate = wxPyBeginAllowThreads();
55053 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
55054 wxPyEndAllowThreads(__tstate);
55055 if (PyErr_Occurred()) SWIG_fail;
55056 }
55057 {
55058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55059 }
55060 return resultobj;
55061 fail:
55062 return NULL;
55063 }
55064
55065
55066 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55067 PyObject *resultobj = 0;
55068 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55069 wxGBSpan *arg2 = 0 ;
55070 bool result;
55071 void *argp1 = 0 ;
55072 int res1 = 0 ;
55073 wxGBSpan temp2 ;
55074 PyObject * obj0 = 0 ;
55075 PyObject * obj1 = 0 ;
55076 char * kwnames[] = {
55077 (char *) "self",(char *) "span", NULL
55078 };
55079
55080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
55081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55082 if (!SWIG_IsOK(res1)) {
55083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55084 }
55085 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55086 {
55087 arg2 = &temp2;
55088 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
55089 }
55090 {
55091 PyThreadState* __tstate = wxPyBeginAllowThreads();
55092 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
55093 wxPyEndAllowThreads(__tstate);
55094 if (PyErr_Occurred()) SWIG_fail;
55095 }
55096 {
55097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55098 }
55099 return resultobj;
55100 fail:
55101 return NULL;
55102 }
55103
55104
55105 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55106 PyObject *resultobj = 0;
55107 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55108 wxGBSizerItem *arg2 = 0 ;
55109 bool result;
55110 void *argp1 = 0 ;
55111 int res1 = 0 ;
55112 void *argp2 = 0 ;
55113 int res2 = 0 ;
55114 PyObject * obj0 = 0 ;
55115 PyObject * obj1 = 0 ;
55116 char * kwnames[] = {
55117 (char *) "self",(char *) "other", NULL
55118 };
55119
55120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
55121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55122 if (!SWIG_IsOK(res1)) {
55123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55124 }
55125 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55126 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
55127 if (!SWIG_IsOK(res2)) {
55128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55129 }
55130 if (!argp2) {
55131 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55132 }
55133 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
55134 {
55135 PyThreadState* __tstate = wxPyBeginAllowThreads();
55136 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
55137 wxPyEndAllowThreads(__tstate);
55138 if (PyErr_Occurred()) SWIG_fail;
55139 }
55140 {
55141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55142 }
55143 return resultobj;
55144 fail:
55145 return NULL;
55146 }
55147
55148
55149 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55150 PyObject *resultobj = 0;
55151 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55152 wxGBPosition *arg2 = 0 ;
55153 wxGBSpan *arg3 = 0 ;
55154 bool result;
55155 void *argp1 = 0 ;
55156 int res1 = 0 ;
55157 wxGBPosition temp2 ;
55158 wxGBSpan temp3 ;
55159 PyObject * obj0 = 0 ;
55160 PyObject * obj1 = 0 ;
55161 PyObject * obj2 = 0 ;
55162 char * kwnames[] = {
55163 (char *) "self",(char *) "pos",(char *) "span", NULL
55164 };
55165
55166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55168 if (!SWIG_IsOK(res1)) {
55169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55170 }
55171 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55172 {
55173 arg2 = &temp2;
55174 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55175 }
55176 {
55177 arg3 = &temp3;
55178 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55179 }
55180 {
55181 PyThreadState* __tstate = wxPyBeginAllowThreads();
55182 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
55183 wxPyEndAllowThreads(__tstate);
55184 if (PyErr_Occurred()) SWIG_fail;
55185 }
55186 {
55187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55188 }
55189 return resultobj;
55190 fail:
55191 return NULL;
55192 }
55193
55194
55195 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55196 PyObject *resultobj = 0;
55197 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55198 wxGBPosition result;
55199 void *argp1 = 0 ;
55200 int res1 = 0 ;
55201 PyObject *swig_obj[1] ;
55202
55203 if (!args) SWIG_fail;
55204 swig_obj[0] = args;
55205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55206 if (!SWIG_IsOK(res1)) {
55207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55208 }
55209 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55210 {
55211 PyThreadState* __tstate = wxPyBeginAllowThreads();
55212 result = wxGBSizerItem_GetEndPos(arg1);
55213 wxPyEndAllowThreads(__tstate);
55214 if (PyErr_Occurred()) SWIG_fail;
55215 }
55216 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55217 return resultobj;
55218 fail:
55219 return NULL;
55220 }
55221
55222
55223 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55224 PyObject *resultobj = 0;
55225 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55226 wxGridBagSizer *result = 0 ;
55227 void *argp1 = 0 ;
55228 int res1 = 0 ;
55229 PyObject *swig_obj[1] ;
55230
55231 if (!args) SWIG_fail;
55232 swig_obj[0] = args;
55233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55234 if (!SWIG_IsOK(res1)) {
55235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55236 }
55237 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55238 {
55239 PyThreadState* __tstate = wxPyBeginAllowThreads();
55240 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
55241 wxPyEndAllowThreads(__tstate);
55242 if (PyErr_Occurred()) SWIG_fail;
55243 }
55244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55245 return resultobj;
55246 fail:
55247 return NULL;
55248 }
55249
55250
55251 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55252 PyObject *resultobj = 0;
55253 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55254 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
55255 void *argp1 = 0 ;
55256 int res1 = 0 ;
55257 void *argp2 = 0 ;
55258 int res2 = 0 ;
55259 PyObject * obj0 = 0 ;
55260 PyObject * obj1 = 0 ;
55261 char * kwnames[] = {
55262 (char *) "self",(char *) "sizer", NULL
55263 };
55264
55265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55267 if (!SWIG_IsOK(res1)) {
55268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55269 }
55270 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55271 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55272 if (!SWIG_IsOK(res2)) {
55273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
55274 }
55275 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
55276 {
55277 PyThreadState* __tstate = wxPyBeginAllowThreads();
55278 (arg1)->SetGBSizer(arg2);
55279 wxPyEndAllowThreads(__tstate);
55280 if (PyErr_Occurred()) SWIG_fail;
55281 }
55282 resultobj = SWIG_Py_Void();
55283 return resultobj;
55284 fail:
55285 return NULL;
55286 }
55287
55288
55289 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55290 PyObject *obj;
55291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55292 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
55293 return SWIG_Py_Void();
55294 }
55295
55296 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55297 return SWIG_Python_InitShadowInstance(args);
55298 }
55299
55300 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55301 PyObject *resultobj = 0;
55302 int arg1 = (int) 0 ;
55303 int arg2 = (int) 0 ;
55304 wxGridBagSizer *result = 0 ;
55305 int val1 ;
55306 int ecode1 = 0 ;
55307 int val2 ;
55308 int ecode2 = 0 ;
55309 PyObject * obj0 = 0 ;
55310 PyObject * obj1 = 0 ;
55311 char * kwnames[] = {
55312 (char *) "vgap",(char *) "hgap", NULL
55313 };
55314
55315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55316 if (obj0) {
55317 ecode1 = SWIG_AsVal_int(obj0, &val1);
55318 if (!SWIG_IsOK(ecode1)) {
55319 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
55320 }
55321 arg1 = static_cast< int >(val1);
55322 }
55323 if (obj1) {
55324 ecode2 = SWIG_AsVal_int(obj1, &val2);
55325 if (!SWIG_IsOK(ecode2)) {
55326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
55327 }
55328 arg2 = static_cast< int >(val2);
55329 }
55330 {
55331 PyThreadState* __tstate = wxPyBeginAllowThreads();
55332 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
55333 wxPyEndAllowThreads(__tstate);
55334 if (PyErr_Occurred()) SWIG_fail;
55335 }
55336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
55337 return resultobj;
55338 fail:
55339 return NULL;
55340 }
55341
55342
55343 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55344 PyObject *resultobj = 0;
55345 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55346 PyObject *arg2 = (PyObject *) 0 ;
55347 wxGBPosition *arg3 = 0 ;
55348 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
55349 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
55350 int arg5 = (int) 0 ;
55351 int arg6 = (int) 0 ;
55352 PyObject *arg7 = (PyObject *) NULL ;
55353 wxGBSizerItem *result = 0 ;
55354 void *argp1 = 0 ;
55355 int res1 = 0 ;
55356 wxGBPosition temp3 ;
55357 wxGBSpan temp4 ;
55358 int val5 ;
55359 int ecode5 = 0 ;
55360 int val6 ;
55361 int ecode6 = 0 ;
55362 PyObject * obj0 = 0 ;
55363 PyObject * obj1 = 0 ;
55364 PyObject * obj2 = 0 ;
55365 PyObject * obj3 = 0 ;
55366 PyObject * obj4 = 0 ;
55367 PyObject * obj5 = 0 ;
55368 PyObject * obj6 = 0 ;
55369 char * kwnames[] = {
55370 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55371 };
55372
55373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
55374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55375 if (!SWIG_IsOK(res1)) {
55376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55377 }
55378 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55379 arg2 = obj1;
55380 {
55381 arg3 = &temp3;
55382 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
55383 }
55384 if (obj3) {
55385 {
55386 arg4 = &temp4;
55387 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
55388 }
55389 }
55390 if (obj4) {
55391 ecode5 = SWIG_AsVal_int(obj4, &val5);
55392 if (!SWIG_IsOK(ecode5)) {
55393 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
55394 }
55395 arg5 = static_cast< int >(val5);
55396 }
55397 if (obj5) {
55398 ecode6 = SWIG_AsVal_int(obj5, &val6);
55399 if (!SWIG_IsOK(ecode6)) {
55400 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
55401 }
55402 arg6 = static_cast< int >(val6);
55403 }
55404 if (obj6) {
55405 arg7 = obj6;
55406 }
55407 {
55408 PyThreadState* __tstate = wxPyBeginAllowThreads();
55409 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
55410 wxPyEndAllowThreads(__tstate);
55411 if (PyErr_Occurred()) SWIG_fail;
55412 }
55413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55414 return resultobj;
55415 fail:
55416 return NULL;
55417 }
55418
55419
55420 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55421 PyObject *resultobj = 0;
55422 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55423 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
55424 wxGBSizerItem *result = 0 ;
55425 void *argp1 = 0 ;
55426 int res1 = 0 ;
55427 int res2 = 0 ;
55428 PyObject * obj0 = 0 ;
55429 PyObject * obj1 = 0 ;
55430 char * kwnames[] = {
55431 (char *) "self",(char *) "item", NULL
55432 };
55433
55434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
55435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55436 if (!SWIG_IsOK(res1)) {
55437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55438 }
55439 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55440 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
55441 if (!SWIG_IsOK(res2)) {
55442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
55443 }
55444 {
55445 PyThreadState* __tstate = wxPyBeginAllowThreads();
55446 result = (wxGBSizerItem *)(arg1)->Add(arg2);
55447 wxPyEndAllowThreads(__tstate);
55448 if (PyErr_Occurred()) SWIG_fail;
55449 }
55450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55451 return resultobj;
55452 fail:
55453 return NULL;
55454 }
55455
55456
55457 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55458 PyObject *resultobj = 0;
55459 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55460 int arg2 ;
55461 int arg3 ;
55462 wxSize result;
55463 void *argp1 = 0 ;
55464 int res1 = 0 ;
55465 int val2 ;
55466 int ecode2 = 0 ;
55467 int val3 ;
55468 int ecode3 = 0 ;
55469 PyObject * obj0 = 0 ;
55470 PyObject * obj1 = 0 ;
55471 PyObject * obj2 = 0 ;
55472 char * kwnames[] = {
55473 (char *) "self",(char *) "row",(char *) "col", NULL
55474 };
55475
55476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55478 if (!SWIG_IsOK(res1)) {
55479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
55480 }
55481 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55482 ecode2 = SWIG_AsVal_int(obj1, &val2);
55483 if (!SWIG_IsOK(ecode2)) {
55484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
55485 }
55486 arg2 = static_cast< int >(val2);
55487 ecode3 = SWIG_AsVal_int(obj2, &val3);
55488 if (!SWIG_IsOK(ecode3)) {
55489 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
55490 }
55491 arg3 = static_cast< int >(val3);
55492 {
55493 PyThreadState* __tstate = wxPyBeginAllowThreads();
55494 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
55495 wxPyEndAllowThreads(__tstate);
55496 if (PyErr_Occurred()) SWIG_fail;
55497 }
55498 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
55499 return resultobj;
55500 fail:
55501 return NULL;
55502 }
55503
55504
55505 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55506 PyObject *resultobj = 0;
55507 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55508 wxSize result;
55509 void *argp1 = 0 ;
55510 int res1 = 0 ;
55511 PyObject *swig_obj[1] ;
55512
55513 if (!args) SWIG_fail;
55514 swig_obj[0] = args;
55515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55516 if (!SWIG_IsOK(res1)) {
55517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
55518 }
55519 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55520 {
55521 PyThreadState* __tstate = wxPyBeginAllowThreads();
55522 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
55523 wxPyEndAllowThreads(__tstate);
55524 if (PyErr_Occurred()) SWIG_fail;
55525 }
55526 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
55527 return resultobj;
55528 fail:
55529 return NULL;
55530 }
55531
55532
55533 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55534 PyObject *resultobj = 0;
55535 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55536 wxSize *arg2 = 0 ;
55537 void *argp1 = 0 ;
55538 int res1 = 0 ;
55539 wxSize temp2 ;
55540 PyObject * obj0 = 0 ;
55541 PyObject * obj1 = 0 ;
55542 char * kwnames[] = {
55543 (char *) "self",(char *) "sz", NULL
55544 };
55545
55546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
55547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55548 if (!SWIG_IsOK(res1)) {
55549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55550 }
55551 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55552 {
55553 arg2 = &temp2;
55554 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
55555 }
55556 {
55557 PyThreadState* __tstate = wxPyBeginAllowThreads();
55558 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
55559 wxPyEndAllowThreads(__tstate);
55560 if (PyErr_Occurred()) SWIG_fail;
55561 }
55562 resultobj = SWIG_Py_Void();
55563 return resultobj;
55564 fail:
55565 return NULL;
55566 }
55567
55568
55569 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55570 PyObject *resultobj = 0;
55571 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55572 wxWindow *arg2 = (wxWindow *) 0 ;
55573 wxGBPosition result;
55574 void *argp1 = 0 ;
55575 int res1 = 0 ;
55576 void *argp2 = 0 ;
55577 int res2 = 0 ;
55578
55579 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55581 if (!SWIG_IsOK(res1)) {
55582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55583 }
55584 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55585 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55586 if (!SWIG_IsOK(res2)) {
55587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
55588 }
55589 arg2 = reinterpret_cast< wxWindow * >(argp2);
55590 {
55591 PyThreadState* __tstate = wxPyBeginAllowThreads();
55592 result = (arg1)->GetItemPosition(arg2);
55593 wxPyEndAllowThreads(__tstate);
55594 if (PyErr_Occurred()) SWIG_fail;
55595 }
55596 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55597 return resultobj;
55598 fail:
55599 return NULL;
55600 }
55601
55602
55603 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55604 PyObject *resultobj = 0;
55605 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55606 wxSizer *arg2 = (wxSizer *) 0 ;
55607 wxGBPosition result;
55608 void *argp1 = 0 ;
55609 int res1 = 0 ;
55610 void *argp2 = 0 ;
55611 int res2 = 0 ;
55612
55613 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55615 if (!SWIG_IsOK(res1)) {
55616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55617 }
55618 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55619 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55620 if (!SWIG_IsOK(res2)) {
55621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
55622 }
55623 arg2 = reinterpret_cast< wxSizer * >(argp2);
55624 {
55625 PyThreadState* __tstate = wxPyBeginAllowThreads();
55626 result = (arg1)->GetItemPosition(arg2);
55627 wxPyEndAllowThreads(__tstate);
55628 if (PyErr_Occurred()) SWIG_fail;
55629 }
55630 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55631 return resultobj;
55632 fail:
55633 return NULL;
55634 }
55635
55636
55637 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55638 PyObject *resultobj = 0;
55639 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55640 size_t arg2 ;
55641 wxGBPosition result;
55642 void *argp1 = 0 ;
55643 int res1 = 0 ;
55644 size_t val2 ;
55645 int ecode2 = 0 ;
55646
55647 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55649 if (!SWIG_IsOK(res1)) {
55650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55651 }
55652 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55653 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55654 if (!SWIG_IsOK(ecode2)) {
55655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
55656 }
55657 arg2 = static_cast< size_t >(val2);
55658 {
55659 PyThreadState* __tstate = wxPyBeginAllowThreads();
55660 result = (arg1)->GetItemPosition(arg2);
55661 wxPyEndAllowThreads(__tstate);
55662 if (PyErr_Occurred()) SWIG_fail;
55663 }
55664 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55665 return resultobj;
55666 fail:
55667 return NULL;
55668 }
55669
55670
55671 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
55672 int argc;
55673 PyObject *argv[3];
55674
55675 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
55676 --argc;
55677 if (argc == 2) {
55678 int _v = 0;
55679 {
55680 void *vptr = 0;
55681 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55682 _v = SWIG_CheckState(res);
55683 }
55684 if (!_v) goto check_1;
55685 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
55686 }
55687 check_1:
55688
55689 if (argc == 2) {
55690 int _v = 0;
55691 {
55692 void *vptr = 0;
55693 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
55694 _v = SWIG_CheckState(res);
55695 }
55696 if (!_v) goto check_2;
55697 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
55698 }
55699 check_2:
55700
55701 if (argc == 2) {
55702 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
55703 }
55704
55705 fail:
55706 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
55707 return NULL;
55708 }
55709
55710
55711 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55712 PyObject *resultobj = 0;
55713 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55714 wxWindow *arg2 = (wxWindow *) 0 ;
55715 wxGBPosition *arg3 = 0 ;
55716 bool result;
55717 void *argp1 = 0 ;
55718 int res1 = 0 ;
55719 void *argp2 = 0 ;
55720 int res2 = 0 ;
55721 wxGBPosition temp3 ;
55722
55723 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55725 if (!SWIG_IsOK(res1)) {
55726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55727 }
55728 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55729 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55730 if (!SWIG_IsOK(res2)) {
55731 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
55732 }
55733 arg2 = reinterpret_cast< wxWindow * >(argp2);
55734 {
55735 arg3 = &temp3;
55736 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
55737 }
55738 {
55739 PyThreadState* __tstate = wxPyBeginAllowThreads();
55740 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
55741 wxPyEndAllowThreads(__tstate);
55742 if (PyErr_Occurred()) SWIG_fail;
55743 }
55744 {
55745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55746 }
55747 return resultobj;
55748 fail:
55749 return NULL;
55750 }
55751
55752
55753 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55754 PyObject *resultobj = 0;
55755 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55756 wxSizer *arg2 = (wxSizer *) 0 ;
55757 wxGBPosition *arg3 = 0 ;
55758 bool result;
55759 void *argp1 = 0 ;
55760 int res1 = 0 ;
55761 void *argp2 = 0 ;
55762 int res2 = 0 ;
55763 wxGBPosition temp3 ;
55764
55765 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55767 if (!SWIG_IsOK(res1)) {
55768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55769 }
55770 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55771 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55772 if (!SWIG_IsOK(res2)) {
55773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
55774 }
55775 arg2 = reinterpret_cast< wxSizer * >(argp2);
55776 {
55777 arg3 = &temp3;
55778 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
55779 }
55780 {
55781 PyThreadState* __tstate = wxPyBeginAllowThreads();
55782 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
55783 wxPyEndAllowThreads(__tstate);
55784 if (PyErr_Occurred()) SWIG_fail;
55785 }
55786 {
55787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55788 }
55789 return resultobj;
55790 fail:
55791 return NULL;
55792 }
55793
55794
55795 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55796 PyObject *resultobj = 0;
55797 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55798 size_t arg2 ;
55799 wxGBPosition *arg3 = 0 ;
55800 bool result;
55801 void *argp1 = 0 ;
55802 int res1 = 0 ;
55803 size_t val2 ;
55804 int ecode2 = 0 ;
55805 wxGBPosition temp3 ;
55806
55807 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55809 if (!SWIG_IsOK(res1)) {
55810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55811 }
55812 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55813 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55814 if (!SWIG_IsOK(ecode2)) {
55815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
55816 }
55817 arg2 = static_cast< size_t >(val2);
55818 {
55819 arg3 = &temp3;
55820 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
55821 }
55822 {
55823 PyThreadState* __tstate = wxPyBeginAllowThreads();
55824 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
55825 wxPyEndAllowThreads(__tstate);
55826 if (PyErr_Occurred()) SWIG_fail;
55827 }
55828 {
55829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55830 }
55831 return resultobj;
55832 fail:
55833 return NULL;
55834 }
55835
55836
55837 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
55838 int argc;
55839 PyObject *argv[4];
55840
55841 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
55842 --argc;
55843 if (argc == 3) {
55844 int _v = 0;
55845 {
55846 void *vptr = 0;
55847 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55848 _v = SWIG_CheckState(res);
55849 }
55850 if (!_v) goto check_1;
55851 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
55852 }
55853 check_1:
55854
55855 if (argc == 3) {
55856 int _v = 0;
55857 {
55858 void *vptr = 0;
55859 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
55860 _v = SWIG_CheckState(res);
55861 }
55862 if (!_v) goto check_2;
55863 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
55864 }
55865 check_2:
55866
55867 if (argc == 3) {
55868 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
55869 }
55870
55871 fail:
55872 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
55873 return NULL;
55874 }
55875
55876
55877 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55878 PyObject *resultobj = 0;
55879 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55880 wxWindow *arg2 = (wxWindow *) 0 ;
55881 wxGBSpan result;
55882 void *argp1 = 0 ;
55883 int res1 = 0 ;
55884 void *argp2 = 0 ;
55885 int res2 = 0 ;
55886
55887 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55889 if (!SWIG_IsOK(res1)) {
55890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55891 }
55892 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55893 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55894 if (!SWIG_IsOK(res2)) {
55895 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
55896 }
55897 arg2 = reinterpret_cast< wxWindow * >(argp2);
55898 {
55899 PyThreadState* __tstate = wxPyBeginAllowThreads();
55900 result = (arg1)->GetItemSpan(arg2);
55901 wxPyEndAllowThreads(__tstate);
55902 if (PyErr_Occurred()) SWIG_fail;
55903 }
55904 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55905 return resultobj;
55906 fail:
55907 return NULL;
55908 }
55909
55910
55911 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55912 PyObject *resultobj = 0;
55913 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55914 wxSizer *arg2 = (wxSizer *) 0 ;
55915 wxGBSpan result;
55916 void *argp1 = 0 ;
55917 int res1 = 0 ;
55918 void *argp2 = 0 ;
55919 int res2 = 0 ;
55920
55921 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55923 if (!SWIG_IsOK(res1)) {
55924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55925 }
55926 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55927 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55928 if (!SWIG_IsOK(res2)) {
55929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
55930 }
55931 arg2 = reinterpret_cast< wxSizer * >(argp2);
55932 {
55933 PyThreadState* __tstate = wxPyBeginAllowThreads();
55934 result = (arg1)->GetItemSpan(arg2);
55935 wxPyEndAllowThreads(__tstate);
55936 if (PyErr_Occurred()) SWIG_fail;
55937 }
55938 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55939 return resultobj;
55940 fail:
55941 return NULL;
55942 }
55943
55944
55945 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55946 PyObject *resultobj = 0;
55947 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55948 size_t arg2 ;
55949 wxGBSpan result;
55950 void *argp1 = 0 ;
55951 int res1 = 0 ;
55952 size_t val2 ;
55953 int ecode2 = 0 ;
55954
55955 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55957 if (!SWIG_IsOK(res1)) {
55958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55959 }
55960 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55961 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55962 if (!SWIG_IsOK(ecode2)) {
55963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
55964 }
55965 arg2 = static_cast< size_t >(val2);
55966 {
55967 PyThreadState* __tstate = wxPyBeginAllowThreads();
55968 result = (arg1)->GetItemSpan(arg2);
55969 wxPyEndAllowThreads(__tstate);
55970 if (PyErr_Occurred()) SWIG_fail;
55971 }
55972 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55973 return resultobj;
55974 fail:
55975 return NULL;
55976 }
55977
55978
55979 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
55980 int argc;
55981 PyObject *argv[3];
55982
55983 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
55984 --argc;
55985 if (argc == 2) {
55986 int _v = 0;
55987 {
55988 void *vptr = 0;
55989 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55990 _v = SWIG_CheckState(res);
55991 }
55992 if (!_v) goto check_1;
55993 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
55994 }
55995 check_1:
55996
55997 if (argc == 2) {
55998 int _v = 0;
55999 {
56000 void *vptr = 0;
56001 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56002 _v = SWIG_CheckState(res);
56003 }
56004 if (!_v) goto check_2;
56005 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
56006 }
56007 check_2:
56008
56009 if (argc == 2) {
56010 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
56011 }
56012
56013 fail:
56014 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
56015 return NULL;
56016 }
56017
56018
56019 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56020 PyObject *resultobj = 0;
56021 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56022 wxWindow *arg2 = (wxWindow *) 0 ;
56023 wxGBSpan *arg3 = 0 ;
56024 bool result;
56025 void *argp1 = 0 ;
56026 int res1 = 0 ;
56027 void *argp2 = 0 ;
56028 int res2 = 0 ;
56029 wxGBSpan temp3 ;
56030
56031 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56033 if (!SWIG_IsOK(res1)) {
56034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56035 }
56036 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56037 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56038 if (!SWIG_IsOK(res2)) {
56039 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
56040 }
56041 arg2 = reinterpret_cast< wxWindow * >(argp2);
56042 {
56043 arg3 = &temp3;
56044 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56045 }
56046 {
56047 PyThreadState* __tstate = wxPyBeginAllowThreads();
56048 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56049 wxPyEndAllowThreads(__tstate);
56050 if (PyErr_Occurred()) SWIG_fail;
56051 }
56052 {
56053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56054 }
56055 return resultobj;
56056 fail:
56057 return NULL;
56058 }
56059
56060
56061 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56062 PyObject *resultobj = 0;
56063 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56064 wxSizer *arg2 = (wxSizer *) 0 ;
56065 wxGBSpan *arg3 = 0 ;
56066 bool result;
56067 void *argp1 = 0 ;
56068 int res1 = 0 ;
56069 void *argp2 = 0 ;
56070 int res2 = 0 ;
56071 wxGBSpan temp3 ;
56072
56073 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56075 if (!SWIG_IsOK(res1)) {
56076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56077 }
56078 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56079 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56080 if (!SWIG_IsOK(res2)) {
56081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
56082 }
56083 arg2 = reinterpret_cast< wxSizer * >(argp2);
56084 {
56085 arg3 = &temp3;
56086 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56087 }
56088 {
56089 PyThreadState* __tstate = wxPyBeginAllowThreads();
56090 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56091 wxPyEndAllowThreads(__tstate);
56092 if (PyErr_Occurred()) SWIG_fail;
56093 }
56094 {
56095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56096 }
56097 return resultobj;
56098 fail:
56099 return NULL;
56100 }
56101
56102
56103 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56104 PyObject *resultobj = 0;
56105 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56106 size_t arg2 ;
56107 wxGBSpan *arg3 = 0 ;
56108 bool result;
56109 void *argp1 = 0 ;
56110 int res1 = 0 ;
56111 size_t val2 ;
56112 int ecode2 = 0 ;
56113 wxGBSpan temp3 ;
56114
56115 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56117 if (!SWIG_IsOK(res1)) {
56118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56119 }
56120 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56121 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56122 if (!SWIG_IsOK(ecode2)) {
56123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
56124 }
56125 arg2 = static_cast< size_t >(val2);
56126 {
56127 arg3 = &temp3;
56128 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56129 }
56130 {
56131 PyThreadState* __tstate = wxPyBeginAllowThreads();
56132 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56133 wxPyEndAllowThreads(__tstate);
56134 if (PyErr_Occurred()) SWIG_fail;
56135 }
56136 {
56137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56138 }
56139 return resultobj;
56140 fail:
56141 return NULL;
56142 }
56143
56144
56145 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
56146 int argc;
56147 PyObject *argv[4];
56148
56149 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
56150 --argc;
56151 if (argc == 3) {
56152 int _v = 0;
56153 {
56154 void *vptr = 0;
56155 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56156 _v = SWIG_CheckState(res);
56157 }
56158 if (!_v) goto check_1;
56159 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
56160 }
56161 check_1:
56162
56163 if (argc == 3) {
56164 int _v = 0;
56165 {
56166 void *vptr = 0;
56167 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56168 _v = SWIG_CheckState(res);
56169 }
56170 if (!_v) goto check_2;
56171 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
56172 }
56173 check_2:
56174
56175 if (argc == 3) {
56176 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
56177 }
56178
56179 fail:
56180 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
56181 return NULL;
56182 }
56183
56184
56185 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56186 PyObject *resultobj = 0;
56187 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56188 wxWindow *arg2 = (wxWindow *) 0 ;
56189 wxGBSizerItem *result = 0 ;
56190 void *argp1 = 0 ;
56191 int res1 = 0 ;
56192 void *argp2 = 0 ;
56193 int res2 = 0 ;
56194
56195 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56197 if (!SWIG_IsOK(res1)) {
56198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56199 }
56200 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56201 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56202 if (!SWIG_IsOK(res2)) {
56203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
56204 }
56205 arg2 = reinterpret_cast< wxWindow * >(argp2);
56206 {
56207 PyThreadState* __tstate = wxPyBeginAllowThreads();
56208 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56209 wxPyEndAllowThreads(__tstate);
56210 if (PyErr_Occurred()) SWIG_fail;
56211 }
56212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56213 return resultobj;
56214 fail:
56215 return NULL;
56216 }
56217
56218
56219 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56220 PyObject *resultobj = 0;
56221 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56222 wxSizer *arg2 = (wxSizer *) 0 ;
56223 wxGBSizerItem *result = 0 ;
56224 void *argp1 = 0 ;
56225 int res1 = 0 ;
56226 void *argp2 = 0 ;
56227 int res2 = 0 ;
56228
56229 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56231 if (!SWIG_IsOK(res1)) {
56232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56233 }
56234 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56235 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56236 if (!SWIG_IsOK(res2)) {
56237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
56238 }
56239 arg2 = reinterpret_cast< wxSizer * >(argp2);
56240 {
56241 PyThreadState* __tstate = wxPyBeginAllowThreads();
56242 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56243 wxPyEndAllowThreads(__tstate);
56244 if (PyErr_Occurred()) SWIG_fail;
56245 }
56246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56247 return resultobj;
56248 fail:
56249 return NULL;
56250 }
56251
56252
56253 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
56254 int argc;
56255 PyObject *argv[3];
56256
56257 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
56258 --argc;
56259 if (argc == 2) {
56260 int _v = 0;
56261 {
56262 void *vptr = 0;
56263 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56264 _v = SWIG_CheckState(res);
56265 }
56266 if (!_v) goto check_1;
56267 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
56268 }
56269 check_1:
56270
56271 if (argc == 2) {
56272 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
56273 }
56274
56275 fail:
56276 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
56277 return NULL;
56278 }
56279
56280
56281 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56282 PyObject *resultobj = 0;
56283 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56284 wxGBPosition *arg2 = 0 ;
56285 wxGBSizerItem *result = 0 ;
56286 void *argp1 = 0 ;
56287 int res1 = 0 ;
56288 wxGBPosition temp2 ;
56289 PyObject * obj0 = 0 ;
56290 PyObject * obj1 = 0 ;
56291 char * kwnames[] = {
56292 (char *) "self",(char *) "pos", NULL
56293 };
56294
56295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
56296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56297 if (!SWIG_IsOK(res1)) {
56298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56299 }
56300 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56301 {
56302 arg2 = &temp2;
56303 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56304 }
56305 {
56306 PyThreadState* __tstate = wxPyBeginAllowThreads();
56307 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
56308 wxPyEndAllowThreads(__tstate);
56309 if (PyErr_Occurred()) SWIG_fail;
56310 }
56311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56312 return resultobj;
56313 fail:
56314 return NULL;
56315 }
56316
56317
56318 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56319 PyObject *resultobj = 0;
56320 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56321 wxPoint *arg2 = 0 ;
56322 wxGBSizerItem *result = 0 ;
56323 void *argp1 = 0 ;
56324 int res1 = 0 ;
56325 wxPoint temp2 ;
56326 PyObject * obj0 = 0 ;
56327 PyObject * obj1 = 0 ;
56328 char * kwnames[] = {
56329 (char *) "self",(char *) "pt", NULL
56330 };
56331
56332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
56333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56334 if (!SWIG_IsOK(res1)) {
56335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56336 }
56337 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56338 {
56339 arg2 = &temp2;
56340 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
56341 }
56342 {
56343 PyThreadState* __tstate = wxPyBeginAllowThreads();
56344 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
56345 wxPyEndAllowThreads(__tstate);
56346 if (PyErr_Occurred()) SWIG_fail;
56347 }
56348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56349 return resultobj;
56350 fail:
56351 return NULL;
56352 }
56353
56354
56355 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56356 PyObject *resultobj = 0;
56357 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56358 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
56359 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
56360 bool result;
56361 void *argp1 = 0 ;
56362 int res1 = 0 ;
56363 void *argp2 = 0 ;
56364 int res2 = 0 ;
56365 void *argp3 = 0 ;
56366 int res3 = 0 ;
56367 PyObject * obj0 = 0 ;
56368 PyObject * obj1 = 0 ;
56369 PyObject * obj2 = 0 ;
56370 char * kwnames[] = {
56371 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
56372 };
56373
56374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56376 if (!SWIG_IsOK(res1)) {
56377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56378 }
56379 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56380 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56381 if (!SWIG_IsOK(res2)) {
56382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
56383 }
56384 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
56385 if (obj2) {
56386 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56387 if (!SWIG_IsOK(res3)) {
56388 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
56389 }
56390 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
56391 }
56392 {
56393 PyThreadState* __tstate = wxPyBeginAllowThreads();
56394 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
56395 wxPyEndAllowThreads(__tstate);
56396 if (PyErr_Occurred()) SWIG_fail;
56397 }
56398 {
56399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56400 }
56401 return resultobj;
56402 fail:
56403 return NULL;
56404 }
56405
56406
56407 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56408 PyObject *resultobj = 0;
56409 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56410 wxGBPosition *arg2 = 0 ;
56411 wxGBSpan *arg3 = 0 ;
56412 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
56413 bool result;
56414 void *argp1 = 0 ;
56415 int res1 = 0 ;
56416 wxGBPosition temp2 ;
56417 wxGBSpan temp3 ;
56418 void *argp4 = 0 ;
56419 int res4 = 0 ;
56420 PyObject * obj0 = 0 ;
56421 PyObject * obj1 = 0 ;
56422 PyObject * obj2 = 0 ;
56423 PyObject * obj3 = 0 ;
56424 char * kwnames[] = {
56425 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
56426 };
56427
56428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56430 if (!SWIG_IsOK(res1)) {
56431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56432 }
56433 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56434 {
56435 arg2 = &temp2;
56436 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56437 }
56438 {
56439 arg3 = &temp3;
56440 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
56441 }
56442 if (obj3) {
56443 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56444 if (!SWIG_IsOK(res4)) {
56445 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
56446 }
56447 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
56448 }
56449 {
56450 PyThreadState* __tstate = wxPyBeginAllowThreads();
56451 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
56452 wxPyEndAllowThreads(__tstate);
56453 if (PyErr_Occurred()) SWIG_fail;
56454 }
56455 {
56456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56457 }
56458 return resultobj;
56459 fail:
56460 return NULL;
56461 }
56462
56463
56464 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56465 PyObject *obj;
56466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56467 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
56468 return SWIG_Py_Void();
56469 }
56470
56471 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56472 return SWIG_Python_InitShadowInstance(args);
56473 }
56474
56475 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56476 PyObject *resultobj = 0;
56477 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56478 wxRelationship arg2 ;
56479 wxWindow *arg3 = (wxWindow *) 0 ;
56480 wxEdge arg4 ;
56481 int arg5 = (int) 0 ;
56482 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
56483 void *argp1 = 0 ;
56484 int res1 = 0 ;
56485 int val2 ;
56486 int ecode2 = 0 ;
56487 void *argp3 = 0 ;
56488 int res3 = 0 ;
56489 int val4 ;
56490 int ecode4 = 0 ;
56491 int val5 ;
56492 int ecode5 = 0 ;
56493 int val6 ;
56494 int ecode6 = 0 ;
56495 PyObject * obj0 = 0 ;
56496 PyObject * obj1 = 0 ;
56497 PyObject * obj2 = 0 ;
56498 PyObject * obj3 = 0 ;
56499 PyObject * obj4 = 0 ;
56500 PyObject * obj5 = 0 ;
56501 char * kwnames[] = {
56502 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
56503 };
56504
56505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
56506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56507 if (!SWIG_IsOK(res1)) {
56508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56509 }
56510 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56511 ecode2 = SWIG_AsVal_int(obj1, &val2);
56512 if (!SWIG_IsOK(ecode2)) {
56513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
56514 }
56515 arg2 = static_cast< wxRelationship >(val2);
56516 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56517 if (!SWIG_IsOK(res3)) {
56518 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
56519 }
56520 arg3 = reinterpret_cast< wxWindow * >(argp3);
56521 ecode4 = SWIG_AsVal_int(obj3, &val4);
56522 if (!SWIG_IsOK(ecode4)) {
56523 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
56524 }
56525 arg4 = static_cast< wxEdge >(val4);
56526 if (obj4) {
56527 ecode5 = SWIG_AsVal_int(obj4, &val5);
56528 if (!SWIG_IsOK(ecode5)) {
56529 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
56530 }
56531 arg5 = static_cast< int >(val5);
56532 }
56533 if (obj5) {
56534 ecode6 = SWIG_AsVal_int(obj5, &val6);
56535 if (!SWIG_IsOK(ecode6)) {
56536 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
56537 }
56538 arg6 = static_cast< int >(val6);
56539 }
56540 {
56541 PyThreadState* __tstate = wxPyBeginAllowThreads();
56542 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
56543 wxPyEndAllowThreads(__tstate);
56544 if (PyErr_Occurred()) SWIG_fail;
56545 }
56546 resultobj = SWIG_Py_Void();
56547 return resultobj;
56548 fail:
56549 return NULL;
56550 }
56551
56552
56553 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56554 PyObject *resultobj = 0;
56555 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56556 wxWindow *arg2 = (wxWindow *) 0 ;
56557 int arg3 = (int) 0 ;
56558 void *argp1 = 0 ;
56559 int res1 = 0 ;
56560 void *argp2 = 0 ;
56561 int res2 = 0 ;
56562 int val3 ;
56563 int ecode3 = 0 ;
56564 PyObject * obj0 = 0 ;
56565 PyObject * obj1 = 0 ;
56566 PyObject * obj2 = 0 ;
56567 char * kwnames[] = {
56568 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56569 };
56570
56571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56573 if (!SWIG_IsOK(res1)) {
56574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56575 }
56576 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56577 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56578 if (!SWIG_IsOK(res2)) {
56579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
56580 }
56581 arg2 = reinterpret_cast< wxWindow * >(argp2);
56582 if (obj2) {
56583 ecode3 = SWIG_AsVal_int(obj2, &val3);
56584 if (!SWIG_IsOK(ecode3)) {
56585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
56586 }
56587 arg3 = static_cast< int >(val3);
56588 }
56589 {
56590 PyThreadState* __tstate = wxPyBeginAllowThreads();
56591 (arg1)->LeftOf(arg2,arg3);
56592 wxPyEndAllowThreads(__tstate);
56593 if (PyErr_Occurred()) SWIG_fail;
56594 }
56595 resultobj = SWIG_Py_Void();
56596 return resultobj;
56597 fail:
56598 return NULL;
56599 }
56600
56601
56602 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56603 PyObject *resultobj = 0;
56604 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56605 wxWindow *arg2 = (wxWindow *) 0 ;
56606 int arg3 = (int) 0 ;
56607 void *argp1 = 0 ;
56608 int res1 = 0 ;
56609 void *argp2 = 0 ;
56610 int res2 = 0 ;
56611 int val3 ;
56612 int ecode3 = 0 ;
56613 PyObject * obj0 = 0 ;
56614 PyObject * obj1 = 0 ;
56615 PyObject * obj2 = 0 ;
56616 char * kwnames[] = {
56617 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56618 };
56619
56620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56622 if (!SWIG_IsOK(res1)) {
56623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56624 }
56625 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56626 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56627 if (!SWIG_IsOK(res2)) {
56628 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
56629 }
56630 arg2 = reinterpret_cast< wxWindow * >(argp2);
56631 if (obj2) {
56632 ecode3 = SWIG_AsVal_int(obj2, &val3);
56633 if (!SWIG_IsOK(ecode3)) {
56634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
56635 }
56636 arg3 = static_cast< int >(val3);
56637 }
56638 {
56639 PyThreadState* __tstate = wxPyBeginAllowThreads();
56640 (arg1)->RightOf(arg2,arg3);
56641 wxPyEndAllowThreads(__tstate);
56642 if (PyErr_Occurred()) SWIG_fail;
56643 }
56644 resultobj = SWIG_Py_Void();
56645 return resultobj;
56646 fail:
56647 return NULL;
56648 }
56649
56650
56651 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56652 PyObject *resultobj = 0;
56653 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56654 wxWindow *arg2 = (wxWindow *) 0 ;
56655 int arg3 = (int) 0 ;
56656 void *argp1 = 0 ;
56657 int res1 = 0 ;
56658 void *argp2 = 0 ;
56659 int res2 = 0 ;
56660 int val3 ;
56661 int ecode3 = 0 ;
56662 PyObject * obj0 = 0 ;
56663 PyObject * obj1 = 0 ;
56664 PyObject * obj2 = 0 ;
56665 char * kwnames[] = {
56666 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56667 };
56668
56669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56671 if (!SWIG_IsOK(res1)) {
56672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56673 }
56674 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56675 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56676 if (!SWIG_IsOK(res2)) {
56677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
56678 }
56679 arg2 = reinterpret_cast< wxWindow * >(argp2);
56680 if (obj2) {
56681 ecode3 = SWIG_AsVal_int(obj2, &val3);
56682 if (!SWIG_IsOK(ecode3)) {
56683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
56684 }
56685 arg3 = static_cast< int >(val3);
56686 }
56687 {
56688 PyThreadState* __tstate = wxPyBeginAllowThreads();
56689 (arg1)->Above(arg2,arg3);
56690 wxPyEndAllowThreads(__tstate);
56691 if (PyErr_Occurred()) SWIG_fail;
56692 }
56693 resultobj = SWIG_Py_Void();
56694 return resultobj;
56695 fail:
56696 return NULL;
56697 }
56698
56699
56700 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56701 PyObject *resultobj = 0;
56702 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56703 wxWindow *arg2 = (wxWindow *) 0 ;
56704 int arg3 = (int) 0 ;
56705 void *argp1 = 0 ;
56706 int res1 = 0 ;
56707 void *argp2 = 0 ;
56708 int res2 = 0 ;
56709 int val3 ;
56710 int ecode3 = 0 ;
56711 PyObject * obj0 = 0 ;
56712 PyObject * obj1 = 0 ;
56713 PyObject * obj2 = 0 ;
56714 char * kwnames[] = {
56715 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56716 };
56717
56718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56720 if (!SWIG_IsOK(res1)) {
56721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56722 }
56723 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56724 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56725 if (!SWIG_IsOK(res2)) {
56726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
56727 }
56728 arg2 = reinterpret_cast< wxWindow * >(argp2);
56729 if (obj2) {
56730 ecode3 = SWIG_AsVal_int(obj2, &val3);
56731 if (!SWIG_IsOK(ecode3)) {
56732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
56733 }
56734 arg3 = static_cast< int >(val3);
56735 }
56736 {
56737 PyThreadState* __tstate = wxPyBeginAllowThreads();
56738 (arg1)->Below(arg2,arg3);
56739 wxPyEndAllowThreads(__tstate);
56740 if (PyErr_Occurred()) SWIG_fail;
56741 }
56742 resultobj = SWIG_Py_Void();
56743 return resultobj;
56744 fail:
56745 return NULL;
56746 }
56747
56748
56749 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56750 PyObject *resultobj = 0;
56751 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56752 wxWindow *arg2 = (wxWindow *) 0 ;
56753 wxEdge arg3 ;
56754 int arg4 = (int) 0 ;
56755 void *argp1 = 0 ;
56756 int res1 = 0 ;
56757 void *argp2 = 0 ;
56758 int res2 = 0 ;
56759 int val3 ;
56760 int ecode3 = 0 ;
56761 int val4 ;
56762 int ecode4 = 0 ;
56763 PyObject * obj0 = 0 ;
56764 PyObject * obj1 = 0 ;
56765 PyObject * obj2 = 0 ;
56766 PyObject * obj3 = 0 ;
56767 char * kwnames[] = {
56768 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
56769 };
56770
56771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56773 if (!SWIG_IsOK(res1)) {
56774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56775 }
56776 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56777 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56778 if (!SWIG_IsOK(res2)) {
56779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
56780 }
56781 arg2 = reinterpret_cast< wxWindow * >(argp2);
56782 ecode3 = SWIG_AsVal_int(obj2, &val3);
56783 if (!SWIG_IsOK(ecode3)) {
56784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
56785 }
56786 arg3 = static_cast< wxEdge >(val3);
56787 if (obj3) {
56788 ecode4 = SWIG_AsVal_int(obj3, &val4);
56789 if (!SWIG_IsOK(ecode4)) {
56790 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
56791 }
56792 arg4 = static_cast< int >(val4);
56793 }
56794 {
56795 PyThreadState* __tstate = wxPyBeginAllowThreads();
56796 (arg1)->SameAs(arg2,arg3,arg4);
56797 wxPyEndAllowThreads(__tstate);
56798 if (PyErr_Occurred()) SWIG_fail;
56799 }
56800 resultobj = SWIG_Py_Void();
56801 return resultobj;
56802 fail:
56803 return NULL;
56804 }
56805
56806
56807 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56808 PyObject *resultobj = 0;
56809 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56810 wxWindow *arg2 = (wxWindow *) 0 ;
56811 wxEdge arg3 ;
56812 int arg4 ;
56813 void *argp1 = 0 ;
56814 int res1 = 0 ;
56815 void *argp2 = 0 ;
56816 int res2 = 0 ;
56817 int val3 ;
56818 int ecode3 = 0 ;
56819 int val4 ;
56820 int ecode4 = 0 ;
56821 PyObject * obj0 = 0 ;
56822 PyObject * obj1 = 0 ;
56823 PyObject * obj2 = 0 ;
56824 PyObject * obj3 = 0 ;
56825 char * kwnames[] = {
56826 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
56827 };
56828
56829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56831 if (!SWIG_IsOK(res1)) {
56832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56833 }
56834 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56835 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56836 if (!SWIG_IsOK(res2)) {
56837 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
56838 }
56839 arg2 = reinterpret_cast< wxWindow * >(argp2);
56840 ecode3 = SWIG_AsVal_int(obj2, &val3);
56841 if (!SWIG_IsOK(ecode3)) {
56842 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
56843 }
56844 arg3 = static_cast< wxEdge >(val3);
56845 ecode4 = SWIG_AsVal_int(obj3, &val4);
56846 if (!SWIG_IsOK(ecode4)) {
56847 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
56848 }
56849 arg4 = static_cast< int >(val4);
56850 {
56851 PyThreadState* __tstate = wxPyBeginAllowThreads();
56852 (arg1)->PercentOf(arg2,arg3,arg4);
56853 wxPyEndAllowThreads(__tstate);
56854 if (PyErr_Occurred()) SWIG_fail;
56855 }
56856 resultobj = SWIG_Py_Void();
56857 return resultobj;
56858 fail:
56859 return NULL;
56860 }
56861
56862
56863 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56864 PyObject *resultobj = 0;
56865 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56866 int arg2 ;
56867 void *argp1 = 0 ;
56868 int res1 = 0 ;
56869 int val2 ;
56870 int ecode2 = 0 ;
56871 PyObject * obj0 = 0 ;
56872 PyObject * obj1 = 0 ;
56873 char * kwnames[] = {
56874 (char *) "self",(char *) "val", NULL
56875 };
56876
56877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
56878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56879 if (!SWIG_IsOK(res1)) {
56880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56881 }
56882 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56883 ecode2 = SWIG_AsVal_int(obj1, &val2);
56884 if (!SWIG_IsOK(ecode2)) {
56885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
56886 }
56887 arg2 = static_cast< int >(val2);
56888 {
56889 PyThreadState* __tstate = wxPyBeginAllowThreads();
56890 (arg1)->Absolute(arg2);
56891 wxPyEndAllowThreads(__tstate);
56892 if (PyErr_Occurred()) SWIG_fail;
56893 }
56894 resultobj = SWIG_Py_Void();
56895 return resultobj;
56896 fail:
56897 return NULL;
56898 }
56899
56900
56901 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56902 PyObject *resultobj = 0;
56903 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56904 void *argp1 = 0 ;
56905 int res1 = 0 ;
56906 PyObject *swig_obj[1] ;
56907
56908 if (!args) SWIG_fail;
56909 swig_obj[0] = args;
56910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56911 if (!SWIG_IsOK(res1)) {
56912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56913 }
56914 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56915 {
56916 PyThreadState* __tstate = wxPyBeginAllowThreads();
56917 (arg1)->Unconstrained();
56918 wxPyEndAllowThreads(__tstate);
56919 if (PyErr_Occurred()) SWIG_fail;
56920 }
56921 resultobj = SWIG_Py_Void();
56922 return resultobj;
56923 fail:
56924 return NULL;
56925 }
56926
56927
56928 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56929 PyObject *resultobj = 0;
56930 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56931 void *argp1 = 0 ;
56932 int res1 = 0 ;
56933 PyObject *swig_obj[1] ;
56934
56935 if (!args) SWIG_fail;
56936 swig_obj[0] = args;
56937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56938 if (!SWIG_IsOK(res1)) {
56939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56940 }
56941 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56942 {
56943 PyThreadState* __tstate = wxPyBeginAllowThreads();
56944 (arg1)->AsIs();
56945 wxPyEndAllowThreads(__tstate);
56946 if (PyErr_Occurred()) SWIG_fail;
56947 }
56948 resultobj = SWIG_Py_Void();
56949 return resultobj;
56950 fail:
56951 return NULL;
56952 }
56953
56954
56955 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56956 PyObject *resultobj = 0;
56957 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56958 wxWindow *result = 0 ;
56959 void *argp1 = 0 ;
56960 int res1 = 0 ;
56961 PyObject *swig_obj[1] ;
56962
56963 if (!args) SWIG_fail;
56964 swig_obj[0] = args;
56965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56966 if (!SWIG_IsOK(res1)) {
56967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56968 }
56969 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56970 {
56971 PyThreadState* __tstate = wxPyBeginAllowThreads();
56972 result = (wxWindow *)(arg1)->GetOtherWindow();
56973 wxPyEndAllowThreads(__tstate);
56974 if (PyErr_Occurred()) SWIG_fail;
56975 }
56976 {
56977 resultobj = wxPyMake_wxObject(result, 0);
56978 }
56979 return resultobj;
56980 fail:
56981 return NULL;
56982 }
56983
56984
56985 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56986 PyObject *resultobj = 0;
56987 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56988 wxEdge result;
56989 void *argp1 = 0 ;
56990 int res1 = 0 ;
56991 PyObject *swig_obj[1] ;
56992
56993 if (!args) SWIG_fail;
56994 swig_obj[0] = args;
56995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56996 if (!SWIG_IsOK(res1)) {
56997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56998 }
56999 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57000 {
57001 PyThreadState* __tstate = wxPyBeginAllowThreads();
57002 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
57003 wxPyEndAllowThreads(__tstate);
57004 if (PyErr_Occurred()) SWIG_fail;
57005 }
57006 resultobj = SWIG_From_int(static_cast< int >(result));
57007 return resultobj;
57008 fail:
57009 return NULL;
57010 }
57011
57012
57013 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57014 PyObject *resultobj = 0;
57015 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57016 wxEdge arg2 ;
57017 void *argp1 = 0 ;
57018 int res1 = 0 ;
57019 int val2 ;
57020 int ecode2 = 0 ;
57021 PyObject * obj0 = 0 ;
57022 PyObject * obj1 = 0 ;
57023 char * kwnames[] = {
57024 (char *) "self",(char *) "which", NULL
57025 };
57026
57027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
57028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57029 if (!SWIG_IsOK(res1)) {
57030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57031 }
57032 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57033 ecode2 = SWIG_AsVal_int(obj1, &val2);
57034 if (!SWIG_IsOK(ecode2)) {
57035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
57036 }
57037 arg2 = static_cast< wxEdge >(val2);
57038 {
57039 PyThreadState* __tstate = wxPyBeginAllowThreads();
57040 (arg1)->SetEdge(arg2);
57041 wxPyEndAllowThreads(__tstate);
57042 if (PyErr_Occurred()) SWIG_fail;
57043 }
57044 resultobj = SWIG_Py_Void();
57045 return resultobj;
57046 fail:
57047 return NULL;
57048 }
57049
57050
57051 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57052 PyObject *resultobj = 0;
57053 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57054 int arg2 ;
57055 void *argp1 = 0 ;
57056 int res1 = 0 ;
57057 int val2 ;
57058 int ecode2 = 0 ;
57059 PyObject * obj0 = 0 ;
57060 PyObject * obj1 = 0 ;
57061 char * kwnames[] = {
57062 (char *) "self",(char *) "v", NULL
57063 };
57064
57065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
57066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57067 if (!SWIG_IsOK(res1)) {
57068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57069 }
57070 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57071 ecode2 = SWIG_AsVal_int(obj1, &val2);
57072 if (!SWIG_IsOK(ecode2)) {
57073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
57074 }
57075 arg2 = static_cast< int >(val2);
57076 {
57077 PyThreadState* __tstate = wxPyBeginAllowThreads();
57078 (arg1)->SetValue(arg2);
57079 wxPyEndAllowThreads(__tstate);
57080 if (PyErr_Occurred()) SWIG_fail;
57081 }
57082 resultobj = SWIG_Py_Void();
57083 return resultobj;
57084 fail:
57085 return NULL;
57086 }
57087
57088
57089 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57090 PyObject *resultobj = 0;
57091 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57092 int result;
57093 void *argp1 = 0 ;
57094 int res1 = 0 ;
57095 PyObject *swig_obj[1] ;
57096
57097 if (!args) SWIG_fail;
57098 swig_obj[0] = args;
57099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57100 if (!SWIG_IsOK(res1)) {
57101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57102 }
57103 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57104 {
57105 PyThreadState* __tstate = wxPyBeginAllowThreads();
57106 result = (int)(arg1)->GetMargin();
57107 wxPyEndAllowThreads(__tstate);
57108 if (PyErr_Occurred()) SWIG_fail;
57109 }
57110 resultobj = SWIG_From_int(static_cast< int >(result));
57111 return resultobj;
57112 fail:
57113 return NULL;
57114 }
57115
57116
57117 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57118 PyObject *resultobj = 0;
57119 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57120 int arg2 ;
57121 void *argp1 = 0 ;
57122 int res1 = 0 ;
57123 int val2 ;
57124 int ecode2 = 0 ;
57125 PyObject * obj0 = 0 ;
57126 PyObject * obj1 = 0 ;
57127 char * kwnames[] = {
57128 (char *) "self",(char *) "m", NULL
57129 };
57130
57131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
57132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57133 if (!SWIG_IsOK(res1)) {
57134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57135 }
57136 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57137 ecode2 = SWIG_AsVal_int(obj1, &val2);
57138 if (!SWIG_IsOK(ecode2)) {
57139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
57140 }
57141 arg2 = static_cast< int >(val2);
57142 {
57143 PyThreadState* __tstate = wxPyBeginAllowThreads();
57144 (arg1)->SetMargin(arg2);
57145 wxPyEndAllowThreads(__tstate);
57146 if (PyErr_Occurred()) SWIG_fail;
57147 }
57148 resultobj = SWIG_Py_Void();
57149 return resultobj;
57150 fail:
57151 return NULL;
57152 }
57153
57154
57155 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57156 PyObject *resultobj = 0;
57157 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57158 int result;
57159 void *argp1 = 0 ;
57160 int res1 = 0 ;
57161 PyObject *swig_obj[1] ;
57162
57163 if (!args) SWIG_fail;
57164 swig_obj[0] = args;
57165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57166 if (!SWIG_IsOK(res1)) {
57167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57168 }
57169 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57170 {
57171 PyThreadState* __tstate = wxPyBeginAllowThreads();
57172 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
57173 wxPyEndAllowThreads(__tstate);
57174 if (PyErr_Occurred()) SWIG_fail;
57175 }
57176 resultobj = SWIG_From_int(static_cast< int >(result));
57177 return resultobj;
57178 fail:
57179 return NULL;
57180 }
57181
57182
57183 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57184 PyObject *resultobj = 0;
57185 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57186 int result;
57187 void *argp1 = 0 ;
57188 int res1 = 0 ;
57189 PyObject *swig_obj[1] ;
57190
57191 if (!args) SWIG_fail;
57192 swig_obj[0] = args;
57193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57194 if (!SWIG_IsOK(res1)) {
57195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57196 }
57197 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57198 {
57199 PyThreadState* __tstate = wxPyBeginAllowThreads();
57200 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
57201 wxPyEndAllowThreads(__tstate);
57202 if (PyErr_Occurred()) SWIG_fail;
57203 }
57204 resultobj = SWIG_From_int(static_cast< int >(result));
57205 return resultobj;
57206 fail:
57207 return NULL;
57208 }
57209
57210
57211 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57212 PyObject *resultobj = 0;
57213 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57214 int result;
57215 void *argp1 = 0 ;
57216 int res1 = 0 ;
57217 PyObject *swig_obj[1] ;
57218
57219 if (!args) SWIG_fail;
57220 swig_obj[0] = args;
57221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57222 if (!SWIG_IsOK(res1)) {
57223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57224 }
57225 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57226 {
57227 PyThreadState* __tstate = wxPyBeginAllowThreads();
57228 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
57229 wxPyEndAllowThreads(__tstate);
57230 if (PyErr_Occurred()) SWIG_fail;
57231 }
57232 resultobj = SWIG_From_int(static_cast< int >(result));
57233 return resultobj;
57234 fail:
57235 return NULL;
57236 }
57237
57238
57239 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57240 PyObject *resultobj = 0;
57241 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57242 bool result;
57243 void *argp1 = 0 ;
57244 int res1 = 0 ;
57245 PyObject *swig_obj[1] ;
57246
57247 if (!args) SWIG_fail;
57248 swig_obj[0] = args;
57249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57250 if (!SWIG_IsOK(res1)) {
57251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57252 }
57253 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57254 {
57255 PyThreadState* __tstate = wxPyBeginAllowThreads();
57256 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
57257 wxPyEndAllowThreads(__tstate);
57258 if (PyErr_Occurred()) SWIG_fail;
57259 }
57260 {
57261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57262 }
57263 return resultobj;
57264 fail:
57265 return NULL;
57266 }
57267
57268
57269 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57270 PyObject *resultobj = 0;
57271 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57272 bool arg2 ;
57273 void *argp1 = 0 ;
57274 int res1 = 0 ;
57275 bool val2 ;
57276 int ecode2 = 0 ;
57277 PyObject * obj0 = 0 ;
57278 PyObject * obj1 = 0 ;
57279 char * kwnames[] = {
57280 (char *) "self",(char *) "d", NULL
57281 };
57282
57283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
57284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57285 if (!SWIG_IsOK(res1)) {
57286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57287 }
57288 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57289 ecode2 = SWIG_AsVal_bool(obj1, &val2);
57290 if (!SWIG_IsOK(ecode2)) {
57291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
57292 }
57293 arg2 = static_cast< bool >(val2);
57294 {
57295 PyThreadState* __tstate = wxPyBeginAllowThreads();
57296 (arg1)->SetDone(arg2);
57297 wxPyEndAllowThreads(__tstate);
57298 if (PyErr_Occurred()) SWIG_fail;
57299 }
57300 resultobj = SWIG_Py_Void();
57301 return resultobj;
57302 fail:
57303 return NULL;
57304 }
57305
57306
57307 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57308 PyObject *resultobj = 0;
57309 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57310 wxRelationship result;
57311 void *argp1 = 0 ;
57312 int res1 = 0 ;
57313 PyObject *swig_obj[1] ;
57314
57315 if (!args) SWIG_fail;
57316 swig_obj[0] = args;
57317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57318 if (!SWIG_IsOK(res1)) {
57319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57320 }
57321 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57322 {
57323 PyThreadState* __tstate = wxPyBeginAllowThreads();
57324 result = (wxRelationship)(arg1)->GetRelationship();
57325 wxPyEndAllowThreads(__tstate);
57326 if (PyErr_Occurred()) SWIG_fail;
57327 }
57328 resultobj = SWIG_From_int(static_cast< int >(result));
57329 return resultobj;
57330 fail:
57331 return NULL;
57332 }
57333
57334
57335 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57336 PyObject *resultobj = 0;
57337 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57338 wxRelationship arg2 ;
57339 void *argp1 = 0 ;
57340 int res1 = 0 ;
57341 int val2 ;
57342 int ecode2 = 0 ;
57343 PyObject * obj0 = 0 ;
57344 PyObject * obj1 = 0 ;
57345 char * kwnames[] = {
57346 (char *) "self",(char *) "r", NULL
57347 };
57348
57349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
57350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57351 if (!SWIG_IsOK(res1)) {
57352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57353 }
57354 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57355 ecode2 = SWIG_AsVal_int(obj1, &val2);
57356 if (!SWIG_IsOK(ecode2)) {
57357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
57358 }
57359 arg2 = static_cast< wxRelationship >(val2);
57360 {
57361 PyThreadState* __tstate = wxPyBeginAllowThreads();
57362 (arg1)->SetRelationship(arg2);
57363 wxPyEndAllowThreads(__tstate);
57364 if (PyErr_Occurred()) SWIG_fail;
57365 }
57366 resultobj = SWIG_Py_Void();
57367 return resultobj;
57368 fail:
57369 return NULL;
57370 }
57371
57372
57373 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57374 PyObject *resultobj = 0;
57375 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57376 wxWindow *arg2 = (wxWindow *) 0 ;
57377 bool result;
57378 void *argp1 = 0 ;
57379 int res1 = 0 ;
57380 void *argp2 = 0 ;
57381 int res2 = 0 ;
57382 PyObject * obj0 = 0 ;
57383 PyObject * obj1 = 0 ;
57384 char * kwnames[] = {
57385 (char *) "self",(char *) "otherW", NULL
57386 };
57387
57388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
57389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57390 if (!SWIG_IsOK(res1)) {
57391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57392 }
57393 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57394 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57395 if (!SWIG_IsOK(res2)) {
57396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
57397 }
57398 arg2 = reinterpret_cast< wxWindow * >(argp2);
57399 {
57400 PyThreadState* __tstate = wxPyBeginAllowThreads();
57401 result = (bool)(arg1)->ResetIfWin(arg2);
57402 wxPyEndAllowThreads(__tstate);
57403 if (PyErr_Occurred()) SWIG_fail;
57404 }
57405 {
57406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57407 }
57408 return resultobj;
57409 fail:
57410 return NULL;
57411 }
57412
57413
57414 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57415 PyObject *resultobj = 0;
57416 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57417 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
57418 wxWindow *arg3 = (wxWindow *) 0 ;
57419 bool result;
57420 void *argp1 = 0 ;
57421 int res1 = 0 ;
57422 void *argp2 = 0 ;
57423 int res2 = 0 ;
57424 void *argp3 = 0 ;
57425 int res3 = 0 ;
57426 PyObject * obj0 = 0 ;
57427 PyObject * obj1 = 0 ;
57428 PyObject * obj2 = 0 ;
57429 char * kwnames[] = {
57430 (char *) "self",(char *) "constraints",(char *) "win", NULL
57431 };
57432
57433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57435 if (!SWIG_IsOK(res1)) {
57436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57437 }
57438 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57439 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57440 if (!SWIG_IsOK(res2)) {
57441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
57442 }
57443 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
57444 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57445 if (!SWIG_IsOK(res3)) {
57446 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
57447 }
57448 arg3 = reinterpret_cast< wxWindow * >(argp3);
57449 {
57450 PyThreadState* __tstate = wxPyBeginAllowThreads();
57451 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
57452 wxPyEndAllowThreads(__tstate);
57453 if (PyErr_Occurred()) SWIG_fail;
57454 }
57455 {
57456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57457 }
57458 return resultobj;
57459 fail:
57460 return NULL;
57461 }
57462
57463
57464 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57465 PyObject *resultobj = 0;
57466 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57467 wxEdge arg2 ;
57468 wxWindow *arg3 = (wxWindow *) 0 ;
57469 wxWindow *arg4 = (wxWindow *) 0 ;
57470 int result;
57471 void *argp1 = 0 ;
57472 int res1 = 0 ;
57473 int val2 ;
57474 int ecode2 = 0 ;
57475 void *argp3 = 0 ;
57476 int res3 = 0 ;
57477 void *argp4 = 0 ;
57478 int res4 = 0 ;
57479 PyObject * obj0 = 0 ;
57480 PyObject * obj1 = 0 ;
57481 PyObject * obj2 = 0 ;
57482 PyObject * obj3 = 0 ;
57483 char * kwnames[] = {
57484 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
57485 };
57486
57487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57489 if (!SWIG_IsOK(res1)) {
57490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57491 }
57492 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57493 ecode2 = SWIG_AsVal_int(obj1, &val2);
57494 if (!SWIG_IsOK(ecode2)) {
57495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
57496 }
57497 arg2 = static_cast< wxEdge >(val2);
57498 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57499 if (!SWIG_IsOK(res3)) {
57500 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
57501 }
57502 arg3 = reinterpret_cast< wxWindow * >(argp3);
57503 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
57504 if (!SWIG_IsOK(res4)) {
57505 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
57506 }
57507 arg4 = reinterpret_cast< wxWindow * >(argp4);
57508 {
57509 PyThreadState* __tstate = wxPyBeginAllowThreads();
57510 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
57511 wxPyEndAllowThreads(__tstate);
57512 if (PyErr_Occurred()) SWIG_fail;
57513 }
57514 resultobj = SWIG_From_int(static_cast< int >(result));
57515 return resultobj;
57516 fail:
57517 return NULL;
57518 }
57519
57520
57521 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57522 PyObject *obj;
57523 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
57524 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
57525 return SWIG_Py_Void();
57526 }
57527
57528 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57529 PyObject *resultobj = 0;
57530 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57531 wxIndividualLayoutConstraint *result = 0 ;
57532 void *argp1 = 0 ;
57533 int res1 = 0 ;
57534 PyObject *swig_obj[1] ;
57535
57536 if (!args) SWIG_fail;
57537 swig_obj[0] = args;
57538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57539 if (!SWIG_IsOK(res1)) {
57540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57541 }
57542 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57543 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
57544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57545 return resultobj;
57546 fail:
57547 return NULL;
57548 }
57549
57550
57551 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57552 PyObject *resultobj = 0;
57553 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57554 wxIndividualLayoutConstraint *result = 0 ;
57555 void *argp1 = 0 ;
57556 int res1 = 0 ;
57557 PyObject *swig_obj[1] ;
57558
57559 if (!args) SWIG_fail;
57560 swig_obj[0] = args;
57561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57562 if (!SWIG_IsOK(res1)) {
57563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57564 }
57565 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57566 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
57567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57568 return resultobj;
57569 fail:
57570 return NULL;
57571 }
57572
57573
57574 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57575 PyObject *resultobj = 0;
57576 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57577 wxIndividualLayoutConstraint *result = 0 ;
57578 void *argp1 = 0 ;
57579 int res1 = 0 ;
57580 PyObject *swig_obj[1] ;
57581
57582 if (!args) SWIG_fail;
57583 swig_obj[0] = args;
57584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57585 if (!SWIG_IsOK(res1)) {
57586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57587 }
57588 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57589 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
57590 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57591 return resultobj;
57592 fail:
57593 return NULL;
57594 }
57595
57596
57597 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57598 PyObject *resultobj = 0;
57599 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57600 wxIndividualLayoutConstraint *result = 0 ;
57601 void *argp1 = 0 ;
57602 int res1 = 0 ;
57603 PyObject *swig_obj[1] ;
57604
57605 if (!args) SWIG_fail;
57606 swig_obj[0] = args;
57607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57608 if (!SWIG_IsOK(res1)) {
57609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57610 }
57611 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57612 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
57613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57614 return resultobj;
57615 fail:
57616 return NULL;
57617 }
57618
57619
57620 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57621 PyObject *resultobj = 0;
57622 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57623 wxIndividualLayoutConstraint *result = 0 ;
57624 void *argp1 = 0 ;
57625 int res1 = 0 ;
57626 PyObject *swig_obj[1] ;
57627
57628 if (!args) SWIG_fail;
57629 swig_obj[0] = args;
57630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57631 if (!SWIG_IsOK(res1)) {
57632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57633 }
57634 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57635 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
57636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57637 return resultobj;
57638 fail:
57639 return NULL;
57640 }
57641
57642
57643 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57644 PyObject *resultobj = 0;
57645 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57646 wxIndividualLayoutConstraint *result = 0 ;
57647 void *argp1 = 0 ;
57648 int res1 = 0 ;
57649 PyObject *swig_obj[1] ;
57650
57651 if (!args) SWIG_fail;
57652 swig_obj[0] = args;
57653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57654 if (!SWIG_IsOK(res1)) {
57655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57656 }
57657 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57658 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
57659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57660 return resultobj;
57661 fail:
57662 return NULL;
57663 }
57664
57665
57666 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57667 PyObject *resultobj = 0;
57668 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57669 wxIndividualLayoutConstraint *result = 0 ;
57670 void *argp1 = 0 ;
57671 int res1 = 0 ;
57672 PyObject *swig_obj[1] ;
57673
57674 if (!args) SWIG_fail;
57675 swig_obj[0] = args;
57676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57677 if (!SWIG_IsOK(res1)) {
57678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57679 }
57680 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57681 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
57682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57683 return resultobj;
57684 fail:
57685 return NULL;
57686 }
57687
57688
57689 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57690 PyObject *resultobj = 0;
57691 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57692 wxIndividualLayoutConstraint *result = 0 ;
57693 void *argp1 = 0 ;
57694 int res1 = 0 ;
57695 PyObject *swig_obj[1] ;
57696
57697 if (!args) SWIG_fail;
57698 swig_obj[0] = args;
57699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57700 if (!SWIG_IsOK(res1)) {
57701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57702 }
57703 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57704 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
57705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57706 return resultobj;
57707 fail:
57708 return NULL;
57709 }
57710
57711
57712 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57713 PyObject *resultobj = 0;
57714 wxLayoutConstraints *result = 0 ;
57715
57716 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
57717 {
57718 PyThreadState* __tstate = wxPyBeginAllowThreads();
57719 result = (wxLayoutConstraints *)new wxLayoutConstraints();
57720 wxPyEndAllowThreads(__tstate);
57721 if (PyErr_Occurred()) SWIG_fail;
57722 }
57723 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
57724 return resultobj;
57725 fail:
57726 return NULL;
57727 }
57728
57729
57730 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57731 PyObject *resultobj = 0;
57732 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57733 void *argp1 = 0 ;
57734 int res1 = 0 ;
57735 PyObject *swig_obj[1] ;
57736
57737 if (!args) SWIG_fail;
57738 swig_obj[0] = args;
57739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
57740 if (!SWIG_IsOK(res1)) {
57741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57742 }
57743 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57744 {
57745 PyThreadState* __tstate = wxPyBeginAllowThreads();
57746 delete arg1;
57747
57748 wxPyEndAllowThreads(__tstate);
57749 if (PyErr_Occurred()) SWIG_fail;
57750 }
57751 resultobj = SWIG_Py_Void();
57752 return resultobj;
57753 fail:
57754 return NULL;
57755 }
57756
57757
57758 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57759 PyObject *resultobj = 0;
57760 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57761 wxWindow *arg2 = (wxWindow *) 0 ;
57762 int *arg3 = (int *) 0 ;
57763 bool result;
57764 void *argp1 = 0 ;
57765 int res1 = 0 ;
57766 void *argp2 = 0 ;
57767 int res2 = 0 ;
57768 int temp3 ;
57769 int res3 = SWIG_TMPOBJ ;
57770 PyObject * obj0 = 0 ;
57771 PyObject * obj1 = 0 ;
57772 char * kwnames[] = {
57773 (char *) "self",(char *) "win", NULL
57774 };
57775
57776 arg3 = &temp3;
57777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
57778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57779 if (!SWIG_IsOK(res1)) {
57780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57781 }
57782 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57783 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57784 if (!SWIG_IsOK(res2)) {
57785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
57786 }
57787 arg2 = reinterpret_cast< wxWindow * >(argp2);
57788 {
57789 PyThreadState* __tstate = wxPyBeginAllowThreads();
57790 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
57791 wxPyEndAllowThreads(__tstate);
57792 if (PyErr_Occurred()) SWIG_fail;
57793 }
57794 {
57795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57796 }
57797 if (SWIG_IsTmpObj(res3)) {
57798 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
57799 } else {
57800 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
57801 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
57802 }
57803 return resultobj;
57804 fail:
57805 return NULL;
57806 }
57807
57808
57809 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57810 PyObject *resultobj = 0;
57811 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57812 bool result;
57813 void *argp1 = 0 ;
57814 int res1 = 0 ;
57815 PyObject *swig_obj[1] ;
57816
57817 if (!args) SWIG_fail;
57818 swig_obj[0] = args;
57819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57820 if (!SWIG_IsOK(res1)) {
57821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
57822 }
57823 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57824 {
57825 PyThreadState* __tstate = wxPyBeginAllowThreads();
57826 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
57827 wxPyEndAllowThreads(__tstate);
57828 if (PyErr_Occurred()) SWIG_fail;
57829 }
57830 {
57831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57832 }
57833 return resultobj;
57834 fail:
57835 return NULL;
57836 }
57837
57838
57839 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57840 PyObject *obj;
57841 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
57842 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
57843 return SWIG_Py_Void();
57844 }
57845
57846 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57847 return SWIG_Python_InitShadowInstance(args);
57848 }
57849
57850 static PyMethodDef SwigMethods[] = {
57851 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
57852 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
57853 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
57854 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57855 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
57856 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
57857 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
57858 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
57859 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
57860 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
57861 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
57862 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57863 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57864 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57865 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
57866 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
57867 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
57868 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
57869 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
57870 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
57871 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57872 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57873 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
57874 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
57875 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
57876 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
57877 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
57878 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
57879 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
57880 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
57881 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
57882 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
57883 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
57884 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
57885 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57886 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
57887 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57888 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57889 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57890 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
57891 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57892 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
57893 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
57894 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
57895 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
57896 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
57897 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
57898 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
57899 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
57900 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
57901 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57902 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57903 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57904 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
57905 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
57906 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
57907 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57908 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
57909 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
57910 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
57911 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
57912 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
57913 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
57914 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
57915 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
57916 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
57917 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
57918 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
57919 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
57920 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
57921 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57922 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
57923 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
57924 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
57925 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57926 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
57927 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57928 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
57929 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
57930 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57931 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
57932 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
57933 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
57934 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
57935 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
57936 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57937 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
57938 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
57939 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
57940 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
57941 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57942 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
57943 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
57944 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
57945 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
57946 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
57947 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
57948 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
57949 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
57950 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
57951 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57952 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
57953 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57954 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57955 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
57956 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
57957 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
57958 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57959 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
57960 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
57961 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
57962 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
57963 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
57964 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
57965 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
57966 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
57967 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
57968 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57969 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
57970 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
57971 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
57972 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
57973 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
57974 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
57975 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57976 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
57977 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
57978 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
57979 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
57980 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
57981 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
57982 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
57983 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
57984 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
57985 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
57986 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
57987 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
57988 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
57989 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
57990 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
57991 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
57992 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57993 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57994 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
57995 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
57996 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
57997 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
57998 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57999 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
58000 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
58001 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
58002 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
58003 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
58004 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
58005 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
58006 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
58007 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58008 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
58009 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
58010 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
58011 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58012 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
58013 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58014 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58015 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
58016 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
58017 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
58018 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
58019 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
58020 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58021 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
58022 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58023 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58024 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
58025 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
58026 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58027 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
58028 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58029 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58030 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
58031 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
58032 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
58033 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
58034 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
58035 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
58036 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
58037 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
58038 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
58039 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
58040 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
58041 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
58042 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
58043 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
58044 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
58045 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
58046 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
58047 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
58048 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58049 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58050 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
58051 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
58052 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
58053 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
58054 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
58055 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
58056 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
58057 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
58058 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58059 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
58060 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
58061 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
58062 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
58063 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
58064 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
58065 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
58066 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
58067 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
58068 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
58069 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
58070 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
58071 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
58072 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
58073 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
58074 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
58075 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
58076 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
58077 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
58078 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
58079 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
58080 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
58081 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
58082 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
58083 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
58084 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
58085 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
58086 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
58087 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
58088 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
58089 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
58090 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
58091 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
58092 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
58093 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
58094 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
58095 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
58096 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
58097 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
58098 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58099 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58100 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58101 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58102 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
58103 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
58104 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
58105 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
58106 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
58107 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
58108 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
58109 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
58110 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
58111 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
58112 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
58113 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
58114 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58115 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58116 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
58117 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58118 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58119 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
58120 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
58121 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
58122 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
58123 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
58124 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
58125 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58126 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58127 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
58128 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
58129 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
58130 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58131 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58132 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58133 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
58134 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
58135 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
58136 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
58137 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58138 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
58139 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
58140 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58141 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58142 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58143 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58144 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
58145 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
58146 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
58147 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
58148 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
58149 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
58150 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
58151 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58152 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58153 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
58154 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
58155 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
58156 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
58157 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
58158 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
58159 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58160 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
58161 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
58162 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
58163 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58164 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58165 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
58166 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58167 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
58168 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
58169 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
58170 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
58171 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
58172 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
58173 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
58174 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
58175 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
58176 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
58177 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
58178 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
58179 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
58180 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
58181 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
58182 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
58183 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
58184 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
58185 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
58186 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
58187 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
58188 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
58189 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
58190 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
58191 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
58192 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
58193 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
58194 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58195 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
58196 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58197 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58198 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
58199 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
58200 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
58201 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
58202 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
58203 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
58204 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
58205 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
58206 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
58207 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
58208 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58209 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
58210 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
58211 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
58212 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
58213 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58214 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58215 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
58216 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
58217 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
58218 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58219 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
58220 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58221 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
58222 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58223 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
58224 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
58225 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58226 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58227 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58228 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58229 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58230 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
58231 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
58232 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
58233 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
58234 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
58235 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
58236 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
58237 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
58238 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
58239 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
58240 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
58241 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
58242 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58243 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
58244 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
58245 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
58246 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58247 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
58248 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
58249 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
58250 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
58251 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
58252 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
58253 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
58254 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
58255 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
58256 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
58257 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
58258 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
58259 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
58260 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58261 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58262 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58263 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58264 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
58265 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
58266 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
58267 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58268 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58269 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58270 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
58271 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
58272 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58273 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58274 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
58275 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
58276 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58277 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
58278 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
58279 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58280 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
58281 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
58282 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
58283 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
58284 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
58285 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
58286 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
58287 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
58288 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
58289 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
58290 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
58291 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
58292 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
58293 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
58294 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
58295 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
58296 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
58297 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
58298 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
58299 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
58300 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
58301 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
58302 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
58303 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
58304 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
58305 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
58306 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
58307 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
58308 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
58309 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
58310 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
58311 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
58312 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
58313 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
58314 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
58315 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
58316 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
58317 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
58318 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
58319 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
58320 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
58321 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58322 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58323 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
58324 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58325 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58326 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58327 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
58328 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
58329 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
58330 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58331 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
58332 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
58333 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
58334 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
58335 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
58336 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
58337 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
58338 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
58339 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
58340 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
58341 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
58342 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58343 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
58344 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
58345 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
58346 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
58347 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
58348 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
58349 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
58350 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
58351 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
58352 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
58353 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
58354 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
58355 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
58356 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
58357 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
58358 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
58359 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58360 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
58361 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
58362 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
58363 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
58364 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
58365 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
58366 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
58367 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
58368 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
58369 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
58370 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
58371 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
58372 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
58373 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
58374 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58375 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
58376 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
58377 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
58378 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
58379 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
58380 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58381 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
58382 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
58383 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58384 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58385 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
58386 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
58387 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58388 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
58389 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
58390 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58391 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58392 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
58393 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
58394 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58395 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
58396 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
58397 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
58398 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
58399 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
58400 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
58401 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
58402 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
58403 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
58404 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
58405 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
58406 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
58407 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
58408 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
58409 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
58410 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
58411 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
58412 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
58413 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
58414 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
58415 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
58416 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
58417 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
58418 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
58419 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
58420 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
58421 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
58422 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
58423 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
58424 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
58425 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58426 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
58427 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
58428 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
58429 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
58430 { (char *)"MouseEvent_GetWheelAxis", (PyCFunction)_wrap_MouseEvent_GetWheelAxis, METH_O, NULL},
58431 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
58432 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
58433 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
58434 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
58435 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
58436 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
58437 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
58438 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
58439 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
58440 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
58441 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
58442 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
58443 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
58444 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
58445 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
58446 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
58447 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
58448 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
58449 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
58450 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
58451 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
58452 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
58453 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
58454 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
58455 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
58456 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
58457 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
58458 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
58459 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58460 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
58461 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
58462 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
58463 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
58464 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
58465 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
58466 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
58467 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58468 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
58469 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
58470 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
58471 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
58472 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
58473 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
58474 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
58475 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
58476 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
58477 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58478 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
58479 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
58480 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
58481 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
58482 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
58483 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
58484 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
58485 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
58486 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
58487 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
58488 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
58489 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
58490 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
58491 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
58492 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
58493 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
58494 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
58495 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
58496 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
58497 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
58498 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
58499 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
58500 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
58501 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
58502 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
58503 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
58504 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
58505 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
58506 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58507 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
58508 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
58509 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
58510 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
58511 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
58512 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
58513 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
58514 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
58515 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
58516 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
58517 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58518 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
58519 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
58520 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
58521 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58522 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
58523 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
58524 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58525 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
58526 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
58527 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58528 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
58529 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
58530 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58531 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
58532 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
58533 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
58534 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58535 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
58536 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58537 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
58538 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
58539 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58540 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
58541 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
58542 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
58543 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58544 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
58545 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
58546 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
58547 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58548 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
58549 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
58550 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58551 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
58552 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
58553 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
58554 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
58555 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
58556 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58557 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
58558 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
58559 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
58560 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
58561 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
58562 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
58563 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
58564 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
58565 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58566 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
58567 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
58568 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
58569 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
58570 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58571 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
58572 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
58573 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
58574 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58575 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
58576 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
58577 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
58578 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
58579 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
58580 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
58581 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58582 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
58583 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
58584 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
58585 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
58586 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
58587 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
58588 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
58589 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
58590 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
58591 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58592 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
58593 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
58594 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
58595 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
58596 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
58597 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
58598 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
58599 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
58600 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
58601 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
58602 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
58603 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
58604 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
58605 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58606 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
58607 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
58608 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
58609 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58610 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
58611 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
58612 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
58613 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
58614 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
58615 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58616 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58617 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
58618 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
58619 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
58620 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58621 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
58622 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
58623 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
58624 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
58625 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
58626 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
58627 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58628 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
58629 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
58630 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
58631 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
58632 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
58633 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
58634 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
58635 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
58636 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
58637 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58638 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
58639 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
58640 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
58641 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58642 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
58643 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
58644 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
58645 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58646 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
58647 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58648 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
58649 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
58650 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
58651 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
58652 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
58653 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
58654 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
58655 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
58656 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
58657 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
58658 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58659 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
58660 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
58661 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58662 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
58663 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58664 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
58665 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
58666 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
58667 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58668 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
58669 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58670 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
58671 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
58672 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
58673 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58674 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
58675 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
58676 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
58677 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
58678 { (char *)"new_EventBlocker", (PyCFunction) _wrap_new_EventBlocker, METH_VARARGS | METH_KEYWORDS, NULL},
58679 { (char *)"delete_EventBlocker", (PyCFunction)_wrap_delete_EventBlocker, METH_O, NULL},
58680 { (char *)"EventBlocker_Block", (PyCFunction) _wrap_EventBlocker_Block, METH_VARARGS | METH_KEYWORDS, NULL},
58681 { (char *)"EventBlocker_swigregister", EventBlocker_swigregister, METH_VARARGS, NULL},
58682 { (char *)"EventBlocker_swiginit", EventBlocker_swiginit, METH_VARARGS, NULL},
58683 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
58684 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
58685 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58686 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
58687 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
58688 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
58689 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
58690 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
58691 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
58692 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
58693 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
58694 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
58695 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
58696 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
58697 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
58698 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
58699 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
58700 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
58701 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
58702 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
58703 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
58704 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
58705 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
58706 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58707 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
58708 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
58709 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
58710 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
58711 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
58712 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
58713 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
58714 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
58715 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
58716 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
58717 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
58718 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
58719 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
58720 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
58721 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
58722 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
58723 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
58724 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
58725 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
58726 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
58727 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
58728 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
58729 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
58730 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
58731 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
58732 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
58733 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
58734 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
58735 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
58736 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58737 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
58738 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
58739 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
58740 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
58741 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
58742 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
58743 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
58744 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
58745 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
58746 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
58747 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
58748 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
58749 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
58750 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
58751 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
58752 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
58753 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
58754 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
58755 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
58756 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
58757 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
58758 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58759 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58760 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
58761 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
58762 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
58763 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
58764 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
58765 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
58766 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
58767 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
58768 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
58769 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
58770 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
58771 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
58772 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
58773 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
58774 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
58775 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
58776 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
58777 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
58778 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
58779 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
58780 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
58781 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
58782 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
58783 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
58784 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
58785 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58786 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
58787 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
58788 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
58789 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
58790 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58791 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
58792 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
58793 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
58794 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
58795 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
58796 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58797 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
58798 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
58799 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
58800 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
58801 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
58802 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58803 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58804 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
58805 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
58806 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
58807 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
58808 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
58809 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
58810 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
58811 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
58812 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
58813 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
58814 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
58815 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
58816 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
58817 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
58818 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
58819 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
58820 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
58821 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
58822 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
58823 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
58824 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
58825 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
58826 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
58827 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
58828 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
58829 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
58830 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
58831 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
58832 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
58833 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
58834 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
58835 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
58836 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
58837 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
58838 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
58839 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
58840 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
58841 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
58842 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
58843 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
58844 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
58845 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
58846 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
58847 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
58848 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
58849 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
58850 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
58851 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
58852 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
58853 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
58854 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
58855 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
58856 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
58857 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58858 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
58859 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
58860 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
58861 { (char *)"Window_IsThisEnabled", (PyCFunction)_wrap_Window_IsThisEnabled, METH_O, NULL},
58862 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
58863 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
58864 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
58865 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
58866 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
58867 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
58868 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
58869 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
58870 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
58871 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58872 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
58873 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
58874 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
58875 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
58876 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
58877 { (char *)"Window_CanAcceptFocus", (PyCFunction)_wrap_Window_CanAcceptFocus, METH_O, NULL},
58878 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
58879 { (char *)"Window_CanAcceptFocusFromKeyboard", (PyCFunction)_wrap_Window_CanAcceptFocusFromKeyboard, METH_O, NULL},
58880 { (char *)"Window_NavigateIn", (PyCFunction) _wrap_Window_NavigateIn, METH_VARARGS | METH_KEYWORDS, NULL},
58881 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
58882 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
58883 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
58884 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
58885 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
58886 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
58887 { (char *)"Window_GetTopLevelParent", (PyCFunction)_wrap_Window_GetTopLevelParent, METH_O, NULL},
58888 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
58889 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
58890 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
58891 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
58892 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
58893 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
58894 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
58895 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
58896 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58897 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58898 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58899 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58900 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
58901 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
58902 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
58903 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
58904 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
58905 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
58906 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
58907 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
58908 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
58909 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
58910 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
58911 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
58912 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
58913 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
58914 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
58915 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
58916 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
58917 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
58918 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
58919 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
58920 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
58921 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
58922 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
58923 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
58924 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
58925 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
58926 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
58927 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
58928 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
58929 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
58930 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
58931 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
58932 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
58933 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58934 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
58935 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
58936 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
58937 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58938 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58939 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58940 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58941 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
58942 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
58943 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
58944 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
58945 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
58946 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
58947 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
58948 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
58949 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
58950 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
58951 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
58952 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
58953 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
58954 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
58955 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
58956 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
58957 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
58958 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
58959 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
58960 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
58961 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
58962 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
58963 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
58964 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
58965 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
58966 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
58967 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
58968 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58969 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
58970 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
58971 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
58972 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
58973 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
58974 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
58975 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
58976 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
58977 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
58978 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
58979 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58980 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
58981 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
58982 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
58983 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
58984 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
58985 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
58986 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
58987 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
58988 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58989 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
58990 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
58991 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
58992 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
58993 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
58994 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
58995 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
58996 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
58997 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
58998 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
58999 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
59000 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
59001 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59002 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
59003 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
59004 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59005 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
59006 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
59007 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
59008 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
59009 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
59010 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
59011 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
59012 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
59013 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
59014 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59015 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
59016 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
59017 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
59018 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
59019 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
59020 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
59021 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
59022 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
59023 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59024 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
59025 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
59026 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
59027 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
59028 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
59029 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59030 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
59031 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
59032 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
59033 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59034 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
59035 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59036 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59037 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59038 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59039 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
59040 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59041 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59042 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
59043 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59044 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
59045 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59046 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59047 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59048 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59049 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
59050 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59051 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59052 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59053 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59054 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
59055 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59056 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
59057 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
59058 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
59059 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
59060 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
59061 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
59062 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
59063 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
59064 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59065 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59066 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59067 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59068 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
59069 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59070 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59071 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59072 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59073 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
59074 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
59075 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59076 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
59077 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59078 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
59079 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
59080 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
59081 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
59082 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
59083 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
59084 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
59085 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
59086 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
59087 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
59088 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
59089 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
59090 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59091 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59092 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
59093 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59094 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
59095 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59096 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
59097 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
59098 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
59099 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
59100 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
59101 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
59102 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59103 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59104 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59105 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
59106 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59107 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59108 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59109 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59110 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59111 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
59112 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
59113 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
59114 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
59115 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
59116 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59117 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
59118 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
59119 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
59120 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
59121 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
59122 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
59123 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59124 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
59125 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
59126 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
59127 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
59128 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
59129 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
59130 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
59131 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
59132 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
59133 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
59134 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
59135 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
59136 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59137 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
59138 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59139 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
59140 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59141 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
59142 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
59143 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
59144 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
59145 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
59146 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
59147 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59148 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
59149 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
59150 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
59151 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
59152 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
59153 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59154 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
59155 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
59156 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59157 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
59158 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
59159 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
59160 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
59161 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
59162 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
59163 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
59164 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
59165 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
59166 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
59167 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
59168 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59169 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
59170 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
59171 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
59172 { (char *)"Control_RemoveMnemonics", (PyCFunction) _wrap_Control_RemoveMnemonics, METH_VARARGS | METH_KEYWORDS, NULL},
59173 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
59174 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
59175 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
59176 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59177 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
59178 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59179 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
59180 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59181 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59182 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59183 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
59184 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
59185 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
59186 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
59187 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
59188 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
59189 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59190 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
59191 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59192 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
59193 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
59194 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
59195 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
59196 { (char *)"new_SizerFlags", (PyCFunction) _wrap_new_SizerFlags, METH_VARARGS | METH_KEYWORDS, NULL},
59197 { (char *)"delete_SizerFlags", (PyCFunction)_wrap_delete_SizerFlags, METH_O, NULL},
59198 { (char *)"SizerFlags_Proportion", (PyCFunction) _wrap_SizerFlags_Proportion, METH_VARARGS | METH_KEYWORDS, NULL},
59199 { (char *)"SizerFlags_Align", (PyCFunction) _wrap_SizerFlags_Align, METH_VARARGS | METH_KEYWORDS, NULL},
59200 { (char *)"SizerFlags_Expand", (PyCFunction)_wrap_SizerFlags_Expand, METH_O, NULL},
59201 { (char *)"SizerFlags_Centre", (PyCFunction)_wrap_SizerFlags_Centre, METH_O, NULL},
59202 { (char *)"SizerFlags_Center", (PyCFunction)_wrap_SizerFlags_Center, METH_O, NULL},
59203 { (char *)"SizerFlags_Left", (PyCFunction)_wrap_SizerFlags_Left, METH_O, NULL},
59204 { (char *)"SizerFlags_Right", (PyCFunction)_wrap_SizerFlags_Right, METH_O, NULL},
59205 { (char *)"SizerFlags_Top", (PyCFunction)_wrap_SizerFlags_Top, METH_O, NULL},
59206 { (char *)"SizerFlags_Bottom", (PyCFunction)_wrap_SizerFlags_Bottom, METH_O, NULL},
59207 { (char *)"SizerFlags_Shaped", (PyCFunction)_wrap_SizerFlags_Shaped, METH_O, NULL},
59208 { (char *)"SizerFlags_FixedMinSize", (PyCFunction)_wrap_SizerFlags_FixedMinSize, METH_O, NULL},
59209 { (char *)"SizerFlags_Border", (PyCFunction) _wrap_SizerFlags_Border, METH_VARARGS | METH_KEYWORDS, NULL},
59210 { (char *)"SizerFlags_DoubleBorder", (PyCFunction) _wrap_SizerFlags_DoubleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59211 { (char *)"SizerFlags_TripleBorder", (PyCFunction) _wrap_SizerFlags_TripleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59212 { (char *)"SizerFlags_HorzBorder", (PyCFunction)_wrap_SizerFlags_HorzBorder, METH_O, NULL},
59213 { (char *)"SizerFlags_DoubleHorzBorder", (PyCFunction)_wrap_SizerFlags_DoubleHorzBorder, METH_O, NULL},
59214 { (char *)"SizerFlags_GetDefaultBorder", (PyCFunction)_wrap_SizerFlags_GetDefaultBorder, METH_NOARGS, NULL},
59215 { (char *)"SizerFlags_GetProportion", (PyCFunction)_wrap_SizerFlags_GetProportion, METH_O, NULL},
59216 { (char *)"SizerFlags_GetFlags", (PyCFunction)_wrap_SizerFlags_GetFlags, METH_O, NULL},
59217 { (char *)"SizerFlags_GetBorderInPixels", (PyCFunction)_wrap_SizerFlags_GetBorderInPixels, METH_O, NULL},
59218 { (char *)"SizerFlags_swigregister", SizerFlags_swigregister, METH_VARARGS, NULL},
59219 { (char *)"SizerFlags_swiginit", SizerFlags_swiginit, METH_VARARGS, NULL},
59220 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
59221 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
59222 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59223 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59224 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59225 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
59226 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
59227 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
59228 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
59229 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59230 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
59231 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
59232 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
59233 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
59234 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
59235 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
59236 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
59237 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
59238 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
59239 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
59240 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
59241 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
59242 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
59243 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59244 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
59245 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59246 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
59247 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
59248 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
59249 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
59250 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59251 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59252 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59253 { (char *)"SizerItem_AssignWindow", (PyCFunction) _wrap_SizerItem_AssignWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59254 { (char *)"SizerItem_AssignSizer", (PyCFunction) _wrap_SizerItem_AssignSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59255 { (char *)"SizerItem_AssignSpacer", (PyCFunction) _wrap_SizerItem_AssignSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59256 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59257 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
59258 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
59259 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
59260 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
59261 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
59262 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
59263 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
59264 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59265 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59266 { (char *)"Sizer_AddF", (PyCFunction) _wrap_Sizer_AddF, METH_VARARGS | METH_KEYWORDS, NULL},
59267 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59268 { (char *)"Sizer_InsertF", (PyCFunction) _wrap_Sizer_InsertF, METH_VARARGS | METH_KEYWORDS, NULL},
59269 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59270 { (char *)"Sizer_PrependF", (PyCFunction) _wrap_Sizer_PrependF, METH_VARARGS | METH_KEYWORDS, NULL},
59271 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59272 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
59273 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
59274 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59275 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
59276 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59277 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
59278 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59279 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
59280 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59281 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59282 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59283 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59284 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59285 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
59286 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
59287 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
59288 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
59289 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
59290 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
59291 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
59292 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
59293 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59294 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59295 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
59296 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
59297 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
59298 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59299 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
59300 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
59301 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
59302 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
59303 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59304 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
59305 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
59306 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59307 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
59308 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
59309 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
59310 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
59311 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59312 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
59313 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
59314 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
59315 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59316 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
59317 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
59318 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
59319 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
59320 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
59321 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
59322 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
59323 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
59324 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
59325 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
59326 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59327 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59328 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59329 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59330 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59331 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59332 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
59333 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
59334 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
59335 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
59336 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
59337 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
59338 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
59339 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
59340 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
59341 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
59342 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59343 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59344 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
59345 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
59346 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
59347 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
59348 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
59349 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
59350 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
59351 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
59352 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59353 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
59354 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
59355 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
59356 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
59357 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
59358 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59359 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59360 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59361 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
59362 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
59363 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
59364 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59365 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
59366 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
59367 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
59368 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
59369 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
59370 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59371 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59372 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59373 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
59374 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
59375 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
59376 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
59377 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
59378 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59379 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59380 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59381 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
59382 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
59383 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
59384 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59385 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
59386 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
59387 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
59388 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
59389 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59390 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
59391 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
59392 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59393 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59394 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59395 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59396 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
59397 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59398 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
59399 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
59400 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
59401 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
59402 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
59403 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59404 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59405 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
59406 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
59407 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
59408 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
59409 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59410 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
59411 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
59412 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
59413 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
59414 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
59415 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
59416 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
59417 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
59418 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
59419 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
59420 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
59421 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
59422 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
59423 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
59424 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
59425 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
59426 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
59427 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
59428 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
59429 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
59430 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
59431 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
59432 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
59433 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
59434 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
59435 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
59436 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
59437 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
59438 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
59439 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
59440 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
59441 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
59442 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
59443 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
59444 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
59445 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
59446 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
59447 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
59448 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
59449 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
59450 { NULL, NULL, 0, NULL }
59451 };
59452
59453
59454 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
59455
59456 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
59457 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
59458 }
59459 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
59460 return (void *)((wxEvent *) ((wxMenuEvent *) x));
59461 }
59462 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
59463 return (void *)((wxEvent *) ((wxCloseEvent *) x));
59464 }
59465 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
59466 return (void *)((wxEvent *) ((wxMouseEvent *) x));
59467 }
59468 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
59469 return (void *)((wxEvent *) ((wxEraseEvent *) x));
59470 }
59471 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
59472 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
59473 }
59474 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
59475 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
59476 }
59477 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
59478 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
59479 }
59480 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
59481 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
59482 }
59483 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
59484 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
59485 }
59486 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
59487 return (void *)((wxEvent *) ((wxPyEvent *) x));
59488 }
59489 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
59490 return (void *)((wxEvent *) ((wxIdleEvent *) x));
59491 }
59492 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
59493 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
59494 }
59495 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
59496 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
59497 }
59498 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
59499 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
59500 }
59501 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
59502 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
59503 }
59504 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
59505 return (void *)((wxEvent *) ((wxActivateEvent *) x));
59506 }
59507 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
59508 return (void *)((wxEvent *) ((wxSizeEvent *) x));
59509 }
59510 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
59511 return (void *)((wxEvent *) ((wxMoveEvent *) x));
59512 }
59513 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
59514 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
59515 }
59516 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
59517 return (void *)((wxEvent *) ((wxPaintEvent *) x));
59518 }
59519 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
59520 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
59521 }
59522 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
59523 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
59524 }
59525 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
59526 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
59527 }
59528 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
59529 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
59530 }
59531 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
59532 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
59533 }
59534 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
59535 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
59536 }
59537 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
59538 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
59539 }
59540 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
59541 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
59542 }
59543 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
59544 return (void *)((wxEvent *) ((wxFocusEvent *) x));
59545 }
59546 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
59547 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
59548 }
59549 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
59550 return (void *)((wxEvent *) ((wxShowEvent *) x));
59551 }
59552 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
59553 return (void *)((wxEvent *) ((wxCommandEvent *) x));
59554 }
59555 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
59556 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
59557 }
59558 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
59559 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
59560 }
59561 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
59562 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
59563 }
59564 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
59565 return (void *)((wxEvent *) ((wxKeyEvent *) x));
59566 }
59567 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
59568 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
59569 }
59570 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
59571 return (void *)((wxValidator *) ((wxPyValidator *) x));
59572 }
59573 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
59574 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
59575 }
59576 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
59577 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
59578 }
59579 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
59580 return (void *)((wxObject *) ((wxSizerItem *) x));
59581 }
59582 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
59583 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
59584 }
59585 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
59586 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
59587 }
59588 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
59589 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
59590 }
59591 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
59592 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
59593 }
59594 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
59595 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
59596 }
59597 static void *_p_wxSizerTo_p_wxObject(void *x) {
59598 return (void *)((wxObject *) ((wxSizer *) x));
59599 }
59600 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
59601 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
59602 }
59603 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
59604 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
59605 }
59606 static void *_p_wxEventTo_p_wxObject(void *x) {
59607 return (void *)((wxObject *) ((wxEvent *) x));
59608 }
59609 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
59610 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
59611 }
59612 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
59613 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
59614 }
59615 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
59616 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
59617 }
59618 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
59619 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
59620 }
59621 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
59622 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
59623 }
59624 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
59625 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
59626 }
59627 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
59628 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
59629 }
59630 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
59631 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
59632 }
59633 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
59634 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
59635 }
59636 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
59637 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
59638 }
59639 static void *_p_wxControlTo_p_wxObject(void *x) {
59640 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
59641 }
59642 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
59643 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
59644 }
59645 static void *_p_wxFSFileTo_p_wxObject(void *x) {
59646 return (void *)((wxObject *) ((wxFSFile *) x));
59647 }
59648 static void *_p_wxPySizerTo_p_wxObject(void *x) {
59649 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
59650 }
59651 static void *_p_wxPyEventTo_p_wxObject(void *x) {
59652 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
59653 }
59654 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
59655 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
59656 }
59657 static void *_p_wxShowEventTo_p_wxObject(void *x) {
59658 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
59659 }
59660 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
59661 return (void *)((wxObject *) ((wxMenuItem *) x));
59662 }
59663 static void *_p_wxDateEventTo_p_wxObject(void *x) {
59664 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
59665 }
59666 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
59667 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
59668 }
59669 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
59670 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
59671 }
59672 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
59673 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
59674 }
59675 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
59676 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
59677 }
59678 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
59679 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
59680 }
59681 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
59682 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
59683 }
59684 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
59685 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
59686 }
59687 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
59688 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
59689 }
59690 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
59691 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
59692 }
59693 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
59694 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
59695 }
59696 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
59697 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
59698 }
59699 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
59700 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
59701 }
59702 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
59703 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
59704 }
59705 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
59706 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
59707 }
59708 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
59709 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
59710 }
59711 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
59712 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
59713 }
59714 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
59715 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
59716 }
59717 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
59718 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
59719 }
59720 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
59721 return (void *)((wxObject *) ((wxImageHandler *) x));
59722 }
59723 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
59724 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
59725 }
59726 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
59727 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
59728 }
59729 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
59730 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
59731 }
59732 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
59733 return (void *)((wxObject *) ((wxEvtHandler *) x));
59734 }
59735 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
59736 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
59737 }
59738 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
59739 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
59740 }
59741 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
59742 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
59743 }
59744 static void *_p_wxImageTo_p_wxObject(void *x) {
59745 return (void *)((wxObject *) ((wxImage *) x));
59746 }
59747 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
59748 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
59749 }
59750 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
59751 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
59752 }
59753 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
59754 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
59755 }
59756 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
59757 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
59758 }
59759 static void *_p_wxWindowTo_p_wxObject(void *x) {
59760 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
59761 }
59762 static void *_p_wxMenuTo_p_wxObject(void *x) {
59763 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
59764 }
59765 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
59766 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
59767 }
59768 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
59769 return (void *)((wxObject *) ((wxFileSystem *) x));
59770 }
59771 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
59772 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
59773 }
59774 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
59775 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
59776 }
59777 static void *_p_wxPyAppTo_p_wxObject(void *x) {
59778 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
59779 }
59780 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
59781 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
59782 }
59783 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
59784 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
59785 }
59786 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
59787 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
59788 }
59789 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
59790 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
59791 }
59792 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
59793 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
59794 }
59795 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
59796 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
59797 }
59798 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
59799 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
59800 }
59801 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
59802 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
59803 }
59804 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
59805 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
59806 }
59807 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
59808 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
59809 }
59810 static void *_p_wxValidatorTo_p_wxObject(void *x) {
59811 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
59812 }
59813 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
59814 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
59815 }
59816 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
59817 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
59818 }
59819 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
59820 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
59821 }
59822 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
59823 return (void *)((wxControl *) ((wxControlWithItems *) x));
59824 }
59825 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
59826 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
59827 }
59828 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
59829 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
59830 }
59831 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
59832 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
59833 }
59834 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
59835 return (void *)((wxSizer *) ((wxBoxSizer *) x));
59836 }
59837 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
59838 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
59839 }
59840 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
59841 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
59842 }
59843 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
59844 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
59845 }
59846 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
59847 return (void *)((wxSizer *) ((wxGridSizer *) x));
59848 }
59849 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
59850 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
59851 }
59852 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
59853 return (void *)((wxSizer *) ((wxPySizer *) x));
59854 }
59855 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
59856 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
59857 }
59858 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
59859 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
59860 }
59861 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
59862 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
59863 }
59864 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
59865 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
59866 }
59867 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
59868 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
59869 }
59870 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
59871 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
59872 }
59873 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
59874 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
59875 }
59876 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
59877 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
59878 }
59879 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
59880 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
59881 }
59882 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
59883 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
59884 }
59885 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
59886 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
59887 }
59888 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
59889 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
59890 }
59891 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
59892 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
59893 }
59894 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
59895 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
59896 }
59897 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
59898 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
59899 }
59900 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
59901 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
59902 }
59903 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
59904 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
59905 }
59906 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
59907 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
59908 }
59909 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
59910 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
59911 }
59912 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
59913 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
59914 }
59915 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
59916 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
59917 }
59918 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
59919 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
59920 }
59921 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
59922 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
59923 }
59924 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
59925 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
59926 }
59927 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
59928 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
59929 }
59930 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
59931 return (void *)((wxEvtHandler *) ((wxWindow *) x));
59932 }
59933 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
59934 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
59935 }
59936 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
59937 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
59938 }
59939 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
59940 return (void *)((wxEvtHandler *) ((wxValidator *) x));
59941 }
59942 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
59943 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
59944 }
59945 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
59946 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
59947 }
59948 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
59949 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
59950 }
59951 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
59952 return (void *)((wxEvtHandler *) ((wxMenu *) x));
59953 }
59954 static void *_p_wxControlTo_p_wxWindow(void *x) {
59955 return (void *)((wxWindow *) ((wxControl *) x));
59956 }
59957 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
59958 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
59959 }
59960 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
59961 return (void *)((wxWindow *) ((wxMenuBar *) x));
59962 }
59963 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
59964 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
59965 }
59966 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
59967 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
59968 }
59969 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
59970 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
59971 }
59972 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
59973 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
59974 }
59975 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
59976 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
59977 }
59978 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
59979 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
59980 }
59981 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
59982 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
59983 }
59984 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
59985 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
59986 }
59987 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
59988 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
59989 }
59990 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
59991 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
59992 }
59993 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
59994 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
59995 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};
59996 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
59997 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
59998 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
59999 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
60000 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
60001 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
60002 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
60003 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
60004 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
60005 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
60006 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
60007 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
60008 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
60009 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
60010 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
60011 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
60012 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
60013 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
60014 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
60015 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
60016 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
60017 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
60018 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
60019 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
60020 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
60021 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
60022 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
60023 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
60024 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
60025 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
60026 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
60027 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
60028 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
60029 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
60030 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
60031 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", "wxEventBlocker *", 0, 0, (void*)0, 0};
60032 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
60033 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
60034 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
60035 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
60036 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
60037 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
60038 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
60039 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
60040 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
60041 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
60042 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
60043 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
60044 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
60045 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
60046 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
60047 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
60048 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
60049 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
60050 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
60051 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
60052 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
60053 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
60054 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
60055 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
60056 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
60057 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
60058 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
60059 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
60060 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
60061 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
60062 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
60063 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
60064 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
60065 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
60066 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
60067 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
60068 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
60069 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
60070 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
60071 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
60072 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
60073 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
60074 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
60075 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
60076 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
60077 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
60078 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
60079 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
60080 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
60081 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
60082 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
60083 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
60084 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
60085 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
60086 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
60087 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
60088 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
60089 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
60090 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
60091 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
60092 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
60093 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
60094 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
60095 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
60096 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
60097 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
60098 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
60099 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
60100 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
60101 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
60102 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
60103 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
60104 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
60105 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
60106 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
60107 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
60108 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
60109 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
60110 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
60111 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
60112 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
60113 static swig_type_info _swigt__p_wxSizerFlags = {"_p_wxSizerFlags", "wxSizerFlags *", 0, 0, (void*)0, 0};
60114 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
60115 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
60116 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
60117 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
60118 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
60119 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
60120 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
60121 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
60122 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
60123 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
60124 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
60125 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
60126 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
60127 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
60128 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
60129 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
60130
60131 static swig_type_info *swig_type_initial[] = {
60132 &_swigt__p_buffer,
60133 &_swigt__p_char,
60134 &_swigt__p_form_ops_t,
60135 &_swigt__p_int,
60136 &_swigt__p_long,
60137 &_swigt__p_unsigned_char,
60138 &_swigt__p_unsigned_int,
60139 &_swigt__p_unsigned_long,
60140 &_swigt__p_wxANIHandler,
60141 &_swigt__p_wxAcceleratorEntry,
60142 &_swigt__p_wxAcceleratorTable,
60143 &_swigt__p_wxActivateEvent,
60144 &_swigt__p_wxAppTraits,
60145 &_swigt__p_wxArrayString,
60146 &_swigt__p_wxBMPHandler,
60147 &_swigt__p_wxBitmap,
60148 &_swigt__p_wxBoxSizer,
60149 &_swigt__p_wxButton,
60150 &_swigt__p_wxCURHandler,
60151 &_swigt__p_wxCaret,
60152 &_swigt__p_wxChildFocusEvent,
60153 &_swigt__p_wxClipboardTextEvent,
60154 &_swigt__p_wxCloseEvent,
60155 &_swigt__p_wxColour,
60156 &_swigt__p_wxCommandEvent,
60157 &_swigt__p_wxContextMenuEvent,
60158 &_swigt__p_wxControl,
60159 &_swigt__p_wxControlWithItems,
60160 &_swigt__p_wxCursor,
60161 &_swigt__p_wxDC,
60162 &_swigt__p_wxDateEvent,
60163 &_swigt__p_wxDateTime,
60164 &_swigt__p_wxDisplayChangedEvent,
60165 &_swigt__p_wxDouble,
60166 &_swigt__p_wxDropFilesEvent,
60167 &_swigt__p_wxDuplexMode,
60168 &_swigt__p_wxEraseEvent,
60169 &_swigt__p_wxEvent,
60170 &_swigt__p_wxEventBlocker,
60171 &_swigt__p_wxEventLoop,
60172 &_swigt__p_wxEventLoopActivator,
60173 &_swigt__p_wxEvtHandler,
60174 &_swigt__p_wxFSFile,
60175 &_swigt__p_wxFileSystem,
60176 &_swigt__p_wxFileSystemHandler,
60177 &_swigt__p_wxFlexGridSizer,
60178 &_swigt__p_wxFocusEvent,
60179 &_swigt__p_wxFont,
60180 &_swigt__p_wxFrame,
60181 &_swigt__p_wxGBPosition,
60182 &_swigt__p_wxGBSizerItem,
60183 &_swigt__p_wxGBSpan,
60184 &_swigt__p_wxGIFHandler,
60185 &_swigt__p_wxGridBagSizer,
60186 &_swigt__p_wxGridSizer,
60187 &_swigt__p_wxHelpEvent__Origin,
60188 &_swigt__p_wxICOHandler,
60189 &_swigt__p_wxIconizeEvent,
60190 &_swigt__p_wxIdleEvent,
60191 &_swigt__p_wxImage,
60192 &_swigt__p_wxImageHandler,
60193 &_swigt__p_wxImageHistogram,
60194 &_swigt__p_wxImage_HSVValue,
60195 &_swigt__p_wxImage_RGBValue,
60196 &_swigt__p_wxIndividualLayoutConstraint,
60197 &_swigt__p_wxInitDialogEvent,
60198 &_swigt__p_wxInputStream,
60199 &_swigt__p_wxInternetFSHandler,
60200 &_swigt__p_wxItemContainer,
60201 &_swigt__p_wxJPEGHandler,
60202 &_swigt__p_wxKeyEvent,
60203 &_swigt__p_wxLayoutConstraints,
60204 &_swigt__p_wxMaximizeEvent,
60205 &_swigt__p_wxMemoryFSHandler,
60206 &_swigt__p_wxMenu,
60207 &_swigt__p_wxMenuBar,
60208 &_swigt__p_wxMenuBarBase,
60209 &_swigt__p_wxMenuEvent,
60210 &_swigt__p_wxMenuItem,
60211 &_swigt__p_wxMouseCaptureChangedEvent,
60212 &_swigt__p_wxMouseCaptureLostEvent,
60213 &_swigt__p_wxMouseEvent,
60214 &_swigt__p_wxMoveEvent,
60215 &_swigt__p_wxNavigationKeyEvent,
60216 &_swigt__p_wxNcPaintEvent,
60217 &_swigt__p_wxNotifyEvent,
60218 &_swigt__p_wxObject,
60219 &_swigt__p_wxOutputStream,
60220 &_swigt__p_wxPCXHandler,
60221 &_swigt__p_wxPNGHandler,
60222 &_swigt__p_wxPNMHandler,
60223 &_swigt__p_wxPaintEvent,
60224 &_swigt__p_wxPaletteChangedEvent,
60225 &_swigt__p_wxPaperSize,
60226 &_swigt__p_wxPoint,
60227 &_swigt__p_wxPoint2D,
60228 &_swigt__p_wxPropagateOnce,
60229 &_swigt__p_wxPropagationDisabler,
60230 &_swigt__p_wxPyApp,
60231 &_swigt__p_wxPyCommandEvent,
60232 &_swigt__p_wxPyDropTarget,
60233 &_swigt__p_wxPyEvent,
60234 &_swigt__p_wxPyFileSystemHandler,
60235 &_swigt__p_wxPyImageHandler,
60236 &_swigt__p_wxPyInputStream,
60237 &_swigt__p_wxPySizer,
60238 &_swigt__p_wxPyValidator,
60239 &_swigt__p_wxQuantize,
60240 &_swigt__p_wxQueryNewPaletteEvent,
60241 &_swigt__p_wxRealPoint,
60242 &_swigt__p_wxRect,
60243 &_swigt__p_wxRect2D,
60244 &_swigt__p_wxRegion,
60245 &_swigt__p_wxScrollEvent,
60246 &_swigt__p_wxScrollWinEvent,
60247 &_swigt__p_wxSetCursorEvent,
60248 &_swigt__p_wxShowEvent,
60249 &_swigt__p_wxSize,
60250 &_swigt__p_wxSizeEvent,
60251 &_swigt__p_wxSizer,
60252 &_swigt__p_wxSizerFlags,
60253 &_swigt__p_wxSizerItem,
60254 &_swigt__p_wxStaticBox,
60255 &_swigt__p_wxStaticBoxSizer,
60256 &_swigt__p_wxStdDialogButtonSizer,
60257 &_swigt__p_wxSysColourChangedEvent,
60258 &_swigt__p_wxTGAHandler,
60259 &_swigt__p_wxTIFFHandler,
60260 &_swigt__p_wxToolTip,
60261 &_swigt__p_wxUpdateUIEvent,
60262 &_swigt__p_wxValidator,
60263 &_swigt__p_wxVisualAttributes,
60264 &_swigt__p_wxWindow,
60265 &_swigt__p_wxWindowCreateEvent,
60266 &_swigt__p_wxWindowDestroyEvent,
60267 &_swigt__p_wxXPMHandler,
60268 &_swigt__p_wxZipFSHandler,
60269 };
60270
60271 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
60272 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
60273 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
60274 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
60275 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
60276 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
60277 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
60278 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
60279 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
60280 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
60281 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
60282 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
60283 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
60284 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
60285 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}};
60286 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
60287 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}};
60288 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
60289 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}};
60290 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
60291 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60292 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
60293 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
60294 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
60295 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}};
60296 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60297 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}};
60298 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
60299 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
60300 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
60301 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
60302 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
60303 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60304 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
60305 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
60306 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
60307 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
60308 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}};
60309 static swig_cast_info _swigc__p_wxEventBlocker[] = { {&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
60310 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
60311 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
60312 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}};
60313 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
60314 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
60315 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}};
60316 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}};
60317 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60318 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
60319 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
60320 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
60321 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
60322 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
60323 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
60324 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
60325 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}};
60326 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
60327 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}};
60328 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60329 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
60330 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
60331 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}};
60332 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
60333 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
60334 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
60335 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
60336 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
60337 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
60338 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60339 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}};
60340 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
60341 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60342 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
60343 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60344 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60345 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
60346 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
60347 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
60348 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60349 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
60350 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60351 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
60352 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
60353 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
60354 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60355 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60356 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
60357 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}};
60358 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
60359 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
60360 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
60361 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
60362 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60363 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60364 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
60365 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
60366 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
60367 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
60368 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
60369 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
60370 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
60371 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
60372 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
60373 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
60374 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
60375 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
60376 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
60377 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
60378 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
60379 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
60380 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
60381 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
60382 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
60383 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
60384 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
60385 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
60386 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
60387 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
60388 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
60389 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60390 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}};
60391 static swig_cast_info _swigc__p_wxSizerFlags[] = { {&_swigt__p_wxSizerFlags, 0, 0, 0},{0, 0, 0, 0}};
60392 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}};
60393 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
60394 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
60395 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
60396 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60397 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
60398 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
60399 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
60400 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
60401 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}};
60402 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
60403 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}};
60404 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
60405 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
60406 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
60407 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60408
60409 static swig_cast_info *swig_cast_initial[] = {
60410 _swigc__p_buffer,
60411 _swigc__p_char,
60412 _swigc__p_form_ops_t,
60413 _swigc__p_int,
60414 _swigc__p_long,
60415 _swigc__p_unsigned_char,
60416 _swigc__p_unsigned_int,
60417 _swigc__p_unsigned_long,
60418 _swigc__p_wxANIHandler,
60419 _swigc__p_wxAcceleratorEntry,
60420 _swigc__p_wxAcceleratorTable,
60421 _swigc__p_wxActivateEvent,
60422 _swigc__p_wxAppTraits,
60423 _swigc__p_wxArrayString,
60424 _swigc__p_wxBMPHandler,
60425 _swigc__p_wxBitmap,
60426 _swigc__p_wxBoxSizer,
60427 _swigc__p_wxButton,
60428 _swigc__p_wxCURHandler,
60429 _swigc__p_wxCaret,
60430 _swigc__p_wxChildFocusEvent,
60431 _swigc__p_wxClipboardTextEvent,
60432 _swigc__p_wxCloseEvent,
60433 _swigc__p_wxColour,
60434 _swigc__p_wxCommandEvent,
60435 _swigc__p_wxContextMenuEvent,
60436 _swigc__p_wxControl,
60437 _swigc__p_wxControlWithItems,
60438 _swigc__p_wxCursor,
60439 _swigc__p_wxDC,
60440 _swigc__p_wxDateEvent,
60441 _swigc__p_wxDateTime,
60442 _swigc__p_wxDisplayChangedEvent,
60443 _swigc__p_wxDouble,
60444 _swigc__p_wxDropFilesEvent,
60445 _swigc__p_wxDuplexMode,
60446 _swigc__p_wxEraseEvent,
60447 _swigc__p_wxEvent,
60448 _swigc__p_wxEventBlocker,
60449 _swigc__p_wxEventLoop,
60450 _swigc__p_wxEventLoopActivator,
60451 _swigc__p_wxEvtHandler,
60452 _swigc__p_wxFSFile,
60453 _swigc__p_wxFileSystem,
60454 _swigc__p_wxFileSystemHandler,
60455 _swigc__p_wxFlexGridSizer,
60456 _swigc__p_wxFocusEvent,
60457 _swigc__p_wxFont,
60458 _swigc__p_wxFrame,
60459 _swigc__p_wxGBPosition,
60460 _swigc__p_wxGBSizerItem,
60461 _swigc__p_wxGBSpan,
60462 _swigc__p_wxGIFHandler,
60463 _swigc__p_wxGridBagSizer,
60464 _swigc__p_wxGridSizer,
60465 _swigc__p_wxHelpEvent__Origin,
60466 _swigc__p_wxICOHandler,
60467 _swigc__p_wxIconizeEvent,
60468 _swigc__p_wxIdleEvent,
60469 _swigc__p_wxImage,
60470 _swigc__p_wxImageHandler,
60471 _swigc__p_wxImageHistogram,
60472 _swigc__p_wxImage_HSVValue,
60473 _swigc__p_wxImage_RGBValue,
60474 _swigc__p_wxIndividualLayoutConstraint,
60475 _swigc__p_wxInitDialogEvent,
60476 _swigc__p_wxInputStream,
60477 _swigc__p_wxInternetFSHandler,
60478 _swigc__p_wxItemContainer,
60479 _swigc__p_wxJPEGHandler,
60480 _swigc__p_wxKeyEvent,
60481 _swigc__p_wxLayoutConstraints,
60482 _swigc__p_wxMaximizeEvent,
60483 _swigc__p_wxMemoryFSHandler,
60484 _swigc__p_wxMenu,
60485 _swigc__p_wxMenuBar,
60486 _swigc__p_wxMenuBarBase,
60487 _swigc__p_wxMenuEvent,
60488 _swigc__p_wxMenuItem,
60489 _swigc__p_wxMouseCaptureChangedEvent,
60490 _swigc__p_wxMouseCaptureLostEvent,
60491 _swigc__p_wxMouseEvent,
60492 _swigc__p_wxMoveEvent,
60493 _swigc__p_wxNavigationKeyEvent,
60494 _swigc__p_wxNcPaintEvent,
60495 _swigc__p_wxNotifyEvent,
60496 _swigc__p_wxObject,
60497 _swigc__p_wxOutputStream,
60498 _swigc__p_wxPCXHandler,
60499 _swigc__p_wxPNGHandler,
60500 _swigc__p_wxPNMHandler,
60501 _swigc__p_wxPaintEvent,
60502 _swigc__p_wxPaletteChangedEvent,
60503 _swigc__p_wxPaperSize,
60504 _swigc__p_wxPoint,
60505 _swigc__p_wxPoint2D,
60506 _swigc__p_wxPropagateOnce,
60507 _swigc__p_wxPropagationDisabler,
60508 _swigc__p_wxPyApp,
60509 _swigc__p_wxPyCommandEvent,
60510 _swigc__p_wxPyDropTarget,
60511 _swigc__p_wxPyEvent,
60512 _swigc__p_wxPyFileSystemHandler,
60513 _swigc__p_wxPyImageHandler,
60514 _swigc__p_wxPyInputStream,
60515 _swigc__p_wxPySizer,
60516 _swigc__p_wxPyValidator,
60517 _swigc__p_wxQuantize,
60518 _swigc__p_wxQueryNewPaletteEvent,
60519 _swigc__p_wxRealPoint,
60520 _swigc__p_wxRect,
60521 _swigc__p_wxRect2D,
60522 _swigc__p_wxRegion,
60523 _swigc__p_wxScrollEvent,
60524 _swigc__p_wxScrollWinEvent,
60525 _swigc__p_wxSetCursorEvent,
60526 _swigc__p_wxShowEvent,
60527 _swigc__p_wxSize,
60528 _swigc__p_wxSizeEvent,
60529 _swigc__p_wxSizer,
60530 _swigc__p_wxSizerFlags,
60531 _swigc__p_wxSizerItem,
60532 _swigc__p_wxStaticBox,
60533 _swigc__p_wxStaticBoxSizer,
60534 _swigc__p_wxStdDialogButtonSizer,
60535 _swigc__p_wxSysColourChangedEvent,
60536 _swigc__p_wxTGAHandler,
60537 _swigc__p_wxTIFFHandler,
60538 _swigc__p_wxToolTip,
60539 _swigc__p_wxUpdateUIEvent,
60540 _swigc__p_wxValidator,
60541 _swigc__p_wxVisualAttributes,
60542 _swigc__p_wxWindow,
60543 _swigc__p_wxWindowCreateEvent,
60544 _swigc__p_wxWindowDestroyEvent,
60545 _swigc__p_wxXPMHandler,
60546 _swigc__p_wxZipFSHandler,
60547 };
60548
60549
60550 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
60551
60552 static swig_const_info swig_const_table[] = {
60553 {0, 0, 0, 0.0, 0, 0}};
60554
60555 #ifdef __cplusplus
60556 }
60557 #endif
60558 /* -----------------------------------------------------------------------------
60559 * Type initialization:
60560 * This problem is tough by the requirement that no dynamic
60561 * memory is used. Also, since swig_type_info structures store pointers to
60562 * swig_cast_info structures and swig_cast_info structures store pointers back
60563 * to swig_type_info structures, we need some lookup code at initialization.
60564 * The idea is that swig generates all the structures that are needed.
60565 * The runtime then collects these partially filled structures.
60566 * The SWIG_InitializeModule function takes these initial arrays out of
60567 * swig_module, and does all the lookup, filling in the swig_module.types
60568 * array with the correct data and linking the correct swig_cast_info
60569 * structures together.
60570 *
60571 * The generated swig_type_info structures are assigned staticly to an initial
60572 * array. We just loop though that array, and handle each type individually.
60573 * First we lookup if this type has been already loaded, and if so, use the
60574 * loaded structure instead of the generated one. Then we have to fill in the
60575 * cast linked list. The cast data is initially stored in something like a
60576 * two-dimensional array. Each row corresponds to a type (there are the same
60577 * number of rows as there are in the swig_type_initial array). Each entry in
60578 * a column is one of the swig_cast_info structures for that type.
60579 * The cast_initial array is actually an array of arrays, because each row has
60580 * a variable number of columns. So to actually build the cast linked list,
60581 * we find the array of casts associated with the type, and loop through it
60582 * adding the casts to the list. The one last trick we need to do is making
60583 * sure the type pointer in the swig_cast_info struct is correct.
60584 *
60585 * First off, we lookup the cast->type name to see if it is already loaded.
60586 * There are three cases to handle:
60587 * 1) If the cast->type has already been loaded AND the type we are adding
60588 * casting info to has not been loaded (it is in this module), THEN we
60589 * replace the cast->type pointer with the type pointer that has already
60590 * been loaded.
60591 * 2) If BOTH types (the one we are adding casting info to, and the
60592 * cast->type) are loaded, THEN the cast info has already been loaded by
60593 * the previous module so we just ignore it.
60594 * 3) Finally, if cast->type has not already been loaded, then we add that
60595 * swig_cast_info to the linked list (because the cast->type) pointer will
60596 * be correct.
60597 * ----------------------------------------------------------------------------- */
60598
60599 #ifdef __cplusplus
60600 extern "C" {
60601 #if 0
60602 } /* c-mode */
60603 #endif
60604 #endif
60605
60606 #if 0
60607 #define SWIGRUNTIME_DEBUG
60608 #endif
60609
60610 SWIGRUNTIME void
60611 SWIG_InitializeModule(void *clientdata) {
60612 size_t i;
60613 swig_module_info *module_head;
60614 static int init_run = 0;
60615
60616 clientdata = clientdata;
60617
60618 if (init_run) return;
60619 init_run = 1;
60620
60621 /* Initialize the swig_module */
60622 swig_module.type_initial = swig_type_initial;
60623 swig_module.cast_initial = swig_cast_initial;
60624
60625 /* Try and load any already created modules */
60626 module_head = SWIG_GetModule(clientdata);
60627 if (module_head) {
60628 swig_module.next = module_head->next;
60629 module_head->next = &swig_module;
60630 } else {
60631 /* This is the first module loaded */
60632 swig_module.next = &swig_module;
60633 SWIG_SetModule(clientdata, &swig_module);
60634 }
60635
60636 /* Now work on filling in swig_module.types */
60637 #ifdef SWIGRUNTIME_DEBUG
60638 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
60639 #endif
60640 for (i = 0; i < swig_module.size; ++i) {
60641 swig_type_info *type = 0;
60642 swig_type_info *ret;
60643 swig_cast_info *cast;
60644
60645 #ifdef SWIGRUNTIME_DEBUG
60646 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
60647 #endif
60648
60649 /* if there is another module already loaded */
60650 if (swig_module.next != &swig_module) {
60651 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
60652 }
60653 if (type) {
60654 /* Overwrite clientdata field */
60655 #ifdef SWIGRUNTIME_DEBUG
60656 printf("SWIG_InitializeModule: found type %s\n", type->name);
60657 #endif
60658 if (swig_module.type_initial[i]->clientdata) {
60659 type->clientdata = swig_module.type_initial[i]->clientdata;
60660 #ifdef SWIGRUNTIME_DEBUG
60661 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
60662 #endif
60663 }
60664 } else {
60665 type = swig_module.type_initial[i];
60666 }
60667
60668 /* Insert casting types */
60669 cast = swig_module.cast_initial[i];
60670 while (cast->type) {
60671 /* Don't need to add information already in the list */
60672 ret = 0;
60673 #ifdef SWIGRUNTIME_DEBUG
60674 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
60675 #endif
60676 if (swig_module.next != &swig_module) {
60677 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
60678 #ifdef SWIGRUNTIME_DEBUG
60679 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
60680 #endif
60681 }
60682 if (ret) {
60683 if (type == swig_module.type_initial[i]) {
60684 #ifdef SWIGRUNTIME_DEBUG
60685 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
60686 #endif
60687 cast->type = ret;
60688 ret = 0;
60689 } else {
60690 /* Check for casting already in the list */
60691 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
60692 #ifdef SWIGRUNTIME_DEBUG
60693 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
60694 #endif
60695 if (!ocast) ret = 0;
60696 }
60697 }
60698
60699 if (!ret) {
60700 #ifdef SWIGRUNTIME_DEBUG
60701 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
60702 #endif
60703 if (type->cast) {
60704 type->cast->prev = cast;
60705 cast->next = type->cast;
60706 }
60707 type->cast = cast;
60708 }
60709 cast++;
60710 }
60711 /* Set entry in modules->types array equal to the type */
60712 swig_module.types[i] = type;
60713 }
60714 swig_module.types[i] = 0;
60715
60716 #ifdef SWIGRUNTIME_DEBUG
60717 printf("**** SWIG_InitializeModule: Cast List ******\n");
60718 for (i = 0; i < swig_module.size; ++i) {
60719 int j = 0;
60720 swig_cast_info *cast = swig_module.cast_initial[i];
60721 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
60722 while (cast->type) {
60723 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
60724 cast++;
60725 ++j;
60726 }
60727 printf("---- Total casts: %d\n",j);
60728 }
60729 printf("**** SWIG_InitializeModule: Cast List ******\n");
60730 #endif
60731 }
60732
60733 /* This function will propagate the clientdata field of type to
60734 * any new swig_type_info structures that have been added into the list
60735 * of equivalent types. It is like calling
60736 * SWIG_TypeClientData(type, clientdata) a second time.
60737 */
60738 SWIGRUNTIME void
60739 SWIG_PropagateClientData(void) {
60740 size_t i;
60741 swig_cast_info *equiv;
60742 static int init_run = 0;
60743
60744 if (init_run) return;
60745 init_run = 1;
60746
60747 for (i = 0; i < swig_module.size; i++) {
60748 if (swig_module.types[i]->clientdata) {
60749 equiv = swig_module.types[i]->cast;
60750 while (equiv) {
60751 if (!equiv->converter) {
60752 if (equiv->type && !equiv->type->clientdata)
60753 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
60754 }
60755 equiv = equiv->next;
60756 }
60757 }
60758 }
60759 }
60760
60761 #ifdef __cplusplus
60762 #if 0
60763 {
60764 /* c-mode */
60765 #endif
60766 }
60767 #endif
60768
60769
60770
60771 #ifdef __cplusplus
60772 extern "C" {
60773 #endif
60774
60775 /* Python-specific SWIG API */
60776 #define SWIG_newvarlink() SWIG_Python_newvarlink()
60777 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
60778 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
60779
60780 /* -----------------------------------------------------------------------------
60781 * global variable support code.
60782 * ----------------------------------------------------------------------------- */
60783
60784 typedef struct swig_globalvar {
60785 char *name; /* Name of global variable */
60786 PyObject *(*get_attr)(void); /* Return the current value */
60787 int (*set_attr)(PyObject *); /* Set the value */
60788 struct swig_globalvar *next;
60789 } swig_globalvar;
60790
60791 typedef struct swig_varlinkobject {
60792 PyObject_HEAD
60793 swig_globalvar *vars;
60794 } swig_varlinkobject;
60795
60796 SWIGINTERN PyObject *
60797 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
60798 return PyString_FromString("<Swig global variables>");
60799 }
60800
60801 SWIGINTERN PyObject *
60802 swig_varlink_str(swig_varlinkobject *v) {
60803 PyObject *str = PyString_FromString("(");
60804 swig_globalvar *var;
60805 for (var = v->vars; var; var=var->next) {
60806 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
60807 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
60808 }
60809 PyString_ConcatAndDel(&str,PyString_FromString(")"));
60810 return str;
60811 }
60812
60813 SWIGINTERN int
60814 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
60815 PyObject *str = swig_varlink_str(v);
60816 fprintf(fp,"Swig global variables ");
60817 fprintf(fp,"%s\n", PyString_AsString(str));
60818 Py_DECREF(str);
60819 return 0;
60820 }
60821
60822 SWIGINTERN void
60823 swig_varlink_dealloc(swig_varlinkobject *v) {
60824 swig_globalvar *var = v->vars;
60825 while (var) {
60826 swig_globalvar *n = var->next;
60827 free(var->name);
60828 free(var);
60829 var = n;
60830 }
60831 }
60832
60833 SWIGINTERN PyObject *
60834 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
60835 PyObject *res = NULL;
60836 swig_globalvar *var = v->vars;
60837 while (var) {
60838 if (strcmp(var->name,n) == 0) {
60839 res = (*var->get_attr)();
60840 break;
60841 }
60842 var = var->next;
60843 }
60844 if (res == NULL && !PyErr_Occurred()) {
60845 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
60846 }
60847 return res;
60848 }
60849
60850 SWIGINTERN int
60851 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
60852 int res = 1;
60853 swig_globalvar *var = v->vars;
60854 while (var) {
60855 if (strcmp(var->name,n) == 0) {
60856 res = (*var->set_attr)(p);
60857 break;
60858 }
60859 var = var->next;
60860 }
60861 if (res == 1 && !PyErr_Occurred()) {
60862 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
60863 }
60864 return res;
60865 }
60866
60867 SWIGINTERN PyTypeObject*
60868 swig_varlink_type(void) {
60869 static char varlink__doc__[] = "Swig var link object";
60870 static PyTypeObject varlink_type;
60871 static int type_init = 0;
60872 if (!type_init) {
60873 const PyTypeObject tmp
60874 = {
60875 PyObject_HEAD_INIT(NULL)
60876 0, /* Number of items in variable part (ob_size) */
60877 (char *)"swigvarlink", /* Type name (tp_name) */
60878 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
60879 0, /* Itemsize (tp_itemsize) */
60880 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
60881 (printfunc) swig_varlink_print, /* Print (tp_print) */
60882 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
60883 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
60884 0, /* tp_compare */
60885 (reprfunc) swig_varlink_repr, /* tp_repr */
60886 0, /* tp_as_number */
60887 0, /* tp_as_sequence */
60888 0, /* tp_as_mapping */
60889 0, /* tp_hash */
60890 0, /* tp_call */
60891 (reprfunc)swig_varlink_str, /* tp_str */
60892 0, /* tp_getattro */
60893 0, /* tp_setattro */
60894 0, /* tp_as_buffer */
60895 0, /* tp_flags */
60896 varlink__doc__, /* tp_doc */
60897 0, /* tp_traverse */
60898 0, /* tp_clear */
60899 0, /* tp_richcompare */
60900 0, /* tp_weaklistoffset */
60901 #if PY_VERSION_HEX >= 0x02020000
60902 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
60903 #endif
60904 #if PY_VERSION_HEX >= 0x02030000
60905 0, /* tp_del */
60906 #endif
60907 #ifdef COUNT_ALLOCS
60908 0,0,0,0 /* tp_alloc -> tp_next */
60909 #endif
60910 };
60911 varlink_type = tmp;
60912 varlink_type.ob_type = &PyType_Type;
60913 type_init = 1;
60914 }
60915 return &varlink_type;
60916 }
60917
60918 /* Create a variable linking object for use later */
60919 SWIGINTERN PyObject *
60920 SWIG_Python_newvarlink(void) {
60921 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
60922 if (result) {
60923 result->vars = 0;
60924 }
60925 return ((PyObject*) result);
60926 }
60927
60928 SWIGINTERN void
60929 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
60930 swig_varlinkobject *v = (swig_varlinkobject *) p;
60931 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
60932 if (gv) {
60933 size_t size = strlen(name)+1;
60934 gv->name = (char *)malloc(size);
60935 if (gv->name) {
60936 strncpy(gv->name,name,size);
60937 gv->get_attr = get_attr;
60938 gv->set_attr = set_attr;
60939 gv->next = v->vars;
60940 }
60941 }
60942 v->vars = gv;
60943 }
60944
60945 SWIGINTERN PyObject *
60946 SWIG_globals() {
60947 static PyObject *_SWIG_globals = 0;
60948 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
60949 return _SWIG_globals;
60950 }
60951
60952 /* -----------------------------------------------------------------------------
60953 * constants/methods manipulation
60954 * ----------------------------------------------------------------------------- */
60955
60956 /* Install Constants */
60957 SWIGINTERN void
60958 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
60959 PyObject *obj = 0;
60960 size_t i;
60961 for (i = 0; constants[i].type; ++i) {
60962 switch(constants[i].type) {
60963 case SWIG_PY_POINTER:
60964 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
60965 break;
60966 case SWIG_PY_BINARY:
60967 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
60968 break;
60969 default:
60970 obj = 0;
60971 break;
60972 }
60973 if (obj) {
60974 PyDict_SetItemString(d, constants[i].name, obj);
60975 Py_DECREF(obj);
60976 }
60977 }
60978 }
60979
60980 /* -----------------------------------------------------------------------------*/
60981 /* Fix SwigMethods to carry the callback ptrs when needed */
60982 /* -----------------------------------------------------------------------------*/
60983
60984 SWIGINTERN void
60985 SWIG_Python_FixMethods(PyMethodDef *methods,
60986 swig_const_info *const_table,
60987 swig_type_info **types,
60988 swig_type_info **types_initial) {
60989 size_t i;
60990 for (i = 0; methods[i].ml_name; ++i) {
60991 const char *c = methods[i].ml_doc;
60992 if (c && (c = strstr(c, "swig_ptr: "))) {
60993 int j;
60994 swig_const_info *ci = 0;
60995 const char *name = c + 10;
60996 for (j = 0; const_table[j].type; ++j) {
60997 if (strncmp(const_table[j].name, name,
60998 strlen(const_table[j].name)) == 0) {
60999 ci = &(const_table[j]);
61000 break;
61001 }
61002 }
61003 if (ci) {
61004 size_t shift = (ci->ptype) - types;
61005 swig_type_info *ty = types_initial[shift];
61006 size_t ldoc = (c - methods[i].ml_doc);
61007 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
61008 char *ndoc = (char*)malloc(ldoc + lptr + 10);
61009 if (ndoc) {
61010 char *buff = ndoc;
61011 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
61012 if (ptr) {
61013 strncpy(buff, methods[i].ml_doc, ldoc);
61014 buff += ldoc;
61015 strncpy(buff, "swig_ptr: ", 10);
61016 buff += 10;
61017 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
61018 methods[i].ml_doc = ndoc;
61019 }
61020 }
61021 }
61022 }
61023 }
61024 }
61025
61026 #ifdef __cplusplus
61027 }
61028 #endif
61029
61030 /* -----------------------------------------------------------------------------*
61031 * Partial Init method
61032 * -----------------------------------------------------------------------------*/
61033
61034 #ifdef __cplusplus
61035 extern "C"
61036 #endif
61037 SWIGEXPORT void SWIG_init(void) {
61038 PyObject *m, *d;
61039
61040 /* Fix SwigMethods to carry the callback ptrs when needed */
61041 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
61042
61043 m = Py_InitModule((char *) SWIG_name, SwigMethods);
61044 d = PyModule_GetDict(m);
61045
61046 SWIG_InitializeModule(0);
61047 SWIG_InstallConstants(d,swig_const_table);
61048
61049
61050
61051 #ifndef wxPyUSE_EXPORT
61052 // Make our API structure a CObject so other modules can import it
61053 // from this module.
61054 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
61055 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
61056 Py_XDECREF(cobj);
61057 #endif
61058
61059 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
61060 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
61061 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
61062 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
61063 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
61064 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
61065 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
61066 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
61067 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
61068 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
61069 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
61070 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
61071 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
61072 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
61073 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
61074 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
61075 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
61076 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
61077 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
61078 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
61079 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
61080 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
61081 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
61082 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
61083 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
61084 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
61085 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
61086 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
61087 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
61088 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
61089 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
61090 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
61091 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
61092 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
61093 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
61094 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
61095 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
61096 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
61097 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
61098 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
61099 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
61100 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
61101 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
61102 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
61103 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
61104 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
61105 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
61106 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
61107 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
61108 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
61109 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
61110 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
61111 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
61112 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
61113 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
61114 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
61115 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
61116 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
61117 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
61118 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
61119 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
61120 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
61121 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
61122 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
61123 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
61124 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
61125 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
61126 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
61127 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
61128 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
61129 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
61130 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
61131 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
61132 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
61133 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
61134 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
61135 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
61136 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
61137 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
61138 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
61139 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
61140 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
61141 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
61142 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
61143 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
61144 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
61145 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
61146 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
61147 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
61148 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
61149 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
61150 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
61151 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
61152 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
61153 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
61154 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
61155 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
61156 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
61157 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
61158 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
61159 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
61160 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
61161 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
61162 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
61163 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
61164 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
61165 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
61166 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
61167 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
61168 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
61169 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
61170 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
61171 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
61172 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
61173 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
61174 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
61175 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
61176 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
61177 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
61178 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
61179 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
61180 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
61181 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
61182 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
61183 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
61184 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
61185 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
61186 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
61187 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
61188 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
61189 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
61190 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
61191 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
61192 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
61193 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
61194 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
61195 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
61196 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
61197 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
61198 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
61199 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
61200 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
61201 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
61202 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
61203 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
61204 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
61205 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
61206 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
61207 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
61208 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
61209 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
61210 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
61211 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
61212 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
61213 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
61214 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
61215 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
61216 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
61217 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
61218 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
61219 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
61220 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
61221 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
61222 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
61223 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
61224 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
61225 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
61226 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
61227 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
61228 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
61229 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
61230 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
61231 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
61232 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
61233 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
61234 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
61235 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
61236 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
61237 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
61238 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
61239 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
61240 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
61241 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
61242 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
61243 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
61244 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
61245 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
61246 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
61247 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
61248 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
61249 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
61250 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
61251 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
61252 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
61253 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
61254 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
61255 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
61256 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
61257 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
61258 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
61259 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
61260 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
61261 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
61262 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
61263 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
61264 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
61265 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
61266 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
61267 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
61268 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
61269 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
61270 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
61271 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
61272 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
61273 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
61274 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
61275 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
61276 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
61277 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
61278 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
61279 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
61280 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
61281 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
61282 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
61283 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
61284 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
61285 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
61286 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
61287 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
61288 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
61289 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
61290 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
61291 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
61292 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
61293 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
61294 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
61295 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
61296 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
61297 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
61298 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
61299 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
61300 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
61301 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
61302 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
61303 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
61304 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
61305 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
61306 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
61307 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
61308 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
61309 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
61310 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
61311 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
61312 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
61313 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
61314 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
61315 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
61316 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
61317 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
61318 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
61319 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
61320 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
61321 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
61322 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
61323 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
61324 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
61325 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
61326 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
61327 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
61328 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
61329 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
61330 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
61331 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
61332 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
61333 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
61334 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
61335 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
61336 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
61337 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
61338 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
61339 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
61340 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
61341 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
61342 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
61343 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
61344 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
61345 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
61346 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
61347 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
61348 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
61349 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
61350 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
61351 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
61352 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
61353 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
61354 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
61355 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
61356 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
61357 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
61358 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
61359 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
61360 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
61361 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
61362 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
61363 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
61364 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
61365 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
61366 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
61367 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
61368 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
61369 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
61370 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
61371 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
61372 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
61373 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
61374 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
61375 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
61376 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
61377 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
61378 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
61379 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
61380 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
61381 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
61382 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
61383 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
61384 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
61385 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
61386 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
61387 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
61388 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
61389 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
61390 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
61391 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
61392 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
61393 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
61394 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
61395 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
61396 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
61397 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
61398 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
61399 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
61400 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
61401 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
61402 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
61403 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
61404 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
61405 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
61406 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
61407 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
61408 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
61409 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
61410 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
61411 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
61412 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
61413 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
61414 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
61415 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
61416 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
61417 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
61418 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
61419 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
61420 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
61421 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
61422 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
61423 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
61424 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
61425 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
61426 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
61427 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
61428 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
61429 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
61430 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
61431 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
61432 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
61433 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
61434 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
61435 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
61436 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
61437 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
61438 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
61439 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
61440 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
61441 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
61442 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
61443 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
61444 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
61445 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
61446 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
61447 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
61448 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
61449 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
61450 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
61451 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
61452 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
61453 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
61454 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
61455 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
61456 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
61457 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
61458 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
61459 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
61460 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
61461 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
61462 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
61463 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
61464 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
61465 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
61466 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
61467 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
61468 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
61469 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
61470 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
61471 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
61472 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
61473 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
61474 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
61475 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
61476 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
61477 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
61478 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
61479 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
61480 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
61481 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
61482 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
61483 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
61484 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
61485 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
61486 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
61487 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
61488 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
61489 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
61490 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
61491 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
61492 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
61493 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
61494 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
61495 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
61496 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
61497 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
61498 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
61499 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
61500 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
61501 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
61502 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
61503 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
61504 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
61505 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
61506 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
61507 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
61508 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
61509 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
61510 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
61511 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
61512 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
61513 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
61514 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
61515 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
61516 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
61517 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
61518 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
61519 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
61520 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
61521 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
61522 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
61523 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
61524 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
61525 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
61526 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
61527 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
61528 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
61529 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
61530 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
61531 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
61532 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
61533 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
61534 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
61535 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
61536 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
61537 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
61538 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
61539 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
61540 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
61541 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
61542 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
61543 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
61544 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
61545 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
61546 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
61547 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
61548 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
61549 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
61550 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
61551 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
61552 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
61553 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
61554 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
61555 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
61556 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
61557 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
61558 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
61559 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
61560 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
61561 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
61562 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
61563 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
61564 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
61565 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
61566 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
61567 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
61568 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
61569 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
61570 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
61571 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
61572 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
61573 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
61574 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
61575 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
61576 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
61577 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
61578 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
61579 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
61580 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
61581 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
61582 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
61583 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
61584 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
61585 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
61586 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
61587 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
61588 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
61589 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
61590 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
61591 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
61592 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
61593 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
61594 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
61595 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
61596 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
61597 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
61598 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
61599 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
61600 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
61601 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
61602 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
61603 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
61604 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
61605 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
61606 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
61607 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
61608 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
61609 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
61610 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
61611 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
61612 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
61613 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
61614 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
61615 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
61616 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
61617 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
61618 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
61619 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
61620 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
61621 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
61622 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
61623 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
61624 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
61625 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
61626 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
61627 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
61628 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
61629 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
61630 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
61631 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
61632 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
61633 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
61634 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
61635 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
61636 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
61637 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
61638 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
61639 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
61640 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
61641 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
61642 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
61643 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
61644 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
61645 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
61646 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
61647 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
61648 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
61649 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
61650 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
61651 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
61652 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
61653 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
61654 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
61655 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
61656 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
61657 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
61658 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
61659 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
61660 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
61661 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
61662 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
61663 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
61664 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
61665 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
61666 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
61667 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
61668 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
61669 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
61670 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
61671 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
61672 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
61673 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
61674 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
61675 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
61676 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
61677 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
61678 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
61679 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
61680 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
61681 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
61682 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
61683 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
61684 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
61685 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
61686 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
61687 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
61688 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
61689 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
61690 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
61691 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
61692 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
61693 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
61694 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
61695 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
61696 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
61697 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
61698 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
61699 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
61700 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
61701 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
61702 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
61703 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
61704 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
61705 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
61706 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
61707 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
61708 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
61709 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
61710 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
61711 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
61712 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
61713 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
61714
61715 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
61716
61717
61718 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
61719
61720 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
61721 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
61722 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
61723 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
61724 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
61725 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
61726 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
61727 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
61728 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
61729 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
61730 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
61731 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
61732 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
61733 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
61734 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
61735 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
61736 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
61737 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
61738 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
61739 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
61740 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
61741 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
61742 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
61743 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
61744 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
61745 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
61746 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
61747 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
61748 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
61749 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
61750 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
61751 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
61752 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
61753 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
61754 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
61755 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
61756 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
61757 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
61758 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
61759 PyDict_SetItemString(d, "wxEVT_ANY", PyInt_FromLong(wxEVT_ANY));
61760 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
61761 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
61762 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
61763 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
61764 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
61765 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
61766 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
61767 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
61768 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
61769 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
61770 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
61771 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
61772 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
61773 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
61774 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
61775 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
61776 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
61777 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
61778 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
61779 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
61780 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
61781 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
61782 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
61783 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
61784 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
61785 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
61786 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
61787 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
61788 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
61789 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
61790 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
61791 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
61792 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
61793 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
61794 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
61795 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
61796 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
61797 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
61798 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
61799 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
61800 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
61801 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
61802 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
61803 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
61804 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
61805 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
61806 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
61807 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
61808 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
61809 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
61810 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
61811 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
61812 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
61813 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
61814 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
61815 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
61816 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
61817 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
61818 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
61819 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
61820 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
61821 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
61822 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
61823 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
61824 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
61825 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
61826 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
61827 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
61828 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
61829 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
61830 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
61831 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
61832 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
61833 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
61834 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
61835 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
61836 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
61837 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
61838 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
61839 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
61840 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
61841 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
61842 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
61843 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
61844 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
61845 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
61846 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
61847 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
61848 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
61849 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
61850 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
61851 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
61852 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
61853 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
61854 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
61855 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
61856 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
61857 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
61858 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
61859 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
61860 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
61861 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
61862 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
61863 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
61864 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
61865 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
61866 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
61867 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
61868 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
61869 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
61870 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
61871 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
61872 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
61873 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
61874 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
61875 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
61876 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
61877 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
61878 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
61879 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
61880 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
61881 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
61882 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
61883 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
61884 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
61885 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
61886 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
61887 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
61888 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
61889 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
61890 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
61891 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
61892 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
61893 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
61894 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
61895 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
61896 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
61897 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
61898 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
61899 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
61900 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
61901 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
61902 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
61903 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
61904 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
61905 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
61906 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
61907 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
61908 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
61909 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
61910 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
61911 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
61912 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
61913 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
61914 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
61915 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
61916 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
61917 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
61918 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
61919 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
61920 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
61921 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
61922 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
61923 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
61924 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
61925 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
61926 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
61927 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
61928 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
61929 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
61930 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
61931 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
61932 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
61933 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
61934 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
61935
61936 // Initialize threading, some globals and such
61937 __wxPyPreStart(d);
61938
61939
61940 // Although these are defined in __version__ they need to be here too so
61941 // that an assert can be done to ensure that the wxPython and the wxWindows
61942 // versions match.
61943 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
61944 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
61945 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
61946
61947 }
61948
wxWidgets (Impactor)