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


e2d780c7d12ef673fff090fde79af721e6d05edb
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMoveEvent swig_types[79]
2546 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNcPaintEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNotifyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxObject swig_types[83]
2550 #define SWIGTYPE_p_wxOutputStream swig_types[84]
2551 #define SWIGTYPE_p_wxPCXHandler swig_types[85]
2552 #define SWIGTYPE_p_wxPNGHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNMHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPaintEvent swig_types[88]
2555 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaperSize swig_types[90]
2557 #define SWIGTYPE_p_wxPoint swig_types[91]
2558 #define SWIGTYPE_p_wxPoint2D swig_types[92]
2559 #define SWIGTYPE_p_wxPropagateOnce swig_types[93]
2560 #define SWIGTYPE_p_wxPropagationDisabler swig_types[94]
2561 #define SWIGTYPE_p_wxPyApp swig_types[95]
2562 #define SWIGTYPE_p_wxPyCommandEvent swig_types[96]
2563 #define SWIGTYPE_p_wxPyDropTarget swig_types[97]
2564 #define SWIGTYPE_p_wxPyEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[99]
2566 #define SWIGTYPE_p_wxPyImageHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyInputStream swig_types[101]
2568 #define SWIGTYPE_p_wxPySizer swig_types[102]
2569 #define SWIGTYPE_p_wxPyValidator swig_types[103]
2570 #define SWIGTYPE_p_wxQuantize swig_types[104]
2571 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[105]
2572 #define SWIGTYPE_p_wxRealPoint swig_types[106]
2573 #define SWIGTYPE_p_wxRect swig_types[107]
2574 #define SWIGTYPE_p_wxRegion swig_types[108]
2575 #define SWIGTYPE_p_wxScrollEvent swig_types[109]
2576 #define SWIGTYPE_p_wxScrollWinEvent swig_types[110]
2577 #define SWIGTYPE_p_wxSetCursorEvent swig_types[111]
2578 #define SWIGTYPE_p_wxShowEvent swig_types[112]
2579 #define SWIGTYPE_p_wxSize swig_types[113]
2580 #define SWIGTYPE_p_wxSizeEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSizer swig_types[115]
2582 #define SWIGTYPE_p_wxSizerItem swig_types[116]
2583 #define SWIGTYPE_p_wxStaticBox swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[118]
2585 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[119]
2586 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[120]
2587 #define SWIGTYPE_p_wxTIFFHandler swig_types[121]
2588 #define SWIGTYPE_p_wxToolTip swig_types[122]
2589 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[123]
2590 #define SWIGTYPE_p_wxValidator swig_types[124]
2591 #define SWIGTYPE_p_wxVisualAttributes swig_types[125]
2592 #define SWIGTYPE_p_wxWindow swig_types[126]
2593 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[127]
2594 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[128]
2595 #define SWIGTYPE_p_wxXPMHandler swig_types[129]
2596 #define SWIGTYPE_p_wxZipFSHandler swig_types[130]
2597 static swig_type_info *swig_types[132];
2598 static swig_module_info swig_module = {swig_types, 131, 0, 0, 0, 0};
2599 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2600 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2601
2602 /* -------- TYPES TABLE (END) -------- */
2603
2604 #if (PY_VERSION_HEX <= 0x02000000)
2605 # if !defined(SWIG_PYTHON_CLASSIC)
2606 # error "This python version requires to use swig with the '-classic' option"
2607 # endif
2608 #endif
2609 #if (PY_VERSION_HEX <= 0x02020000)
2610 # error "This python version requires to use swig with the '-nomodern' option"
2611 #endif
2612 #if (PY_VERSION_HEX <= 0x02020000)
2613 # error "This python version requires to use swig with the '-nomodernargs' option"
2614 #endif
2615 #ifndef METH_O
2616 # error "This python version requires to use swig with the '-nofastunpack' option"
2617 #endif
2618
2619 /*-----------------------------------------------
2620 @(target):= _core_.so
2621 ------------------------------------------------*/
2622 #define SWIG_init init_core_
2623
2624 #define SWIG_name "_core_"
2625
2626 #define SWIGVERSION 0x010329
2627
2628
2629 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2630 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2631
2632
2633 #include <stdexcept>
2634
2635
2636 namespace swig {
2637 class PyObject_ptr {
2638 protected:
2639 PyObject *_obj;
2640
2641 public:
2642 PyObject_ptr() :_obj(0)
2643 {
2644 }
2645
2646 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2647 {
2648 Py_XINCREF(_obj);
2649 }
2650
2651 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2652 {
2653 if (initial_ref) Py_XINCREF(_obj);
2654 }
2655
2656 PyObject_ptr & operator=(const PyObject_ptr& item)
2657 {
2658 Py_XINCREF(item._obj);
2659 Py_XDECREF(_obj);
2660 _obj = item._obj;
2661 return *this;
2662 }
2663
2664 ~PyObject_ptr()
2665 {
2666 Py_XDECREF(_obj);
2667 }
2668
2669 operator PyObject *() const
2670 {
2671 return _obj;
2672 }
2673
2674 PyObject *operator->() const
2675 {
2676 return _obj;
2677 }
2678 };
2679 }
2680
2681
2682 namespace swig {
2683 struct PyObject_var : PyObject_ptr {
2684 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2685
2686 PyObject_var & operator = (PyObject* obj)
2687 {
2688 Py_XDECREF(_obj);
2689 _obj = obj;
2690 return *this;
2691 }
2692 };
2693 }
2694
2695
2696 #include "wx/wxPython/wxPython_int.h"
2697 #include "wx/wxPython/pyclasses.h"
2698 #include "wx/wxPython/twoitem.h"
2699
2700
2701 #ifndef wxPyUSE_EXPORT
2702 // Helper functions for dealing with SWIG objects and such. These are
2703 // located here so they know about the SWIG types and functions declared
2704 // in the wrapper code.
2705
2706 #include <wx/hashmap.h>
2707 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2708
2709
2710 // Maintains a hashmap of className to swig_type_info pointers. Given the
2711 // name of a class either looks up the type info in the cache, or scans the
2712 // SWIG tables for it.
2713 extern PyObject* wxPyPtrTypeMap;
2714 static
2715 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2716
2717 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2718
2719 if (typeInfoCache == NULL)
2720 typeInfoCache = new wxPyTypeInfoHashMap;
2721
2722 wxString name(className);
2723 swig_type_info* swigType = (*typeInfoCache)[name];
2724
2725 if (! swigType) {
2726 // it wasn't in the cache, so look it up from SWIG
2727 name.Append(wxT(" *"));
2728 swigType = SWIG_TypeQuery(name.mb_str());
2729
2730 // if it still wasn't found, try looking for a mapped name
2731 if (!swigType) {
2732 PyObject* item;
2733 name = className;
2734
2735 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2736 (char*)(const char*)name.mbc_str())) != NULL) {
2737 name = wxString(PyString_AsString(item), *wxConvCurrent);
2738 name.Append(wxT(" *"));
2739 swigType = SWIG_TypeQuery(name.mb_str());
2740 }
2741 }
2742 if (swigType) {
2743 // and add it to the map if found
2744 (*typeInfoCache)[className] = swigType;
2745 }
2746 }
2747 return swigType;
2748 }
2749
2750
2751 // Check if a class name is a type known to SWIG
2752 bool wxPyCheckSwigType(const wxChar* className) {
2753
2754 swig_type_info* swigType = wxPyFindSwigType(className);
2755 return swigType != NULL;
2756 }
2757
2758
2759 // Given a pointer to a C++ object and a class name, construct a Python proxy
2760 // object for it.
2761 PyObject* wxPyConstructObject(void* ptr,
2762 const wxChar* className,
2763 int setThisOwn) {
2764
2765 swig_type_info* swigType = wxPyFindSwigType(className);
2766 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2767
2768 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2769 }
2770
2771
2772 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2773 // Ensures that the proxy object is of the specified (or derived) type. If
2774 // not able to perform the conversion then a Python exception is set and the
2775 // error should be handled properly in the caller. Returns True on success.
2776 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2777 const wxChar* className) {
2778
2779 swig_type_info* swigType = wxPyFindSwigType(className);
2780 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2781
2782 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2783 }
2784
2785
2786
2787 // Make a SWIGified pointer object suitable for a .this attribute
2788 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2789
2790 PyObject* robj = NULL;
2791
2792 swig_type_info* swigType = wxPyFindSwigType(className);
2793 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2794
2795 robj = PySwigObject_New(ptr, swigType, 0);
2796 return robj;
2797 }
2798
2799
2800 // Python's PyInstance_Check does not return True for instances of new-style
2801 // classes. This should get close enough for both new and old classes but I
2802 // should re-evaluate the need for doing instance checks...
2803 bool wxPyInstance_Check(PyObject* obj) {
2804 return PyObject_HasAttrString(obj, "__class__") != 0;
2805 }
2806
2807
2808 // This one checks if the object is an instance of a SWIG proxy class (it has
2809 // a .this attribute, and the .this attribute is a PySwigObject.)
2810 bool wxPySwigInstance_Check(PyObject* obj) {
2811 static PyObject* this_str = NULL;
2812 if (this_str == NULL)
2813 this_str = PyString_FromString("this");
2814
2815 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2816 if (this_attr) {
2817 bool retval = (PySwigObject_Check(this_attr) != 0);
2818 Py_DECREF(this_attr);
2819 return retval;
2820 }
2821
2822 PyErr_Clear();
2823 return false;
2824 }
2825
2826
2827 // Export a C API in a struct. Other modules will be able to load this from
2828 // the wx._core_ module and will then have safe access to these functions,
2829 // even if they are located in another shared library.
2830 static wxPyCoreAPI API = {
2831
2832 wxPyCheckSwigType,
2833 wxPyConstructObject,
2834 wxPyConvertSwigPtr,
2835 wxPyMakeSwigPtr,
2836
2837 wxPyBeginAllowThreads,
2838 wxPyEndAllowThreads,
2839 wxPyBeginBlockThreads,
2840 wxPyEndBlockThreads,
2841
2842 wxPy_ConvertList,
2843
2844 wxString_in_helper,
2845 Py2wxString,
2846 wx2PyString,
2847
2848 byte_LIST_helper,
2849 int_LIST_helper,
2850 long_LIST_helper,
2851 string_LIST_helper,
2852 wxPoint_LIST_helper,
2853 wxBitmap_LIST_helper,
2854 wxString_LIST_helper,
2855 wxAcceleratorEntry_LIST_helper,
2856
2857 wxSize_helper,
2858 wxPoint_helper,
2859 wxRealPoint_helper,
2860 wxRect_helper,
2861 wxColour_helper,
2862 wxPoint2D_helper,
2863
2864 wxPySimple_typecheck,
2865 wxColour_typecheck,
2866
2867 wxPyCBH_setCallbackInfo,
2868 wxPyCBH_findCallback,
2869 wxPyCBH_callCallback,
2870 wxPyCBH_callCallbackObj,
2871 wxPyCBH_delete,
2872
2873 wxPyMake_wxObject,
2874 wxPyMake_wxSizer,
2875 wxPyPtrTypeMap_Add,
2876 wxPy2int_seq_helper,
2877 wxPy4int_seq_helper,
2878 wxArrayString2PyList_helper,
2879 wxArrayInt2PyList_helper,
2880
2881 wxPyClientData_dtor,
2882 wxPyUserData_dtor,
2883 wxPyOORClientData_dtor,
2884
2885 wxPyCBInputStream_create,
2886 wxPyCBInputStream_copy,
2887
2888 wxPyInstance_Check,
2889 wxPySwigInstance_Check,
2890
2891 wxPyCheckForApp
2892
2893 };
2894
2895 #endif
2896
2897
2898 #if !WXWIN_COMPATIBILITY_2_4
2899 #define wxHIDE_READONLY 0
2900 #endif
2901
2902
2903 #define SWIG_From_long PyInt_FromLong
2904
2905
2906 SWIGINTERNINLINE PyObject *
2907 SWIG_From_int (int value)
2908 {
2909 return SWIG_From_long (value);
2910 }
2911
2912 static const wxString wxPyEmptyString(wxEmptyString);
2913 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2914 return self->GetClassInfo()->GetClassName();
2915 }
2916 SWIGINTERN void wxObject_Destroy(wxObject *self){
2917 delete self;
2918 }
2919
2920 #ifndef __WXMAC__
2921 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2922 #endif
2923
2924
2925 #include <limits.h>
2926 #ifndef LLONG_MIN
2927 # define LLONG_MIN LONG_LONG_MIN
2928 #endif
2929 #ifndef LLONG_MAX
2930 # define LLONG_MAX LONG_LONG_MAX
2931 #endif
2932 #ifndef ULLONG_MAX
2933 # define ULLONG_MAX ULONG_LONG_MAX
2934 #endif
2935
2936
2937 SWIGINTERN int
2938 SWIG_AsVal_long (PyObject* obj, long* val)
2939 {
2940 if (PyNumber_Check(obj)) {
2941 if (val) *val = PyInt_AsLong(obj);
2942 return SWIG_OK;
2943 }
2944 return SWIG_TypeError;
2945 }
2946
2947
2948 SWIGINTERN int
2949 SWIG_AsVal_int (PyObject * obj, int *val)
2950 {
2951 long v;
2952 int res = SWIG_AsVal_long (obj, &v);
2953 if (SWIG_IsOK(res)) {
2954 if ((v < INT_MIN || v > INT_MAX)) {
2955 return SWIG_OverflowError;
2956 } else {
2957 if (val) *val = static_cast< int >(v);
2958 }
2959 }
2960 return res;
2961 }
2962
2963 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2964 wxSize temp, *obj = &temp;
2965 if ( other == Py_None ) return false;
2966 if ( ! wxSize_helper(other, &obj) ) {
2967 PyErr_Clear();
2968 return false;
2969 }
2970 return self->operator==(*obj);
2971 }
2972 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2973 wxSize temp, *obj = &temp;
2974 if ( other == Py_None ) return true;
2975 if ( ! wxSize_helper(other, &obj)) {
2976 PyErr_Clear();
2977 return true;
2978 }
2979 return self->operator!=(*obj);
2980 }
2981 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2982 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2983 PyObject* tup = PyTuple_New(2);
2984 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2985 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2986 wxPyEndBlockThreads(blocked);
2987 return tup;
2988 }
2989
2990 SWIGINTERN int
2991 SWIG_AsVal_double (PyObject *obj, double* val)
2992 {
2993 if (PyNumber_Check(obj)) {
2994 if (val) *val = PyFloat_AsDouble(obj);
2995 return SWIG_OK;
2996 }
2997 return SWIG_TypeError;
2998 }
2999
3000
3001 #define SWIG_From_double PyFloat_FromDouble
3002
3003 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3004 wxRealPoint temp, *obj = &temp;
3005 if ( other == Py_None ) return false;
3006 if ( ! wxRealPoint_helper(other, &obj) ) {
3007 PyErr_Clear();
3008 return false;
3009 }
3010 return self->operator==(*obj);
3011 }
3012 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3013 wxRealPoint temp, *obj = &temp;
3014 if ( other == Py_None ) return true;
3015 if ( ! wxRealPoint_helper(other, &obj)) {
3016 PyErr_Clear();
3017 return true;
3018 }
3019 return self->operator!=(*obj);
3020 }
3021 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3022 self->x = x;
3023 self->y = y;
3024 }
3025 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3027 PyObject* tup = PyTuple_New(2);
3028 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3029 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3030 wxPyEndBlockThreads(blocked);
3031 return tup;
3032 }
3033 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3034 wxPoint temp, *obj = &temp;
3035 if ( other == Py_None ) return false;
3036 if ( ! wxPoint_helper(other, &obj) ) {
3037 PyErr_Clear();
3038 return false;
3039 }
3040 return self->operator==(*obj);
3041 }
3042 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3043 wxPoint temp, *obj = &temp;
3044 if ( other == Py_None ) return true;
3045 if ( ! wxPoint_helper(other, &obj)) {
3046 PyErr_Clear();
3047 return true;
3048 }
3049 return self->operator!=(*obj);
3050 }
3051 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3052 self->x = x;
3053 self->y = y;
3054 }
3055 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3056 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3057 PyObject* tup = PyTuple_New(2);
3058 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3059 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3060 wxPyEndBlockThreads(blocked);
3061 return tup;
3062 }
3063 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3064 wxRect temp, *obj = &temp;
3065 if ( other == Py_None ) return false;
3066 if ( ! wxRect_helper(other, &obj) ) {
3067 PyErr_Clear();
3068 return false;
3069 }
3070 return self->operator==(*obj);
3071 }
3072 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3073 wxRect temp, *obj = &temp;
3074 if ( other == Py_None ) return true;
3075 if ( ! wxRect_helper(other, &obj)) {
3076 PyErr_Clear();
3077 return true;
3078 }
3079 return self->operator!=(*obj);
3080 }
3081 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3082 self->x = x;
3083 self->y = y;
3084 self->width = width;
3085 self->height = height;
3086 }
3087 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3088 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3089 PyObject* tup = PyTuple_New(4);
3090 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3091 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3092 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3093 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3094 wxPyEndBlockThreads(blocked);
3095 return tup;
3096 }
3097
3098 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3099 wxRegion reg1(*r1);
3100 wxRegion reg2(*r2);
3101 wxRect dest(0,0,0,0);
3102 PyObject* obj;
3103
3104 reg1.Intersect(reg2);
3105 dest = reg1.GetBox();
3106
3107 if (dest != wxRect(0,0,0,0)) {
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 wxRect* newRect = new wxRect(dest);
3110 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3111 wxPyEndBlockThreads(blocked);
3112 return obj;
3113 }
3114 Py_INCREF(Py_None);
3115 return Py_None;
3116 }
3117
3118 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3119 wxPoint2D temp, *obj = &temp;
3120 if ( other == Py_None ) return false;
3121 if ( ! wxPoint2D_helper(other, &obj) ) {
3122 PyErr_Clear();
3123 return false;
3124 }
3125 return self->operator==(*obj);
3126 }
3127 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3128 wxPoint2D temp, *obj = &temp;
3129 if ( other == Py_None ) return true;
3130 if ( ! wxPoint2D_helper(other, &obj)) {
3131 PyErr_Clear();
3132 return true;
3133 }
3134 return self->operator!=(*obj);
3135 }
3136 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3137 self->m_x = x;
3138 self->m_y = y;
3139 }
3140 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3141 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3142 PyObject* tup = PyTuple_New(2);
3143 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3144 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3145 wxPyEndBlockThreads(blocked);
3146 return tup;
3147 }
3148
3149 #include "wx/wxPython/pyistream.h"
3150
3151 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3152 wxInputStream* wxis = wxPyCBInputStream::create(p);
3153 if (wxis)
3154 return new wxPyInputStream(wxis);
3155 else
3156 return NULL;
3157 }
3158
3159 SWIGINTERN swig_type_info*
3160 SWIG_pchar_descriptor()
3161 {
3162 static int init = 0;
3163 static swig_type_info* info = 0;
3164 if (!init) {
3165 info = SWIG_TypeQuery("_p_char");
3166 init = 1;
3167 }
3168 return info;
3169 }
3170
3171
3172 SWIGINTERNINLINE PyObject *
3173 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3174 {
3175 if (carray) {
3176 if (size > INT_MAX) {
3177 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3178 return pchar_descriptor ?
3179 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3180 } else {
3181 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3182 }
3183 } else {
3184 return SWIG_Py_Void();
3185 }
3186 }
3187
3188
3189 SWIGINTERNINLINE PyObject *
3190 SWIG_From_char (char c)
3191 {
3192 return SWIG_FromCharPtrAndSize(&c,1);
3193 }
3194
3195
3196 SWIGINTERNINLINE PyObject*
3197 SWIG_From_unsigned_SS_long (unsigned long value)
3198 {
3199 return (value > LONG_MAX) ?
3200 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3201 }
3202
3203
3204 SWIGINTERNINLINE PyObject *
3205 SWIG_From_size_t (size_t value)
3206 {
3207 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3208 }
3209
3210
3211 SWIGINTERN int
3212 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3213 {
3214 if (PyString_Check(obj)) {
3215 char *cstr; Py_ssize_t len;
3216 PyString_AsStringAndSize(obj, &cstr, &len);
3217 if (cptr) {
3218 if (alloc) {
3219 /*
3220 In python the user should not be able to modify the inner
3221 string representation. To warranty that, if you define
3222 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3223 buffer is always returned.
3224
3225 The default behavior is just to return the pointer value,
3226 so, be careful.
3227 */
3228 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3229 if (*alloc != SWIG_OLDOBJ)
3230 #else
3231 if (*alloc == SWIG_NEWOBJ)
3232 #endif
3233 {
3234 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3235 *alloc = SWIG_NEWOBJ;
3236 }
3237 else {
3238 *cptr = cstr;
3239 *alloc = SWIG_OLDOBJ;
3240 }
3241 } else {
3242 *cptr = PyString_AsString(obj);
3243 }
3244 }
3245 if (psize) *psize = len + 1;
3246 return SWIG_OK;
3247 } else {
3248 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3249 if (pchar_descriptor) {
3250 void* vptr = 0;
3251 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3252 if (cptr) *cptr = (char *) vptr;
3253 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3254 if (alloc) *alloc = SWIG_OLDOBJ;
3255 return SWIG_OK;
3256 }
3257 }
3258 }
3259 return SWIG_TypeError;
3260 }
3261
3262
3263 SWIGINTERN int
3264 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3265 {
3266 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3267 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3268 if (SWIG_IsOK(res)) {
3269 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3270 if (csize <= size) {
3271 if (val) {
3272 if (csize) memcpy(val, cptr, csize*sizeof(char));
3273 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3274 }
3275 if (alloc == SWIG_NEWOBJ) {
3276 delete[] cptr;
3277 res = SWIG_DelNewMask(res);
3278 }
3279 return res;
3280 }
3281 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3282 }
3283 return SWIG_TypeError;
3284 }
3285
3286
3287 SWIGINTERN int
3288 SWIG_AsVal_char (PyObject * obj, char *val)
3289 {
3290 int res = SWIG_AsCharArray(obj, val, 1);
3291 if (!SWIG_IsOK(res)) {
3292 long v;
3293 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3294 if (SWIG_IsOK(res)) {
3295 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3296 if (val) *val = static_cast< char >(v);
3297 } else {
3298 res = SWIG_OverflowError;
3299 }
3300 }
3301 }
3302 return res;
3303 }
3304
3305 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3306 // We use only strings for the streams, not unicode
3307 PyObject* str = PyObject_Str(obj);
3308 if (! str) {
3309 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3310 return;
3311 }
3312 self->Write(PyString_AS_STRING(str),
3313 PyString_GET_SIZE(str));
3314 Py_DECREF(str);
3315 }
3316
3317 #include "wx/wxPython/pyistream.h"
3318
3319
3320 class wxPyFileSystemHandler : public wxFileSystemHandler
3321 {
3322 public:
3323 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3324
3325 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3326 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3327 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3328 DEC_PYCALLBACK_STRING__pure(FindNext);
3329
3330 wxString GetProtocol(const wxString& location) {
3331 return wxFileSystemHandler::GetProtocol(location);
3332 }
3333
3334 wxString GetLeftLocation(const wxString& location) {
3335 return wxFileSystemHandler::GetLeftLocation(location);
3336 }
3337
3338 wxString GetAnchor(const wxString& location) {
3339 return wxFileSystemHandler::GetAnchor(location);
3340 }
3341
3342 wxString GetRightLocation(const wxString& location) {
3343 return wxFileSystemHandler::GetRightLocation(location);
3344 }
3345
3346 wxString GetMimeTypeFromExt(const wxString& location) {
3347 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3348 }
3349
3350 PYPRIVATE;
3351 };
3352
3353
3354 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3355 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3356 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3357 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3358
3359
3360 SWIGINTERN int
3361 SWIG_AsVal_bool (PyObject *obj, bool *val)
3362 {
3363 if (obj == Py_True) {
3364 if (val) *val = true;
3365 return SWIG_OK;
3366 } else if (obj == Py_False) {
3367 if (val) *val = false;
3368 return SWIG_OK;
3369 } else {
3370 long v = 0;
3371 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3372 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3373 return res;
3374 }
3375 }
3376
3377 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3378 wxFileName fname = wxFileSystem::URLToFileName(url);
3379 return fname.GetFullPath();
3380 }
3381
3382 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3383 wxImage& image,
3384 long type) {
3385 wxMemoryFSHandler::AddFile(filename, image, type);
3386 }
3387
3388 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3389 const wxBitmap& bitmap,
3390 long type) {
3391 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3392 }
3393
3394 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3395 PyObject* data) {
3396 if (! PyString_Check(data)) {
3397 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3398 "Expected string object"));
3399 return;
3400 }
3401
3402 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3403 void* ptr = (void*)PyString_AsString(data);
3404 size_t size = PyString_Size(data);
3405 wxPyEndBlockThreads(blocked);
3406
3407 wxMemoryFSHandler::AddFile(filename, ptr, size);
3408 }
3409
3410
3411 #include "wx/wxPython/pyistream.h"
3412
3413
3414 SWIGINTERN int
3415 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3416 {
3417 long v = 0;
3418 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3419 return SWIG_TypeError;
3420 }
3421 else if (val)
3422 *val = (unsigned long)v;
3423 return SWIG_OK;
3424 }
3425
3426
3427 SWIGINTERN int
3428 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3429 {
3430 unsigned long v;
3431 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3432 if (SWIG_IsOK(res)) {
3433 if ((v > UCHAR_MAX)) {
3434 return SWIG_OverflowError;
3435 } else {
3436 if (val) *val = static_cast< unsigned char >(v);
3437 }
3438 }
3439 return res;
3440 }
3441
3442
3443 SWIGINTERNINLINE PyObject *
3444 SWIG_From_unsigned_SS_char (unsigned char value)
3445 {
3446 return SWIG_From_unsigned_SS_long (value);
3447 }
3448
3449 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3450 wxImageHistogramEntry e = (*self)[key];
3451 return e.value;
3452 }
3453 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3454 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3455 wxImageHistogramEntry e = (*self)[key];
3456 return e.value;
3457 }
3458 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3459 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3460 colour.Green(),
3461 colour.Blue());
3462 wxImageHistogramEntry e = (*self)[key];
3463 return e.value;
3464 }
3465
3466 typedef unsigned char* buffer;
3467
3468
3469 // Pull the nested class out to the top level for SWIG's sake
3470 #define wxImage_RGBValue wxImage::RGBValue
3471 #define wxImage_HSVValue wxImage::HSVValue
3472
3473 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3474 if (width > 0 && height > 0)
3475 return new wxImage(width, height, clear);
3476 else
3477 return new wxImage;
3478 }
3479 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3480 return new wxImage(bitmap.ConvertToImage());
3481 }
3482 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3483 if (DATASIZE != width*height*3) {
3484 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3485 return NULL;
3486 }
3487
3488 // Copy the source data so the wxImage can clean it up later
3489 buffer copy = (buffer)malloc(DATASIZE);
3490 if (copy == NULL) {
3491 wxPyBLOCK_THREADS(PyErr_NoMemory());
3492 return NULL;
3493 }
3494 memcpy(copy, data, DATASIZE);
3495 return new wxImage(width, height, copy, false);
3496 }
3497 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3498 if (DATASIZE != width*height*3) {
3499 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3500 return NULL;
3501 }
3502 if (ALPHASIZE != width*height) {
3503 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3504 return NULL;
3505 }
3506
3507 // Copy the source data so the wxImage can clean it up later
3508 buffer dcopy = (buffer)malloc(DATASIZE);
3509 if (dcopy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(dcopy, data, DATASIZE);
3514
3515 buffer acopy = (buffer)malloc(ALPHASIZE);
3516 if (acopy == NULL) {
3517 wxPyBLOCK_THREADS(PyErr_NoMemory());
3518 return NULL;
3519 }
3520 memcpy(acopy, alpha, ALPHASIZE);
3521
3522 return new wxImage(width, height, dcopy, acopy, false);
3523 }
3524 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3525 wxSize size(self->GetWidth(), self->GetHeight());
3526 return size;
3527 }
3528 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3529 buffer data = self->GetData();
3530 int len = self->GetWidth() * self->GetHeight() * 3;
3531 PyObject* rv;
3532 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3533 return rv;
3534 }
3535 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3536 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3537 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3538 return;
3539 }
3540 buffer copy = (buffer)malloc(DATASIZE);
3541 if (copy == NULL) {
3542 wxPyBLOCK_THREADS(PyErr_NoMemory());
3543 return;
3544 }
3545 memcpy(copy, data, DATASIZE);
3546 self->SetData(copy, false);
3547 // wxImage takes ownership of copy...
3548 }
3549 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3550 buffer data = self->GetData();
3551 int len = self->GetWidth() * self->GetHeight() * 3;
3552 PyObject* rv;
3553 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3554 return rv;
3555 }
3556 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3557 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3558 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3559 return;
3560 }
3561 self->SetData(data, true);
3562 }
3563 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3564 buffer data = self->GetAlpha();
3565 if (! data) {
3566 RETURN_NONE();
3567 } else {
3568 int len = self->GetWidth() * self->GetHeight();
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3571 return rv;
3572 }
3573 }
3574 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3575 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3576 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3577 return;
3578 }
3579 buffer acopy = (buffer)malloc(ALPHASIZE);
3580 if (acopy == NULL) {
3581 wxPyBLOCK_THREADS(PyErr_NoMemory());
3582 return;
3583 }
3584 memcpy(acopy, alpha, ALPHASIZE);
3585 self->SetAlpha(acopy, false);
3586 // wxImage takes ownership of acopy...
3587 }
3588 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3589 buffer data = self->GetAlpha();
3590 int len = self->GetWidth() * self->GetHeight();
3591 PyObject* rv;
3592 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3593 return rv;
3594 }
3595 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3596 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3597 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3598 return;
3599 }
3600 self->SetAlpha(alpha, true);
3601 }
3602 SWIGINTERN PyObject *wxImage_GetHandlers(){
3603 wxList& list = wxImage::GetHandlers();
3604 return wxPy_ConvertList(&list);
3605 }
3606 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3607 wxBitmap bitmap(*self, depth);
3608 return bitmap;
3609 }
3610 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3611 wxImage mono = self->ConvertToMono( red, green, blue );
3612 wxBitmap bitmap( mono, 1 );
3613 return bitmap;
3614 }
3615 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3616 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3617 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3618 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3619 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3620 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3621 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3622 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3623 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3624 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3625 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3626 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3627 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3628 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3629 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3630
3631 #include <wx/quantize.h>
3632
3633 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3634 return wxQuantize::Quantize(src, dest,
3635 //NULL, // palette
3636 desiredNoColours,
3637 NULL, // eightBitData
3638 flags);
3639 }
3640 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3641 if (PyCallable_Check(func)) {
3642 self->Connect(id, lastId, eventType,
3643 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3644 new wxPyCallback(func));
3645 }
3646 else if (func == Py_None) {
3647 self->Disconnect(id, lastId, eventType,
3648 (wxObjectEventFunction)
3649 &wxPyCallback::EventThunker);
3650 }
3651 else {
3652 wxPyBLOCK_THREADS(
3653 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3654 }
3655 }
3656 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3657 return self->Disconnect(id, lastId, eventType,
3658 (wxObjectEventFunction)
3659 &wxPyCallback::EventThunker);
3660 }
3661 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3662 if (_self && _self != Py_None) {
3663 self->SetClientObject(new wxPyOORClientData(_self, incref));
3664 }
3665 else {
3666 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3667 if (data) {
3668 self->SetClientObject(NULL); // This will delete it too
3669 }
3670 }
3671 }
3672
3673 #if ! wxUSE_HOTKEY
3674 #define wxEVT_HOTKEY -9999
3675 #endif
3676
3677 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3678 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3679 if (data) {
3680 Py_INCREF(data->m_obj);
3681 return data->m_obj;
3682 } else {
3683 Py_INCREF(Py_None);
3684 return Py_None;
3685 }
3686 }
3687 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3688 wxPyClientData* data = new wxPyClientData(clientData);
3689 self->SetClientObject(data);
3690 }
3691 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3692 #if wxUSE_UNICODE
3693 return self->GetUnicodeKey();
3694 #else
3695 return 0;
3696 #endif
3697 }
3698 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3699 #if wxUSE_UNICODE
3700 self->m_uniChar = uniChar;
3701 #endif
3702 }
3703
3704 SWIGINTERNINLINE PyObject *
3705 SWIG_From_unsigned_SS_int (unsigned int value)
3706 {
3707 return SWIG_From_unsigned_SS_long (value);
3708 }
3709
3710
3711 SWIGINTERN int
3712 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3713 {
3714 unsigned long v;
3715 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3716 if (SWIG_IsOK(res)) {
3717 if ((v > UINT_MAX)) {
3718 return SWIG_OverflowError;
3719 } else {
3720 if (val) *val = static_cast< unsigned int >(v);
3721 }
3722 }
3723 return res;
3724 }
3725
3726 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3727 self->m_size = size;
3728 }
3729 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3730 int count = self->GetNumberOfFiles();
3731 wxString* files = self->GetFiles();
3732 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3733 PyObject* list = PyList_New(count);
3734
3735 if (!list) {
3736 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3737 wxPyEndBlockThreads(blocked);
3738 return NULL;
3739 }
3740
3741 for (int i=0; i<count; i++) {
3742 PyList_SetItem(list, i, wx2PyString(files[i]));
3743 }
3744 wxPyEndBlockThreads(blocked);
3745 return list;
3746 }
3747
3748
3749 SWIGINTERN wxPyApp *new_wxPyApp(){
3750 wxPythonApp = new wxPyApp();
3751 return wxPythonApp;
3752 }
3753
3754 void wxApp_CleanUp() {
3755 __wxPyCleanup();
3756 }
3757
3758
3759 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3760
3761
3762
3763
3764
3765 SWIGINTERNINLINE PyObject *
3766 SWIG_FromCharPtr(const char *cptr)
3767 {
3768 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3769 }
3770
3771
3772 #if 0 // #ifdef __WXMAC__
3773
3774 // A dummy class that raises an exception if used...
3775 class wxEventLoop
3776 {
3777 public:
3778 wxEventLoop() { wxPyRaiseNotImplemented(); }
3779 int Run() { return 0; }
3780 void Exit(int rc = 0) {}
3781 bool Pending() const { return false; }
3782 bool Dispatch() { return false; }
3783 bool IsRunning() const { return false; }
3784 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3785 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3786 };
3787
3788 #else
3789
3790 #include <wx/evtloop.h>
3791
3792 #endif
3793
3794
3795
3796 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3797 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3798 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3799 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3800 wxWindowList& list = self->GetChildren();
3801 return wxPy_ConvertList(&list);
3802 }
3803 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3804 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3805 #if wxUSE_HOTKEY
3806 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3807 #else
3808 return false;
3809 #endif
3810 }
3811 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3812
3813
3814
3815 return false;
3816
3817 }
3818 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3819 return wxPyGetWinHandle(self);
3820 }
3821 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3822 self->AssociateHandle((WXWidget)handle);
3823 }
3824
3825 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3826 return wxWindow::FindWindowById(id, parent);
3827 }
3828
3829 wxWindow* wxFindWindowByName( const wxString& name,
3830 const wxWindow *parent = NULL ) {
3831 return wxWindow::FindWindowByName(name, parent);
3832 }
3833
3834 wxWindow* wxFindWindowByLabel( const wxString& label,
3835 const wxWindow *parent = NULL ) {
3836 return wxWindow::FindWindowByLabel(label, parent);
3837 }
3838
3839
3840 #ifdef __WXMSW__
3841 #include <wx/msw/private.h> // to get wxGetWindowId
3842 #endif
3843
3844
3845 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3846 #ifdef __WXMSW__
3847 WXHWND hWnd = (WXHWND)_hWnd;
3848 long id = wxGetWindowId(hWnd);
3849 wxWindow* win = new wxWindow;
3850 if (parent)
3851 parent->AddChild(win);
3852 win->SetEventHandler(win);
3853 win->SetHWND(hWnd);
3854 win->SetId(id);
3855 win->SubclassWin(hWnd);
3856 win->AdoptAttributesFromHWND();
3857 win->SetupColours();
3858 return win;
3859 #else
3860 wxPyRaiseNotImplemented();
3861 return NULL;
3862 #endif
3863 }
3864
3865
3866 PyObject* GetTopLevelWindows() {
3867 return wxPy_ConvertList(&wxTopLevelWindows);
3868 }
3869
3870
3871 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3872 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3873 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3874
3875 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3876
3877
3878 SWIGINTERNINLINE int
3879 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3880 {
3881 unsigned long v;
3882 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3883 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3884 return res;
3885 }
3886
3887 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3888 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3889 wxMenuItemList& list = self->GetMenuItems();
3890 return wxPy_ConvertList(&list);
3891 }
3892 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3893 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3894 static const wxString wxPyControlNameStr(wxControlNameStr);
3895 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3896 if (clientData) {
3897 wxPyClientData* data = new wxPyClientData(clientData);
3898 return self->Append(item, data);
3899 } else
3900 return self->Append(item);
3901 }
3902 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3903 if (clientData) {
3904 wxPyClientData* data = new wxPyClientData(clientData);
3905 return self->Insert(item, pos, data);
3906 } else
3907 return self->Insert(item, pos);
3908 }
3909 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3910 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3911 if (data) {
3912 Py_INCREF(data->m_obj);
3913 return data->m_obj;
3914 } else {
3915 Py_INCREF(Py_None);
3916 return Py_None;
3917 }
3918 }
3919 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3920 wxPyClientData* data = new wxPyClientData(clientData);
3921 self->SetClientObject(n, data);
3922 }
3923
3924
3925 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3926 wxPyUserData* data = NULL;
3927 if ( userData ) {
3928 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3929 data = new wxPyUserData(userData);
3930 wxPyEndBlockThreads(blocked);
3931 }
3932 return new wxSizerItem(window, proportion, flag, border, data);
3933 }
3934 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3935 wxPyUserData* data = NULL;
3936 if ( userData ) {
3937 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3938 data = new wxPyUserData(userData);
3939 wxPyEndBlockThreads(blocked);
3940 }
3941 return new wxSizerItem(width, height, proportion, flag, border, data);
3942 }
3943 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3944 wxPyUserData* data = NULL;
3945 if ( userData ) {
3946 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3947 data = new wxPyUserData(userData);
3948 wxPyEndBlockThreads(blocked);
3949 }
3950 return new wxSizerItem(sizer, proportion, flag, border, data);
3951 }
3952
3953 #include <float.h>
3954
3955
3956 SWIGINTERN int
3957 SWIG_AsVal_float (PyObject * obj, float *val)
3958 {
3959 double v;
3960 int res = SWIG_AsVal_double (obj, &v);
3961 if (SWIG_IsOK(res)) {
3962 if ((v < -FLT_MAX || v > FLT_MAX)) {
3963 return SWIG_OverflowError;
3964 } else {
3965 if (val) *val = static_cast< float >(v);
3966 }
3967 }
3968 return res;
3969 }
3970
3971
3972 SWIGINTERNINLINE PyObject *
3973 SWIG_From_float (float value)
3974 {
3975 return SWIG_From_double (value);
3976 }
3977
3978 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3979 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3980 if (data) {
3981 Py_INCREF(data->m_obj);
3982 return data->m_obj;
3983 } else {
3984 Py_INCREF(Py_None);
3985 return Py_None;
3986 }
3987 }
3988 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3989 wxPyUserData* data = NULL;
3990 if ( userData ) {
3991 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3992 data = new wxPyUserData(userData);
3993 wxPyEndBlockThreads(blocked);
3994 }
3995 self->SetUserData(data);
3996 }
3997
3998 // Figure out the type of the sizer item
3999
4000 struct wxPySizerItemInfo {
4001 wxPySizerItemInfo()
4002 : window(NULL), sizer(NULL), gotSize(false),
4003 size(wxDefaultSize), gotPos(false), pos(-1)
4004 {}
4005
4006 wxWindow* window;
4007 wxSizer* sizer;
4008 bool gotSize;
4009 wxSize size;
4010 bool gotPos;
4011 int pos;
4012 };
4013
4014 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4015
4016 wxPySizerItemInfo info;
4017 wxSize size;
4018 wxSize* sizePtr = &size;
4019
4020 // Find out what the type of the item is
4021 // try wxWindow
4022 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4023 PyErr_Clear();
4024 info.window = NULL;
4025
4026 // try wxSizer
4027 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4028 PyErr_Clear();
4029 info.sizer = NULL;
4030
4031 // try wxSize or (w,h)
4032 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4033 info.size = *sizePtr;
4034 info.gotSize = true;
4035 }
4036
4037 // or a single int
4038 if (checkIdx && PyInt_Check(item)) {
4039 info.pos = PyInt_AsLong(item);
4040 info.gotPos = true;
4041 }
4042 }
4043 }
4044
4045 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4046 // no expected type, figure out what kind of error message to generate
4047 if ( !checkSize && !checkIdx )
4048 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4049 else if ( checkSize && !checkIdx )
4050 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4051 else if ( !checkSize && checkIdx)
4052 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4053 else
4054 // can this one happen?
4055 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4056 }
4057
4058 return info;
4059 }
4060
4061 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4062 if (!self->GetClientObject())
4063 self->SetClientObject(new wxPyOORClientData(_self));
4064 }
4065 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4066
4067 wxPyUserData* data = NULL;
4068 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4069 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4070 if ( userData && (info.window || info.sizer || info.gotSize) )
4071 data = new wxPyUserData(userData);
4072 if ( info.sizer )
4073 PyObject_SetAttrString(item,"thisown",Py_False);
4074 wxPyEndBlockThreads(blocked);
4075
4076 // Now call the real Add method if a valid item type was found
4077 if ( info.window )
4078 return self->Add(info.window, proportion, flag, border, data);
4079 else if ( info.sizer )
4080 return self->Add(info.sizer, proportion, flag, border, data);
4081 else if (info.gotSize)
4082 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4083 proportion, flag, border, data);
4084 else
4085 return NULL;
4086 }
4087 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4088
4089 wxPyUserData* data = NULL;
4090 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4091 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4092 if ( userData && (info.window || info.sizer || info.gotSize) )
4093 data = new wxPyUserData(userData);
4094 if ( info.sizer )
4095 PyObject_SetAttrString(item,"thisown",Py_False);
4096 wxPyEndBlockThreads(blocked);
4097
4098 // Now call the real Insert method if a valid item type was found
4099 if ( info.window )
4100 return self->Insert(before, info.window, proportion, flag, border, data);
4101 else if ( info.sizer )
4102 return self->Insert(before, info.sizer, proportion, flag, border, data);
4103 else if (info.gotSize)
4104 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4105 proportion, flag, border, data);
4106 else
4107 return NULL;
4108 }
4109 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4110
4111 wxPyUserData* data = NULL;
4112 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4113 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4114 if ( userData && (info.window || info.sizer || info.gotSize) )
4115 data = new wxPyUserData(userData);
4116 if ( info.sizer )
4117 PyObject_SetAttrString(item,"thisown",Py_False);
4118 wxPyEndBlockThreads(blocked);
4119
4120 // Now call the real Prepend method if a valid item type was found
4121 if ( info.window )
4122 return self->Prepend(info.window, proportion, flag, border, data);
4123 else if ( info.sizer )
4124 return self->Prepend(info.sizer, proportion, flag, border, data);
4125 else if (info.gotSize)
4126 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4127 proportion, flag, border, data);
4128 else
4129 return NULL;
4130 }
4131 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4132 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4133 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4134 wxPyEndBlockThreads(blocked);
4135 if ( info.window )
4136 return self->Remove(info.window);
4137 else if ( info.sizer )
4138 return self->Remove(info.sizer);
4139 else if ( info.gotPos )
4140 return self->Remove(info.pos);
4141 else
4142 return false;
4143 }
4144 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4145 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4146 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4147 wxPyEndBlockThreads(blocked);
4148 if ( info.window )
4149 return self->Detach(info.window);
4150 else if ( info.sizer )
4151 return self->Detach(info.sizer);
4152 else if ( info.gotPos )
4153 return self->Detach(info.pos);
4154 else
4155 return false;
4156 }
4157 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4158 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4159 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4160 wxPyEndBlockThreads(blocked);
4161 if ( info.window )
4162 return self->GetItem(info.window);
4163 else if ( info.sizer )
4164 return self->GetItem(info.sizer);
4165 else if ( info.gotPos )
4166 return self->GetItem(info.pos);
4167 else
4168 return NULL;
4169 }
4170 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4171 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4172 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4173 wxPyEndBlockThreads(blocked);
4174 if ( info.window )
4175 self->SetItemMinSize(info.window, size);
4176 else if ( info.sizer )
4177 self->SetItemMinSize(info.sizer, size);
4178 else if ( info.gotPos )
4179 self->SetItemMinSize(info.pos, size);
4180 }
4181 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4182 wxSizerItemList& list = self->GetChildren();
4183 return wxPy_ConvertList(&list);
4184 }
4185 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4187 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4188 wxPyEndBlockThreads(blocked);
4189 if ( info.window )
4190 return self->Show(info.window, show, recursive);
4191 else if ( info.sizer )
4192 return self->Show(info.sizer, show, recursive);
4193 else if ( info.gotPos )
4194 return self->Show(info.pos, show);
4195 else
4196 return false;
4197 }
4198 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4199 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4200 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4201 wxPyEndBlockThreads(blocked);
4202 if ( info.window )
4203 return self->IsShown(info.window);
4204 else if ( info.sizer )
4205 return self->IsShown(info.sizer);
4206 else if ( info.gotPos )
4207 return self->IsShown(info.pos);
4208 else
4209 return false;
4210 }
4211
4212 // See pyclasses.h
4213 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4214 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4215 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4216
4217
4218
4219
4220 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4221 {
4222 if (source == Py_None) {
4223 **obj = wxGBPosition(-1,-1);
4224 return true;
4225 }
4226 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4227 }
4228
4229 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4230 {
4231 if (source == Py_None) {
4232 **obj = wxGBSpan(-1,-1);
4233 return true;
4234 }
4235 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4236 }
4237
4238
4239 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4240 wxGBPosition temp, *obj = &temp;
4241 if ( other == Py_None ) return false;
4242 if ( ! wxGBPosition_helper(other, &obj) ) {
4243 PyErr_Clear();
4244 return false;
4245 }
4246 return self->operator==(*obj);
4247 }
4248 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4249 wxGBPosition temp, *obj = &temp;
4250 if ( other == Py_None ) return true;
4251 if ( ! wxGBPosition_helper(other, &obj)) {
4252 PyErr_Clear();
4253 return true;
4254 }
4255 return self->operator!=(*obj);
4256 }
4257 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4258 self->SetRow(row);
4259 self->SetCol(col);
4260 }
4261 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4262 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4263 PyObject* tup = PyTuple_New(2);
4264 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4265 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4266 wxPyEndBlockThreads(blocked);
4267 return tup;
4268 }
4269 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4270 wxGBSpan temp, *obj = &temp;
4271 if ( other == Py_None ) return false;
4272 if ( ! wxGBSpan_helper(other, &obj) ) {
4273 PyErr_Clear();
4274 return false;
4275 }
4276 return self->operator==(*obj);
4277 }
4278 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4279 wxGBSpan temp, *obj = &temp;
4280 if ( other == Py_None ) return true;
4281 if ( ! wxGBSpan_helper(other, &obj)) {
4282 PyErr_Clear();
4283 return true;
4284 }
4285 return self->operator!=(*obj);
4286 }
4287 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4288 self->SetRowspan(rowspan);
4289 self->SetColspan(colspan);
4290 }
4291 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4292 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4293 PyObject* tup = PyTuple_New(2);
4294 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4295 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4296 wxPyEndBlockThreads(blocked);
4297 return tup;
4298 }
4299 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4300 wxPyUserData* data = NULL;
4301 if ( userData ) {
4302 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4303 data = new wxPyUserData(userData);
4304 wxPyEndBlockThreads(blocked);
4305 }
4306 return new wxGBSizerItem(window, pos, span, flag, border, data);
4307 }
4308 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4309 wxPyUserData* data = NULL;
4310 if ( userData ) {
4311 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4312 data = new wxPyUserData(userData);
4313 wxPyEndBlockThreads(blocked);
4314 }
4315 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4316 }
4317 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4318 wxPyUserData* data = NULL;
4319 if ( userData ) {
4320 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4321 data = new wxPyUserData(userData);
4322 wxPyEndBlockThreads(blocked);
4323 }
4324 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4325 }
4326 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4327 int row, col;
4328 self->GetEndPos(row, col);
4329 return wxGBPosition(row, col);
4330 }
4331 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4332
4333 wxPyUserData* data = NULL;
4334 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4335 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4336 if ( userData && (info.window || info.sizer || info.gotSize) )
4337 data = new wxPyUserData(userData);
4338 if ( info.sizer )
4339 PyObject_SetAttrString(item,"thisown",Py_False);
4340 wxPyEndBlockThreads(blocked);
4341
4342 // Now call the real Add method if a valid item type was found
4343 if ( info.window )
4344 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4345 else if ( info.sizer )
4346 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4347 else if (info.gotSize)
4348 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4349 pos, span, flag, border, data);
4350 return NULL;
4351 }
4352
4353
4354 #ifdef __cplusplus
4355 extern "C" {
4356 #endif
4357 SWIGINTERN int EmptyString_set(PyObject *) {
4358 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4359 return 1;
4360 }
4361
4362
4363 SWIGINTERN PyObject *EmptyString_get(void) {
4364 PyObject *pyobj = 0;
4365
4366 {
4367 #if wxUSE_UNICODE
4368 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4369 #else
4370 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4371 #endif
4372 }
4373 return pyobj;
4374 }
4375
4376
4377 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4378 PyObject *resultobj = 0;
4379 wxObject *arg1 = (wxObject *) 0 ;
4380 wxString result;
4381 void *argp1 = 0 ;
4382 int res1 = 0 ;
4383 PyObject *swig_obj[1] ;
4384
4385 if (!args) SWIG_fail;
4386 swig_obj[0] = args;
4387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4388 if (!SWIG_IsOK(res1)) {
4389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4390 }
4391 arg1 = reinterpret_cast< wxObject * >(argp1);
4392 {
4393 PyThreadState* __tstate = wxPyBeginAllowThreads();
4394 result = wxObject_GetClassName(arg1);
4395 wxPyEndAllowThreads(__tstate);
4396 if (PyErr_Occurred()) SWIG_fail;
4397 }
4398 {
4399 #if wxUSE_UNICODE
4400 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4401 #else
4402 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4403 #endif
4404 }
4405 return resultobj;
4406 fail:
4407 return NULL;
4408 }
4409
4410
4411 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4412 PyObject *resultobj = 0;
4413 wxObject *arg1 = (wxObject *) 0 ;
4414 void *argp1 = 0 ;
4415 int res1 = 0 ;
4416 PyObject *swig_obj[1] ;
4417
4418 if (!args) SWIG_fail;
4419 swig_obj[0] = args;
4420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4421 if (!SWIG_IsOK(res1)) {
4422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4423 }
4424 arg1 = reinterpret_cast< wxObject * >(argp1);
4425 {
4426 PyThreadState* __tstate = wxPyBeginAllowThreads();
4427 wxObject_Destroy(arg1);
4428 wxPyEndAllowThreads(__tstate);
4429 if (PyErr_Occurred()) SWIG_fail;
4430 }
4431 resultobj = SWIG_Py_Void();
4432 return resultobj;
4433 fail:
4434 return NULL;
4435 }
4436
4437
4438 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4439 PyObject *obj;
4440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4441 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4442 return SWIG_Py_Void();
4443 }
4444
4445 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4446 PyObject *resultobj = 0;
4447 wxSize *arg1 = (wxSize *) 0 ;
4448 int arg2 ;
4449 void *argp1 = 0 ;
4450 int res1 = 0 ;
4451 int val2 ;
4452 int ecode2 = 0 ;
4453 PyObject *swig_obj[2] ;
4454
4455 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4457 if (!SWIG_IsOK(res1)) {
4458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4459 }
4460 arg1 = reinterpret_cast< wxSize * >(argp1);
4461 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4462 if (!SWIG_IsOK(ecode2)) {
4463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4464 }
4465 arg2 = static_cast< int >(val2);
4466 if (arg1) (arg1)->x = arg2;
4467
4468 resultobj = SWIG_Py_Void();
4469 return resultobj;
4470 fail:
4471 return NULL;
4472 }
4473
4474
4475 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4476 PyObject *resultobj = 0;
4477 wxSize *arg1 = (wxSize *) 0 ;
4478 int result;
4479 void *argp1 = 0 ;
4480 int res1 = 0 ;
4481 PyObject *swig_obj[1] ;
4482
4483 if (!args) SWIG_fail;
4484 swig_obj[0] = args;
4485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4486 if (!SWIG_IsOK(res1)) {
4487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4488 }
4489 arg1 = reinterpret_cast< wxSize * >(argp1);
4490 result = (int) ((arg1)->x);
4491 resultobj = SWIG_From_int(static_cast< int >(result));
4492 return resultobj;
4493 fail:
4494 return NULL;
4495 }
4496
4497
4498 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4499 PyObject *resultobj = 0;
4500 wxSize *arg1 = (wxSize *) 0 ;
4501 int arg2 ;
4502 void *argp1 = 0 ;
4503 int res1 = 0 ;
4504 int val2 ;
4505 int ecode2 = 0 ;
4506 PyObject *swig_obj[2] ;
4507
4508 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4510 if (!SWIG_IsOK(res1)) {
4511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4512 }
4513 arg1 = reinterpret_cast< wxSize * >(argp1);
4514 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4515 if (!SWIG_IsOK(ecode2)) {
4516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4517 }
4518 arg2 = static_cast< int >(val2);
4519 if (arg1) (arg1)->y = arg2;
4520
4521 resultobj = SWIG_Py_Void();
4522 return resultobj;
4523 fail:
4524 return NULL;
4525 }
4526
4527
4528 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4529 PyObject *resultobj = 0;
4530 wxSize *arg1 = (wxSize *) 0 ;
4531 int result;
4532 void *argp1 = 0 ;
4533 int res1 = 0 ;
4534 PyObject *swig_obj[1] ;
4535
4536 if (!args) SWIG_fail;
4537 swig_obj[0] = args;
4538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4539 if (!SWIG_IsOK(res1)) {
4540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4541 }
4542 arg1 = reinterpret_cast< wxSize * >(argp1);
4543 result = (int) ((arg1)->y);
4544 resultobj = SWIG_From_int(static_cast< int >(result));
4545 return resultobj;
4546 fail:
4547 return NULL;
4548 }
4549
4550
4551 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4552 PyObject *resultobj = 0;
4553 int arg1 = (int) 0 ;
4554 int arg2 = (int) 0 ;
4555 wxSize *result = 0 ;
4556 int val1 ;
4557 int ecode1 = 0 ;
4558 int val2 ;
4559 int ecode2 = 0 ;
4560 PyObject * obj0 = 0 ;
4561 PyObject * obj1 = 0 ;
4562 char * kwnames[] = {
4563 (char *) "w",(char *) "h", NULL
4564 };
4565
4566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4567 if (obj0) {
4568 ecode1 = SWIG_AsVal_int(obj0, &val1);
4569 if (!SWIG_IsOK(ecode1)) {
4570 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4571 }
4572 arg1 = static_cast< int >(val1);
4573 }
4574 if (obj1) {
4575 ecode2 = SWIG_AsVal_int(obj1, &val2);
4576 if (!SWIG_IsOK(ecode2)) {
4577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4578 }
4579 arg2 = static_cast< int >(val2);
4580 }
4581 {
4582 PyThreadState* __tstate = wxPyBeginAllowThreads();
4583 result = (wxSize *)new wxSize(arg1,arg2);
4584 wxPyEndAllowThreads(__tstate);
4585 if (PyErr_Occurred()) SWIG_fail;
4586 }
4587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4588 return resultobj;
4589 fail:
4590 return NULL;
4591 }
4592
4593
4594 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4595 PyObject *resultobj = 0;
4596 wxSize *arg1 = (wxSize *) 0 ;
4597 void *argp1 = 0 ;
4598 int res1 = 0 ;
4599 PyObject *swig_obj[1] ;
4600
4601 if (!args) SWIG_fail;
4602 swig_obj[0] = args;
4603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4604 if (!SWIG_IsOK(res1)) {
4605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4606 }
4607 arg1 = reinterpret_cast< wxSize * >(argp1);
4608 {
4609 PyThreadState* __tstate = wxPyBeginAllowThreads();
4610 delete arg1;
4611
4612 wxPyEndAllowThreads(__tstate);
4613 if (PyErr_Occurred()) SWIG_fail;
4614 }
4615 resultobj = SWIG_Py_Void();
4616 return resultobj;
4617 fail:
4618 return NULL;
4619 }
4620
4621
4622 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4623 PyObject *resultobj = 0;
4624 wxSize *arg1 = (wxSize *) 0 ;
4625 PyObject *arg2 = (PyObject *) 0 ;
4626 bool result;
4627 void *argp1 = 0 ;
4628 int res1 = 0 ;
4629 PyObject * obj0 = 0 ;
4630 PyObject * obj1 = 0 ;
4631 char * kwnames[] = {
4632 (char *) "self",(char *) "other", NULL
4633 };
4634
4635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4637 if (!SWIG_IsOK(res1)) {
4638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4639 }
4640 arg1 = reinterpret_cast< wxSize * >(argp1);
4641 arg2 = obj1;
4642 {
4643 result = (bool)wxSize___eq__(arg1,arg2);
4644 if (PyErr_Occurred()) SWIG_fail;
4645 }
4646 {
4647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4648 }
4649 return resultobj;
4650 fail:
4651 return NULL;
4652 }
4653
4654
4655 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4656 PyObject *resultobj = 0;
4657 wxSize *arg1 = (wxSize *) 0 ;
4658 PyObject *arg2 = (PyObject *) 0 ;
4659 bool result;
4660 void *argp1 = 0 ;
4661 int res1 = 0 ;
4662 PyObject * obj0 = 0 ;
4663 PyObject * obj1 = 0 ;
4664 char * kwnames[] = {
4665 (char *) "self",(char *) "other", NULL
4666 };
4667
4668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4670 if (!SWIG_IsOK(res1)) {
4671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4672 }
4673 arg1 = reinterpret_cast< wxSize * >(argp1);
4674 arg2 = obj1;
4675 {
4676 result = (bool)wxSize___ne__(arg1,arg2);
4677 if (PyErr_Occurred()) SWIG_fail;
4678 }
4679 {
4680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4681 }
4682 return resultobj;
4683 fail:
4684 return NULL;
4685 }
4686
4687
4688 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4689 PyObject *resultobj = 0;
4690 wxSize *arg1 = (wxSize *) 0 ;
4691 wxSize *arg2 = 0 ;
4692 wxSize result;
4693 void *argp1 = 0 ;
4694 int res1 = 0 ;
4695 wxSize temp2 ;
4696 PyObject * obj0 = 0 ;
4697 PyObject * obj1 = 0 ;
4698 char * kwnames[] = {
4699 (char *) "self",(char *) "sz", NULL
4700 };
4701
4702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4704 if (!SWIG_IsOK(res1)) {
4705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4706 }
4707 arg1 = reinterpret_cast< wxSize * >(argp1);
4708 {
4709 arg2 = &temp2;
4710 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4711 }
4712 {
4713 PyThreadState* __tstate = wxPyBeginAllowThreads();
4714 result = (arg1)->operator +((wxSize const &)*arg2);
4715 wxPyEndAllowThreads(__tstate);
4716 if (PyErr_Occurred()) SWIG_fail;
4717 }
4718 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4719 return resultobj;
4720 fail:
4721 return NULL;
4722 }
4723
4724
4725 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4726 PyObject *resultobj = 0;
4727 wxSize *arg1 = (wxSize *) 0 ;
4728 wxSize *arg2 = 0 ;
4729 wxSize result;
4730 void *argp1 = 0 ;
4731 int res1 = 0 ;
4732 wxSize temp2 ;
4733 PyObject * obj0 = 0 ;
4734 PyObject * obj1 = 0 ;
4735 char * kwnames[] = {
4736 (char *) "self",(char *) "sz", NULL
4737 };
4738
4739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4741 if (!SWIG_IsOK(res1)) {
4742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4743 }
4744 arg1 = reinterpret_cast< wxSize * >(argp1);
4745 {
4746 arg2 = &temp2;
4747 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4748 }
4749 {
4750 PyThreadState* __tstate = wxPyBeginAllowThreads();
4751 result = (arg1)->operator -((wxSize const &)*arg2);
4752 wxPyEndAllowThreads(__tstate);
4753 if (PyErr_Occurred()) SWIG_fail;
4754 }
4755 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4756 return resultobj;
4757 fail:
4758 return NULL;
4759 }
4760
4761
4762 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4763 PyObject *resultobj = 0;
4764 wxSize *arg1 = (wxSize *) 0 ;
4765 wxSize *arg2 = 0 ;
4766 void *argp1 = 0 ;
4767 int res1 = 0 ;
4768 wxSize temp2 ;
4769 PyObject * obj0 = 0 ;
4770 PyObject * obj1 = 0 ;
4771 char * kwnames[] = {
4772 (char *) "self",(char *) "sz", NULL
4773 };
4774
4775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4777 if (!SWIG_IsOK(res1)) {
4778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4779 }
4780 arg1 = reinterpret_cast< wxSize * >(argp1);
4781 {
4782 arg2 = &temp2;
4783 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4784 }
4785 {
4786 PyThreadState* __tstate = wxPyBeginAllowThreads();
4787 (arg1)->IncTo((wxSize const &)*arg2);
4788 wxPyEndAllowThreads(__tstate);
4789 if (PyErr_Occurred()) SWIG_fail;
4790 }
4791 resultobj = SWIG_Py_Void();
4792 return resultobj;
4793 fail:
4794 return NULL;
4795 }
4796
4797
4798 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4799 PyObject *resultobj = 0;
4800 wxSize *arg1 = (wxSize *) 0 ;
4801 wxSize *arg2 = 0 ;
4802 void *argp1 = 0 ;
4803 int res1 = 0 ;
4804 wxSize temp2 ;
4805 PyObject * obj0 = 0 ;
4806 PyObject * obj1 = 0 ;
4807 char * kwnames[] = {
4808 (char *) "self",(char *) "sz", NULL
4809 };
4810
4811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4813 if (!SWIG_IsOK(res1)) {
4814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4815 }
4816 arg1 = reinterpret_cast< wxSize * >(argp1);
4817 {
4818 arg2 = &temp2;
4819 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4820 }
4821 {
4822 PyThreadState* __tstate = wxPyBeginAllowThreads();
4823 (arg1)->DecTo((wxSize const &)*arg2);
4824 wxPyEndAllowThreads(__tstate);
4825 if (PyErr_Occurred()) SWIG_fail;
4826 }
4827 resultobj = SWIG_Py_Void();
4828 return resultobj;
4829 fail:
4830 return NULL;
4831 }
4832
4833
4834 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4835 PyObject *resultobj = 0;
4836 wxSize *arg1 = (wxSize *) 0 ;
4837 int arg2 ;
4838 int arg3 ;
4839 void *argp1 = 0 ;
4840 int res1 = 0 ;
4841 int val2 ;
4842 int ecode2 = 0 ;
4843 int val3 ;
4844 int ecode3 = 0 ;
4845 PyObject * obj0 = 0 ;
4846 PyObject * obj1 = 0 ;
4847 PyObject * obj2 = 0 ;
4848 char * kwnames[] = {
4849 (char *) "self",(char *) "w",(char *) "h", NULL
4850 };
4851
4852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4854 if (!SWIG_IsOK(res1)) {
4855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4856 }
4857 arg1 = reinterpret_cast< wxSize * >(argp1);
4858 ecode2 = SWIG_AsVal_int(obj1, &val2);
4859 if (!SWIG_IsOK(ecode2)) {
4860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4861 }
4862 arg2 = static_cast< int >(val2);
4863 ecode3 = SWIG_AsVal_int(obj2, &val3);
4864 if (!SWIG_IsOK(ecode3)) {
4865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4866 }
4867 arg3 = static_cast< int >(val3);
4868 {
4869 PyThreadState* __tstate = wxPyBeginAllowThreads();
4870 (arg1)->Set(arg2,arg3);
4871 wxPyEndAllowThreads(__tstate);
4872 if (PyErr_Occurred()) SWIG_fail;
4873 }
4874 resultobj = SWIG_Py_Void();
4875 return resultobj;
4876 fail:
4877 return NULL;
4878 }
4879
4880
4881 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4882 PyObject *resultobj = 0;
4883 wxSize *arg1 = (wxSize *) 0 ;
4884 int arg2 ;
4885 void *argp1 = 0 ;
4886 int res1 = 0 ;
4887 int val2 ;
4888 int ecode2 = 0 ;
4889 PyObject * obj0 = 0 ;
4890 PyObject * obj1 = 0 ;
4891 char * kwnames[] = {
4892 (char *) "self",(char *) "w", NULL
4893 };
4894
4895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4897 if (!SWIG_IsOK(res1)) {
4898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4899 }
4900 arg1 = reinterpret_cast< wxSize * >(argp1);
4901 ecode2 = SWIG_AsVal_int(obj1, &val2);
4902 if (!SWIG_IsOK(ecode2)) {
4903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4904 }
4905 arg2 = static_cast< int >(val2);
4906 {
4907 PyThreadState* __tstate = wxPyBeginAllowThreads();
4908 (arg1)->SetWidth(arg2);
4909 wxPyEndAllowThreads(__tstate);
4910 if (PyErr_Occurred()) SWIG_fail;
4911 }
4912 resultobj = SWIG_Py_Void();
4913 return resultobj;
4914 fail:
4915 return NULL;
4916 }
4917
4918
4919 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4920 PyObject *resultobj = 0;
4921 wxSize *arg1 = (wxSize *) 0 ;
4922 int arg2 ;
4923 void *argp1 = 0 ;
4924 int res1 = 0 ;
4925 int val2 ;
4926 int ecode2 = 0 ;
4927 PyObject * obj0 = 0 ;
4928 PyObject * obj1 = 0 ;
4929 char * kwnames[] = {
4930 (char *) "self",(char *) "h", NULL
4931 };
4932
4933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4935 if (!SWIG_IsOK(res1)) {
4936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4937 }
4938 arg1 = reinterpret_cast< wxSize * >(argp1);
4939 ecode2 = SWIG_AsVal_int(obj1, &val2);
4940 if (!SWIG_IsOK(ecode2)) {
4941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4942 }
4943 arg2 = static_cast< int >(val2);
4944 {
4945 PyThreadState* __tstate = wxPyBeginAllowThreads();
4946 (arg1)->SetHeight(arg2);
4947 wxPyEndAllowThreads(__tstate);
4948 if (PyErr_Occurred()) SWIG_fail;
4949 }
4950 resultobj = SWIG_Py_Void();
4951 return resultobj;
4952 fail:
4953 return NULL;
4954 }
4955
4956
4957 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4958 PyObject *resultobj = 0;
4959 wxSize *arg1 = (wxSize *) 0 ;
4960 int result;
4961 void *argp1 = 0 ;
4962 int res1 = 0 ;
4963 PyObject *swig_obj[1] ;
4964
4965 if (!args) SWIG_fail;
4966 swig_obj[0] = args;
4967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4968 if (!SWIG_IsOK(res1)) {
4969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4970 }
4971 arg1 = reinterpret_cast< wxSize * >(argp1);
4972 {
4973 PyThreadState* __tstate = wxPyBeginAllowThreads();
4974 result = (int)((wxSize const *)arg1)->GetWidth();
4975 wxPyEndAllowThreads(__tstate);
4976 if (PyErr_Occurred()) SWIG_fail;
4977 }
4978 resultobj = SWIG_From_int(static_cast< int >(result));
4979 return resultobj;
4980 fail:
4981 return NULL;
4982 }
4983
4984
4985 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4986 PyObject *resultobj = 0;
4987 wxSize *arg1 = (wxSize *) 0 ;
4988 int result;
4989 void *argp1 = 0 ;
4990 int res1 = 0 ;
4991 PyObject *swig_obj[1] ;
4992
4993 if (!args) SWIG_fail;
4994 swig_obj[0] = args;
4995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4996 if (!SWIG_IsOK(res1)) {
4997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
4998 }
4999 arg1 = reinterpret_cast< wxSize * >(argp1);
5000 {
5001 PyThreadState* __tstate = wxPyBeginAllowThreads();
5002 result = (int)((wxSize const *)arg1)->GetHeight();
5003 wxPyEndAllowThreads(__tstate);
5004 if (PyErr_Occurred()) SWIG_fail;
5005 }
5006 resultobj = SWIG_From_int(static_cast< int >(result));
5007 return resultobj;
5008 fail:
5009 return NULL;
5010 }
5011
5012
5013 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5014 PyObject *resultobj = 0;
5015 wxSize *arg1 = (wxSize *) 0 ;
5016 bool result;
5017 void *argp1 = 0 ;
5018 int res1 = 0 ;
5019 PyObject *swig_obj[1] ;
5020
5021 if (!args) SWIG_fail;
5022 swig_obj[0] = args;
5023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5024 if (!SWIG_IsOK(res1)) {
5025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5026 }
5027 arg1 = reinterpret_cast< wxSize * >(argp1);
5028 {
5029 PyThreadState* __tstate = wxPyBeginAllowThreads();
5030 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5031 wxPyEndAllowThreads(__tstate);
5032 if (PyErr_Occurred()) SWIG_fail;
5033 }
5034 {
5035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5036 }
5037 return resultobj;
5038 fail:
5039 return NULL;
5040 }
5041
5042
5043 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5044 PyObject *resultobj = 0;
5045 wxSize *arg1 = (wxSize *) 0 ;
5046 wxSize *arg2 = 0 ;
5047 void *argp1 = 0 ;
5048 int res1 = 0 ;
5049 wxSize temp2 ;
5050 PyObject * obj0 = 0 ;
5051 PyObject * obj1 = 0 ;
5052 char * kwnames[] = {
5053 (char *) "self",(char *) "size", NULL
5054 };
5055
5056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5058 if (!SWIG_IsOK(res1)) {
5059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5060 }
5061 arg1 = reinterpret_cast< wxSize * >(argp1);
5062 {
5063 arg2 = &temp2;
5064 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5065 }
5066 {
5067 PyThreadState* __tstate = wxPyBeginAllowThreads();
5068 (arg1)->SetDefaults((wxSize const &)*arg2);
5069 wxPyEndAllowThreads(__tstate);
5070 if (PyErr_Occurred()) SWIG_fail;
5071 }
5072 resultobj = SWIG_Py_Void();
5073 return resultobj;
5074 fail:
5075 return NULL;
5076 }
5077
5078
5079 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5080 PyObject *resultobj = 0;
5081 wxSize *arg1 = (wxSize *) 0 ;
5082 PyObject *result = 0 ;
5083 void *argp1 = 0 ;
5084 int res1 = 0 ;
5085 PyObject *swig_obj[1] ;
5086
5087 if (!args) SWIG_fail;
5088 swig_obj[0] = args;
5089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5090 if (!SWIG_IsOK(res1)) {
5091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5092 }
5093 arg1 = reinterpret_cast< wxSize * >(argp1);
5094 {
5095 PyThreadState* __tstate = wxPyBeginAllowThreads();
5096 result = (PyObject *)wxSize_Get(arg1);
5097 wxPyEndAllowThreads(__tstate);
5098 if (PyErr_Occurred()) SWIG_fail;
5099 }
5100 resultobj = result;
5101 return resultobj;
5102 fail:
5103 return NULL;
5104 }
5105
5106
5107 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5108 PyObject *obj;
5109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5110 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5111 return SWIG_Py_Void();
5112 }
5113
5114 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5115 return SWIG_Python_InitShadowInstance(args);
5116 }
5117
5118 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5119 PyObject *resultobj = 0;
5120 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5121 double arg2 ;
5122 void *argp1 = 0 ;
5123 int res1 = 0 ;
5124 double val2 ;
5125 int ecode2 = 0 ;
5126 PyObject *swig_obj[2] ;
5127
5128 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5130 if (!SWIG_IsOK(res1)) {
5131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5132 }
5133 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5134 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5135 if (!SWIG_IsOK(ecode2)) {
5136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5137 }
5138 arg2 = static_cast< double >(val2);
5139 if (arg1) (arg1)->x = arg2;
5140
5141 resultobj = SWIG_Py_Void();
5142 return resultobj;
5143 fail:
5144 return NULL;
5145 }
5146
5147
5148 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5149 PyObject *resultobj = 0;
5150 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5151 double result;
5152 void *argp1 = 0 ;
5153 int res1 = 0 ;
5154 PyObject *swig_obj[1] ;
5155
5156 if (!args) SWIG_fail;
5157 swig_obj[0] = args;
5158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5159 if (!SWIG_IsOK(res1)) {
5160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5161 }
5162 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5163 result = (double) ((arg1)->x);
5164 resultobj = SWIG_From_double(static_cast< double >(result));
5165 return resultobj;
5166 fail:
5167 return NULL;
5168 }
5169
5170
5171 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5172 PyObject *resultobj = 0;
5173 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5174 double arg2 ;
5175 void *argp1 = 0 ;
5176 int res1 = 0 ;
5177 double val2 ;
5178 int ecode2 = 0 ;
5179 PyObject *swig_obj[2] ;
5180
5181 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5183 if (!SWIG_IsOK(res1)) {
5184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5185 }
5186 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5187 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5188 if (!SWIG_IsOK(ecode2)) {
5189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5190 }
5191 arg2 = static_cast< double >(val2);
5192 if (arg1) (arg1)->y = arg2;
5193
5194 resultobj = SWIG_Py_Void();
5195 return resultobj;
5196 fail:
5197 return NULL;
5198 }
5199
5200
5201 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5202 PyObject *resultobj = 0;
5203 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5204 double result;
5205 void *argp1 = 0 ;
5206 int res1 = 0 ;
5207 PyObject *swig_obj[1] ;
5208
5209 if (!args) SWIG_fail;
5210 swig_obj[0] = args;
5211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5212 if (!SWIG_IsOK(res1)) {
5213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5214 }
5215 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5216 result = (double) ((arg1)->y);
5217 resultobj = SWIG_From_double(static_cast< double >(result));
5218 return resultobj;
5219 fail:
5220 return NULL;
5221 }
5222
5223
5224 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5225 PyObject *resultobj = 0;
5226 double arg1 = (double) 0.0 ;
5227 double arg2 = (double) 0.0 ;
5228 wxRealPoint *result = 0 ;
5229 double val1 ;
5230 int ecode1 = 0 ;
5231 double val2 ;
5232 int ecode2 = 0 ;
5233 PyObject * obj0 = 0 ;
5234 PyObject * obj1 = 0 ;
5235 char * kwnames[] = {
5236 (char *) "x",(char *) "y", NULL
5237 };
5238
5239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5240 if (obj0) {
5241 ecode1 = SWIG_AsVal_double(obj0, &val1);
5242 if (!SWIG_IsOK(ecode1)) {
5243 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5244 }
5245 arg1 = static_cast< double >(val1);
5246 }
5247 if (obj1) {
5248 ecode2 = SWIG_AsVal_double(obj1, &val2);
5249 if (!SWIG_IsOK(ecode2)) {
5250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5251 }
5252 arg2 = static_cast< double >(val2);
5253 }
5254 {
5255 PyThreadState* __tstate = wxPyBeginAllowThreads();
5256 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5257 wxPyEndAllowThreads(__tstate);
5258 if (PyErr_Occurred()) SWIG_fail;
5259 }
5260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5261 return resultobj;
5262 fail:
5263 return NULL;
5264 }
5265
5266
5267 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5268 PyObject *resultobj = 0;
5269 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5270 void *argp1 = 0 ;
5271 int res1 = 0 ;
5272 PyObject *swig_obj[1] ;
5273
5274 if (!args) SWIG_fail;
5275 swig_obj[0] = args;
5276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5277 if (!SWIG_IsOK(res1)) {
5278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5279 }
5280 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5281 {
5282 PyThreadState* __tstate = wxPyBeginAllowThreads();
5283 delete arg1;
5284
5285 wxPyEndAllowThreads(__tstate);
5286 if (PyErr_Occurred()) SWIG_fail;
5287 }
5288 resultobj = SWIG_Py_Void();
5289 return resultobj;
5290 fail:
5291 return NULL;
5292 }
5293
5294
5295 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5296 PyObject *resultobj = 0;
5297 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5298 PyObject *arg2 = (PyObject *) 0 ;
5299 bool result;
5300 void *argp1 = 0 ;
5301 int res1 = 0 ;
5302 PyObject * obj0 = 0 ;
5303 PyObject * obj1 = 0 ;
5304 char * kwnames[] = {
5305 (char *) "self",(char *) "other", NULL
5306 };
5307
5308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5310 if (!SWIG_IsOK(res1)) {
5311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5312 }
5313 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5314 arg2 = obj1;
5315 {
5316 result = (bool)wxRealPoint___eq__(arg1,arg2);
5317 if (PyErr_Occurred()) SWIG_fail;
5318 }
5319 {
5320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5321 }
5322 return resultobj;
5323 fail:
5324 return NULL;
5325 }
5326
5327
5328 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5329 PyObject *resultobj = 0;
5330 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5331 PyObject *arg2 = (PyObject *) 0 ;
5332 bool result;
5333 void *argp1 = 0 ;
5334 int res1 = 0 ;
5335 PyObject * obj0 = 0 ;
5336 PyObject * obj1 = 0 ;
5337 char * kwnames[] = {
5338 (char *) "self",(char *) "other", NULL
5339 };
5340
5341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5343 if (!SWIG_IsOK(res1)) {
5344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5345 }
5346 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5347 arg2 = obj1;
5348 {
5349 result = (bool)wxRealPoint___ne__(arg1,arg2);
5350 if (PyErr_Occurred()) SWIG_fail;
5351 }
5352 {
5353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5354 }
5355 return resultobj;
5356 fail:
5357 return NULL;
5358 }
5359
5360
5361 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5362 PyObject *resultobj = 0;
5363 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5364 wxRealPoint *arg2 = 0 ;
5365 wxRealPoint result;
5366 void *argp1 = 0 ;
5367 int res1 = 0 ;
5368 wxRealPoint temp2 ;
5369 PyObject * obj0 = 0 ;
5370 PyObject * obj1 = 0 ;
5371 char * kwnames[] = {
5372 (char *) "self",(char *) "pt", NULL
5373 };
5374
5375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5377 if (!SWIG_IsOK(res1)) {
5378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5379 }
5380 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5381 {
5382 arg2 = &temp2;
5383 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5384 }
5385 {
5386 PyThreadState* __tstate = wxPyBeginAllowThreads();
5387 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5388 wxPyEndAllowThreads(__tstate);
5389 if (PyErr_Occurred()) SWIG_fail;
5390 }
5391 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5392 return resultobj;
5393 fail:
5394 return NULL;
5395 }
5396
5397
5398 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5399 PyObject *resultobj = 0;
5400 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5401 wxRealPoint *arg2 = 0 ;
5402 wxRealPoint result;
5403 void *argp1 = 0 ;
5404 int res1 = 0 ;
5405 wxRealPoint temp2 ;
5406 PyObject * obj0 = 0 ;
5407 PyObject * obj1 = 0 ;
5408 char * kwnames[] = {
5409 (char *) "self",(char *) "pt", NULL
5410 };
5411
5412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5414 if (!SWIG_IsOK(res1)) {
5415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5416 }
5417 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5418 {
5419 arg2 = &temp2;
5420 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5421 }
5422 {
5423 PyThreadState* __tstate = wxPyBeginAllowThreads();
5424 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5425 wxPyEndAllowThreads(__tstate);
5426 if (PyErr_Occurred()) SWIG_fail;
5427 }
5428 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5429 return resultobj;
5430 fail:
5431 return NULL;
5432 }
5433
5434
5435 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5436 PyObject *resultobj = 0;
5437 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5438 double arg2 ;
5439 double arg3 ;
5440 void *argp1 = 0 ;
5441 int res1 = 0 ;
5442 double val2 ;
5443 int ecode2 = 0 ;
5444 double val3 ;
5445 int ecode3 = 0 ;
5446 PyObject * obj0 = 0 ;
5447 PyObject * obj1 = 0 ;
5448 PyObject * obj2 = 0 ;
5449 char * kwnames[] = {
5450 (char *) "self",(char *) "x",(char *) "y", NULL
5451 };
5452
5453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5455 if (!SWIG_IsOK(res1)) {
5456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5457 }
5458 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5459 ecode2 = SWIG_AsVal_double(obj1, &val2);
5460 if (!SWIG_IsOK(ecode2)) {
5461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5462 }
5463 arg2 = static_cast< double >(val2);
5464 ecode3 = SWIG_AsVal_double(obj2, &val3);
5465 if (!SWIG_IsOK(ecode3)) {
5466 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5467 }
5468 arg3 = static_cast< double >(val3);
5469 {
5470 PyThreadState* __tstate = wxPyBeginAllowThreads();
5471 wxRealPoint_Set(arg1,arg2,arg3);
5472 wxPyEndAllowThreads(__tstate);
5473 if (PyErr_Occurred()) SWIG_fail;
5474 }
5475 resultobj = SWIG_Py_Void();
5476 return resultobj;
5477 fail:
5478 return NULL;
5479 }
5480
5481
5482 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5483 PyObject *resultobj = 0;
5484 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5485 PyObject *result = 0 ;
5486 void *argp1 = 0 ;
5487 int res1 = 0 ;
5488 PyObject *swig_obj[1] ;
5489
5490 if (!args) SWIG_fail;
5491 swig_obj[0] = args;
5492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5493 if (!SWIG_IsOK(res1)) {
5494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5495 }
5496 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5497 {
5498 PyThreadState* __tstate = wxPyBeginAllowThreads();
5499 result = (PyObject *)wxRealPoint_Get(arg1);
5500 wxPyEndAllowThreads(__tstate);
5501 if (PyErr_Occurred()) SWIG_fail;
5502 }
5503 resultobj = result;
5504 return resultobj;
5505 fail:
5506 return NULL;
5507 }
5508
5509
5510 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5511 PyObject *obj;
5512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5513 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5514 return SWIG_Py_Void();
5515 }
5516
5517 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5518 return SWIG_Python_InitShadowInstance(args);
5519 }
5520
5521 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5522 PyObject *resultobj = 0;
5523 wxPoint *arg1 = (wxPoint *) 0 ;
5524 int arg2 ;
5525 void *argp1 = 0 ;
5526 int res1 = 0 ;
5527 int val2 ;
5528 int ecode2 = 0 ;
5529 PyObject *swig_obj[2] ;
5530
5531 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5533 if (!SWIG_IsOK(res1)) {
5534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5535 }
5536 arg1 = reinterpret_cast< wxPoint * >(argp1);
5537 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5538 if (!SWIG_IsOK(ecode2)) {
5539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5540 }
5541 arg2 = static_cast< int >(val2);
5542 if (arg1) (arg1)->x = arg2;
5543
5544 resultobj = SWIG_Py_Void();
5545 return resultobj;
5546 fail:
5547 return NULL;
5548 }
5549
5550
5551 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5552 PyObject *resultobj = 0;
5553 wxPoint *arg1 = (wxPoint *) 0 ;
5554 int result;
5555 void *argp1 = 0 ;
5556 int res1 = 0 ;
5557 PyObject *swig_obj[1] ;
5558
5559 if (!args) SWIG_fail;
5560 swig_obj[0] = args;
5561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5562 if (!SWIG_IsOK(res1)) {
5563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5564 }
5565 arg1 = reinterpret_cast< wxPoint * >(argp1);
5566 result = (int) ((arg1)->x);
5567 resultobj = SWIG_From_int(static_cast< int >(result));
5568 return resultobj;
5569 fail:
5570 return NULL;
5571 }
5572
5573
5574 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5575 PyObject *resultobj = 0;
5576 wxPoint *arg1 = (wxPoint *) 0 ;
5577 int arg2 ;
5578 void *argp1 = 0 ;
5579 int res1 = 0 ;
5580 int val2 ;
5581 int ecode2 = 0 ;
5582 PyObject *swig_obj[2] ;
5583
5584 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5586 if (!SWIG_IsOK(res1)) {
5587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5588 }
5589 arg1 = reinterpret_cast< wxPoint * >(argp1);
5590 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5591 if (!SWIG_IsOK(ecode2)) {
5592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5593 }
5594 arg2 = static_cast< int >(val2);
5595 if (arg1) (arg1)->y = arg2;
5596
5597 resultobj = SWIG_Py_Void();
5598 return resultobj;
5599 fail:
5600 return NULL;
5601 }
5602
5603
5604 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5605 PyObject *resultobj = 0;
5606 wxPoint *arg1 = (wxPoint *) 0 ;
5607 int result;
5608 void *argp1 = 0 ;
5609 int res1 = 0 ;
5610 PyObject *swig_obj[1] ;
5611
5612 if (!args) SWIG_fail;
5613 swig_obj[0] = args;
5614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5615 if (!SWIG_IsOK(res1)) {
5616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5617 }
5618 arg1 = reinterpret_cast< wxPoint * >(argp1);
5619 result = (int) ((arg1)->y);
5620 resultobj = SWIG_From_int(static_cast< int >(result));
5621 return resultobj;
5622 fail:
5623 return NULL;
5624 }
5625
5626
5627 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5628 PyObject *resultobj = 0;
5629 int arg1 = (int) 0 ;
5630 int arg2 = (int) 0 ;
5631 wxPoint *result = 0 ;
5632 int val1 ;
5633 int ecode1 = 0 ;
5634 int val2 ;
5635 int ecode2 = 0 ;
5636 PyObject * obj0 = 0 ;
5637 PyObject * obj1 = 0 ;
5638 char * kwnames[] = {
5639 (char *) "x",(char *) "y", NULL
5640 };
5641
5642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5643 if (obj0) {
5644 ecode1 = SWIG_AsVal_int(obj0, &val1);
5645 if (!SWIG_IsOK(ecode1)) {
5646 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5647 }
5648 arg1 = static_cast< int >(val1);
5649 }
5650 if (obj1) {
5651 ecode2 = SWIG_AsVal_int(obj1, &val2);
5652 if (!SWIG_IsOK(ecode2)) {
5653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5654 }
5655 arg2 = static_cast< int >(val2);
5656 }
5657 {
5658 PyThreadState* __tstate = wxPyBeginAllowThreads();
5659 result = (wxPoint *)new wxPoint(arg1,arg2);
5660 wxPyEndAllowThreads(__tstate);
5661 if (PyErr_Occurred()) SWIG_fail;
5662 }
5663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5664 return resultobj;
5665 fail:
5666 return NULL;
5667 }
5668
5669
5670 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5671 PyObject *resultobj = 0;
5672 wxPoint *arg1 = (wxPoint *) 0 ;
5673 void *argp1 = 0 ;
5674 int res1 = 0 ;
5675 PyObject *swig_obj[1] ;
5676
5677 if (!args) SWIG_fail;
5678 swig_obj[0] = args;
5679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5680 if (!SWIG_IsOK(res1)) {
5681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5682 }
5683 arg1 = reinterpret_cast< wxPoint * >(argp1);
5684 {
5685 PyThreadState* __tstate = wxPyBeginAllowThreads();
5686 delete arg1;
5687
5688 wxPyEndAllowThreads(__tstate);
5689 if (PyErr_Occurred()) SWIG_fail;
5690 }
5691 resultobj = SWIG_Py_Void();
5692 return resultobj;
5693 fail:
5694 return NULL;
5695 }
5696
5697
5698 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5699 PyObject *resultobj = 0;
5700 wxPoint *arg1 = (wxPoint *) 0 ;
5701 PyObject *arg2 = (PyObject *) 0 ;
5702 bool result;
5703 void *argp1 = 0 ;
5704 int res1 = 0 ;
5705 PyObject * obj0 = 0 ;
5706 PyObject * obj1 = 0 ;
5707 char * kwnames[] = {
5708 (char *) "self",(char *) "other", NULL
5709 };
5710
5711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5713 if (!SWIG_IsOK(res1)) {
5714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5715 }
5716 arg1 = reinterpret_cast< wxPoint * >(argp1);
5717 arg2 = obj1;
5718 {
5719 result = (bool)wxPoint___eq__(arg1,arg2);
5720 if (PyErr_Occurred()) SWIG_fail;
5721 }
5722 {
5723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5724 }
5725 return resultobj;
5726 fail:
5727 return NULL;
5728 }
5729
5730
5731 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5732 PyObject *resultobj = 0;
5733 wxPoint *arg1 = (wxPoint *) 0 ;
5734 PyObject *arg2 = (PyObject *) 0 ;
5735 bool result;
5736 void *argp1 = 0 ;
5737 int res1 = 0 ;
5738 PyObject * obj0 = 0 ;
5739 PyObject * obj1 = 0 ;
5740 char * kwnames[] = {
5741 (char *) "self",(char *) "other", NULL
5742 };
5743
5744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5746 if (!SWIG_IsOK(res1)) {
5747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5748 }
5749 arg1 = reinterpret_cast< wxPoint * >(argp1);
5750 arg2 = obj1;
5751 {
5752 result = (bool)wxPoint___ne__(arg1,arg2);
5753 if (PyErr_Occurred()) SWIG_fail;
5754 }
5755 {
5756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5757 }
5758 return resultobj;
5759 fail:
5760 return NULL;
5761 }
5762
5763
5764 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5765 PyObject *resultobj = 0;
5766 wxPoint *arg1 = (wxPoint *) 0 ;
5767 wxPoint *arg2 = 0 ;
5768 wxPoint result;
5769 void *argp1 = 0 ;
5770 int res1 = 0 ;
5771 wxPoint temp2 ;
5772 PyObject * obj0 = 0 ;
5773 PyObject * obj1 = 0 ;
5774 char * kwnames[] = {
5775 (char *) "self",(char *) "pt", NULL
5776 };
5777
5778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5780 if (!SWIG_IsOK(res1)) {
5781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5782 }
5783 arg1 = reinterpret_cast< wxPoint * >(argp1);
5784 {
5785 arg2 = &temp2;
5786 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5787 }
5788 {
5789 PyThreadState* __tstate = wxPyBeginAllowThreads();
5790 result = (arg1)->operator +((wxPoint const &)*arg2);
5791 wxPyEndAllowThreads(__tstate);
5792 if (PyErr_Occurred()) SWIG_fail;
5793 }
5794 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5795 return resultobj;
5796 fail:
5797 return NULL;
5798 }
5799
5800
5801 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5802 PyObject *resultobj = 0;
5803 wxPoint *arg1 = (wxPoint *) 0 ;
5804 wxPoint *arg2 = 0 ;
5805 wxPoint result;
5806 void *argp1 = 0 ;
5807 int res1 = 0 ;
5808 wxPoint temp2 ;
5809 PyObject * obj0 = 0 ;
5810 PyObject * obj1 = 0 ;
5811 char * kwnames[] = {
5812 (char *) "self",(char *) "pt", NULL
5813 };
5814
5815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5817 if (!SWIG_IsOK(res1)) {
5818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5819 }
5820 arg1 = reinterpret_cast< wxPoint * >(argp1);
5821 {
5822 arg2 = &temp2;
5823 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5824 }
5825 {
5826 PyThreadState* __tstate = wxPyBeginAllowThreads();
5827 result = (arg1)->operator -((wxPoint const &)*arg2);
5828 wxPyEndAllowThreads(__tstate);
5829 if (PyErr_Occurred()) SWIG_fail;
5830 }
5831 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5832 return resultobj;
5833 fail:
5834 return NULL;
5835 }
5836
5837
5838 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5839 PyObject *resultobj = 0;
5840 wxPoint *arg1 = (wxPoint *) 0 ;
5841 wxPoint *arg2 = 0 ;
5842 wxPoint *result = 0 ;
5843 void *argp1 = 0 ;
5844 int res1 = 0 ;
5845 wxPoint temp2 ;
5846 PyObject * obj0 = 0 ;
5847 PyObject * obj1 = 0 ;
5848 char * kwnames[] = {
5849 (char *) "self",(char *) "pt", NULL
5850 };
5851
5852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5854 if (!SWIG_IsOK(res1)) {
5855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5856 }
5857 arg1 = reinterpret_cast< wxPoint * >(argp1);
5858 {
5859 arg2 = &temp2;
5860 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5861 }
5862 {
5863 PyThreadState* __tstate = wxPyBeginAllowThreads();
5864 {
5865 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5866 result = (wxPoint *) &_result_ref;
5867 }
5868 wxPyEndAllowThreads(__tstate);
5869 if (PyErr_Occurred()) SWIG_fail;
5870 }
5871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5872 return resultobj;
5873 fail:
5874 return NULL;
5875 }
5876
5877
5878 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5879 PyObject *resultobj = 0;
5880 wxPoint *arg1 = (wxPoint *) 0 ;
5881 wxPoint *arg2 = 0 ;
5882 wxPoint *result = 0 ;
5883 void *argp1 = 0 ;
5884 int res1 = 0 ;
5885 wxPoint temp2 ;
5886 PyObject * obj0 = 0 ;
5887 PyObject * obj1 = 0 ;
5888 char * kwnames[] = {
5889 (char *) "self",(char *) "pt", NULL
5890 };
5891
5892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5894 if (!SWIG_IsOK(res1)) {
5895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5896 }
5897 arg1 = reinterpret_cast< wxPoint * >(argp1);
5898 {
5899 arg2 = &temp2;
5900 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5901 }
5902 {
5903 PyThreadState* __tstate = wxPyBeginAllowThreads();
5904 {
5905 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5906 result = (wxPoint *) &_result_ref;
5907 }
5908 wxPyEndAllowThreads(__tstate);
5909 if (PyErr_Occurred()) SWIG_fail;
5910 }
5911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5912 return resultobj;
5913 fail:
5914 return NULL;
5915 }
5916
5917
5918 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5919 PyObject *resultobj = 0;
5920 wxPoint *arg1 = (wxPoint *) 0 ;
5921 long arg2 ;
5922 long arg3 ;
5923 void *argp1 = 0 ;
5924 int res1 = 0 ;
5925 long val2 ;
5926 int ecode2 = 0 ;
5927 long val3 ;
5928 int ecode3 = 0 ;
5929 PyObject * obj0 = 0 ;
5930 PyObject * obj1 = 0 ;
5931 PyObject * obj2 = 0 ;
5932 char * kwnames[] = {
5933 (char *) "self",(char *) "x",(char *) "y", NULL
5934 };
5935
5936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5938 if (!SWIG_IsOK(res1)) {
5939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5940 }
5941 arg1 = reinterpret_cast< wxPoint * >(argp1);
5942 ecode2 = SWIG_AsVal_long(obj1, &val2);
5943 if (!SWIG_IsOK(ecode2)) {
5944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5945 }
5946 arg2 = static_cast< long >(val2);
5947 ecode3 = SWIG_AsVal_long(obj2, &val3);
5948 if (!SWIG_IsOK(ecode3)) {
5949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5950 }
5951 arg3 = static_cast< long >(val3);
5952 {
5953 PyThreadState* __tstate = wxPyBeginAllowThreads();
5954 wxPoint_Set(arg1,arg2,arg3);
5955 wxPyEndAllowThreads(__tstate);
5956 if (PyErr_Occurred()) SWIG_fail;
5957 }
5958 resultobj = SWIG_Py_Void();
5959 return resultobj;
5960 fail:
5961 return NULL;
5962 }
5963
5964
5965 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5966 PyObject *resultobj = 0;
5967 wxPoint *arg1 = (wxPoint *) 0 ;
5968 PyObject *result = 0 ;
5969 void *argp1 = 0 ;
5970 int res1 = 0 ;
5971 PyObject *swig_obj[1] ;
5972
5973 if (!args) SWIG_fail;
5974 swig_obj[0] = args;
5975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5976 if (!SWIG_IsOK(res1)) {
5977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5978 }
5979 arg1 = reinterpret_cast< wxPoint * >(argp1);
5980 {
5981 PyThreadState* __tstate = wxPyBeginAllowThreads();
5982 result = (PyObject *)wxPoint_Get(arg1);
5983 wxPyEndAllowThreads(__tstate);
5984 if (PyErr_Occurred()) SWIG_fail;
5985 }
5986 resultobj = result;
5987 return resultobj;
5988 fail:
5989 return NULL;
5990 }
5991
5992
5993 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5994 PyObject *obj;
5995 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5996 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5997 return SWIG_Py_Void();
5998 }
5999
6000 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6001 return SWIG_Python_InitShadowInstance(args);
6002 }
6003
6004 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6005 PyObject *resultobj = 0;
6006 int arg1 = (int) 0 ;
6007 int arg2 = (int) 0 ;
6008 int arg3 = (int) 0 ;
6009 int arg4 = (int) 0 ;
6010 wxRect *result = 0 ;
6011 int val1 ;
6012 int ecode1 = 0 ;
6013 int val2 ;
6014 int ecode2 = 0 ;
6015 int val3 ;
6016 int ecode3 = 0 ;
6017 int val4 ;
6018 int ecode4 = 0 ;
6019 PyObject * obj0 = 0 ;
6020 PyObject * obj1 = 0 ;
6021 PyObject * obj2 = 0 ;
6022 PyObject * obj3 = 0 ;
6023 char * kwnames[] = {
6024 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6025 };
6026
6027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6028 if (obj0) {
6029 ecode1 = SWIG_AsVal_int(obj0, &val1);
6030 if (!SWIG_IsOK(ecode1)) {
6031 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6032 }
6033 arg1 = static_cast< int >(val1);
6034 }
6035 if (obj1) {
6036 ecode2 = SWIG_AsVal_int(obj1, &val2);
6037 if (!SWIG_IsOK(ecode2)) {
6038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6039 }
6040 arg2 = static_cast< int >(val2);
6041 }
6042 if (obj2) {
6043 ecode3 = SWIG_AsVal_int(obj2, &val3);
6044 if (!SWIG_IsOK(ecode3)) {
6045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6046 }
6047 arg3 = static_cast< int >(val3);
6048 }
6049 if (obj3) {
6050 ecode4 = SWIG_AsVal_int(obj3, &val4);
6051 if (!SWIG_IsOK(ecode4)) {
6052 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6053 }
6054 arg4 = static_cast< int >(val4);
6055 }
6056 {
6057 PyThreadState* __tstate = wxPyBeginAllowThreads();
6058 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6059 wxPyEndAllowThreads(__tstate);
6060 if (PyErr_Occurred()) SWIG_fail;
6061 }
6062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6063 return resultobj;
6064 fail:
6065 return NULL;
6066 }
6067
6068
6069 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6070 PyObject *resultobj = 0;
6071 wxPoint *arg1 = 0 ;
6072 wxPoint *arg2 = 0 ;
6073 wxRect *result = 0 ;
6074 wxPoint temp1 ;
6075 wxPoint temp2 ;
6076 PyObject * obj0 = 0 ;
6077 PyObject * obj1 = 0 ;
6078 char * kwnames[] = {
6079 (char *) "topLeft",(char *) "bottomRight", NULL
6080 };
6081
6082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6083 {
6084 arg1 = &temp1;
6085 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6086 }
6087 {
6088 arg2 = &temp2;
6089 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6090 }
6091 {
6092 PyThreadState* __tstate = wxPyBeginAllowThreads();
6093 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6094 wxPyEndAllowThreads(__tstate);
6095 if (PyErr_Occurred()) SWIG_fail;
6096 }
6097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6098 return resultobj;
6099 fail:
6100 return NULL;
6101 }
6102
6103
6104 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6105 PyObject *resultobj = 0;
6106 wxPoint *arg1 = 0 ;
6107 wxSize *arg2 = 0 ;
6108 wxRect *result = 0 ;
6109 wxPoint temp1 ;
6110 wxSize temp2 ;
6111 PyObject * obj0 = 0 ;
6112 PyObject * obj1 = 0 ;
6113 char * kwnames[] = {
6114 (char *) "pos",(char *) "size", NULL
6115 };
6116
6117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6118 {
6119 arg1 = &temp1;
6120 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6121 }
6122 {
6123 arg2 = &temp2;
6124 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6125 }
6126 {
6127 PyThreadState* __tstate = wxPyBeginAllowThreads();
6128 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6129 wxPyEndAllowThreads(__tstate);
6130 if (PyErr_Occurred()) SWIG_fail;
6131 }
6132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6133 return resultobj;
6134 fail:
6135 return NULL;
6136 }
6137
6138
6139 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6140 PyObject *resultobj = 0;
6141 wxSize *arg1 = 0 ;
6142 wxRect *result = 0 ;
6143 wxSize temp1 ;
6144 PyObject * obj0 = 0 ;
6145 char * kwnames[] = {
6146 (char *) "size", NULL
6147 };
6148
6149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6150 {
6151 arg1 = &temp1;
6152 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6153 }
6154 {
6155 PyThreadState* __tstate = wxPyBeginAllowThreads();
6156 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6157 wxPyEndAllowThreads(__tstate);
6158 if (PyErr_Occurred()) SWIG_fail;
6159 }
6160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6161 return resultobj;
6162 fail:
6163 return NULL;
6164 }
6165
6166
6167 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6168 PyObject *resultobj = 0;
6169 wxRect *arg1 = (wxRect *) 0 ;
6170 void *argp1 = 0 ;
6171 int res1 = 0 ;
6172 PyObject *swig_obj[1] ;
6173
6174 if (!args) SWIG_fail;
6175 swig_obj[0] = args;
6176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6177 if (!SWIG_IsOK(res1)) {
6178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6179 }
6180 arg1 = reinterpret_cast< wxRect * >(argp1);
6181 {
6182 PyThreadState* __tstate = wxPyBeginAllowThreads();
6183 delete arg1;
6184
6185 wxPyEndAllowThreads(__tstate);
6186 if (PyErr_Occurred()) SWIG_fail;
6187 }
6188 resultobj = SWIG_Py_Void();
6189 return resultobj;
6190 fail:
6191 return NULL;
6192 }
6193
6194
6195 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6196 PyObject *resultobj = 0;
6197 wxRect *arg1 = (wxRect *) 0 ;
6198 int result;
6199 void *argp1 = 0 ;
6200 int res1 = 0 ;
6201 PyObject *swig_obj[1] ;
6202
6203 if (!args) SWIG_fail;
6204 swig_obj[0] = args;
6205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6206 if (!SWIG_IsOK(res1)) {
6207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6208 }
6209 arg1 = reinterpret_cast< wxRect * >(argp1);
6210 {
6211 PyThreadState* __tstate = wxPyBeginAllowThreads();
6212 result = (int)((wxRect const *)arg1)->GetX();
6213 wxPyEndAllowThreads(__tstate);
6214 if (PyErr_Occurred()) SWIG_fail;
6215 }
6216 resultobj = SWIG_From_int(static_cast< int >(result));
6217 return resultobj;
6218 fail:
6219 return NULL;
6220 }
6221
6222
6223 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6224 PyObject *resultobj = 0;
6225 wxRect *arg1 = (wxRect *) 0 ;
6226 int arg2 ;
6227 void *argp1 = 0 ;
6228 int res1 = 0 ;
6229 int val2 ;
6230 int ecode2 = 0 ;
6231 PyObject * obj0 = 0 ;
6232 PyObject * obj1 = 0 ;
6233 char * kwnames[] = {
6234 (char *) "self",(char *) "x", NULL
6235 };
6236
6237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6239 if (!SWIG_IsOK(res1)) {
6240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6241 }
6242 arg1 = reinterpret_cast< wxRect * >(argp1);
6243 ecode2 = SWIG_AsVal_int(obj1, &val2);
6244 if (!SWIG_IsOK(ecode2)) {
6245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6246 }
6247 arg2 = static_cast< int >(val2);
6248 {
6249 PyThreadState* __tstate = wxPyBeginAllowThreads();
6250 (arg1)->SetX(arg2);
6251 wxPyEndAllowThreads(__tstate);
6252 if (PyErr_Occurred()) SWIG_fail;
6253 }
6254 resultobj = SWIG_Py_Void();
6255 return resultobj;
6256 fail:
6257 return NULL;
6258 }
6259
6260
6261 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6262 PyObject *resultobj = 0;
6263 wxRect *arg1 = (wxRect *) 0 ;
6264 int result;
6265 void *argp1 = 0 ;
6266 int res1 = 0 ;
6267 PyObject *swig_obj[1] ;
6268
6269 if (!args) SWIG_fail;
6270 swig_obj[0] = args;
6271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6272 if (!SWIG_IsOK(res1)) {
6273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6274 }
6275 arg1 = reinterpret_cast< wxRect * >(argp1);
6276 {
6277 PyThreadState* __tstate = wxPyBeginAllowThreads();
6278 result = (int)(arg1)->GetY();
6279 wxPyEndAllowThreads(__tstate);
6280 if (PyErr_Occurred()) SWIG_fail;
6281 }
6282 resultobj = SWIG_From_int(static_cast< int >(result));
6283 return resultobj;
6284 fail:
6285 return NULL;
6286 }
6287
6288
6289 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6290 PyObject *resultobj = 0;
6291 wxRect *arg1 = (wxRect *) 0 ;
6292 int arg2 ;
6293 void *argp1 = 0 ;
6294 int res1 = 0 ;
6295 int val2 ;
6296 int ecode2 = 0 ;
6297 PyObject * obj0 = 0 ;
6298 PyObject * obj1 = 0 ;
6299 char * kwnames[] = {
6300 (char *) "self",(char *) "y", NULL
6301 };
6302
6303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6305 if (!SWIG_IsOK(res1)) {
6306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6307 }
6308 arg1 = reinterpret_cast< wxRect * >(argp1);
6309 ecode2 = SWIG_AsVal_int(obj1, &val2);
6310 if (!SWIG_IsOK(ecode2)) {
6311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6312 }
6313 arg2 = static_cast< int >(val2);
6314 {
6315 PyThreadState* __tstate = wxPyBeginAllowThreads();
6316 (arg1)->SetY(arg2);
6317 wxPyEndAllowThreads(__tstate);
6318 if (PyErr_Occurred()) SWIG_fail;
6319 }
6320 resultobj = SWIG_Py_Void();
6321 return resultobj;
6322 fail:
6323 return NULL;
6324 }
6325
6326
6327 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6328 PyObject *resultobj = 0;
6329 wxRect *arg1 = (wxRect *) 0 ;
6330 int result;
6331 void *argp1 = 0 ;
6332 int res1 = 0 ;
6333 PyObject *swig_obj[1] ;
6334
6335 if (!args) SWIG_fail;
6336 swig_obj[0] = args;
6337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6338 if (!SWIG_IsOK(res1)) {
6339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6340 }
6341 arg1 = reinterpret_cast< wxRect * >(argp1);
6342 {
6343 PyThreadState* __tstate = wxPyBeginAllowThreads();
6344 result = (int)((wxRect const *)arg1)->GetWidth();
6345 wxPyEndAllowThreads(__tstate);
6346 if (PyErr_Occurred()) SWIG_fail;
6347 }
6348 resultobj = SWIG_From_int(static_cast< int >(result));
6349 return resultobj;
6350 fail:
6351 return NULL;
6352 }
6353
6354
6355 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6356 PyObject *resultobj = 0;
6357 wxRect *arg1 = (wxRect *) 0 ;
6358 int arg2 ;
6359 void *argp1 = 0 ;
6360 int res1 = 0 ;
6361 int val2 ;
6362 int ecode2 = 0 ;
6363 PyObject * obj0 = 0 ;
6364 PyObject * obj1 = 0 ;
6365 char * kwnames[] = {
6366 (char *) "self",(char *) "w", NULL
6367 };
6368
6369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6371 if (!SWIG_IsOK(res1)) {
6372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6373 }
6374 arg1 = reinterpret_cast< wxRect * >(argp1);
6375 ecode2 = SWIG_AsVal_int(obj1, &val2);
6376 if (!SWIG_IsOK(ecode2)) {
6377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6378 }
6379 arg2 = static_cast< int >(val2);
6380 {
6381 PyThreadState* __tstate = wxPyBeginAllowThreads();
6382 (arg1)->SetWidth(arg2);
6383 wxPyEndAllowThreads(__tstate);
6384 if (PyErr_Occurred()) SWIG_fail;
6385 }
6386 resultobj = SWIG_Py_Void();
6387 return resultobj;
6388 fail:
6389 return NULL;
6390 }
6391
6392
6393 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6394 PyObject *resultobj = 0;
6395 wxRect *arg1 = (wxRect *) 0 ;
6396 int result;
6397 void *argp1 = 0 ;
6398 int res1 = 0 ;
6399 PyObject *swig_obj[1] ;
6400
6401 if (!args) SWIG_fail;
6402 swig_obj[0] = args;
6403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6404 if (!SWIG_IsOK(res1)) {
6405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6406 }
6407 arg1 = reinterpret_cast< wxRect * >(argp1);
6408 {
6409 PyThreadState* __tstate = wxPyBeginAllowThreads();
6410 result = (int)((wxRect const *)arg1)->GetHeight();
6411 wxPyEndAllowThreads(__tstate);
6412 if (PyErr_Occurred()) SWIG_fail;
6413 }
6414 resultobj = SWIG_From_int(static_cast< int >(result));
6415 return resultobj;
6416 fail:
6417 return NULL;
6418 }
6419
6420
6421 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6422 PyObject *resultobj = 0;
6423 wxRect *arg1 = (wxRect *) 0 ;
6424 int arg2 ;
6425 void *argp1 = 0 ;
6426 int res1 = 0 ;
6427 int val2 ;
6428 int ecode2 = 0 ;
6429 PyObject * obj0 = 0 ;
6430 PyObject * obj1 = 0 ;
6431 char * kwnames[] = {
6432 (char *) "self",(char *) "h", NULL
6433 };
6434
6435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6437 if (!SWIG_IsOK(res1)) {
6438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6439 }
6440 arg1 = reinterpret_cast< wxRect * >(argp1);
6441 ecode2 = SWIG_AsVal_int(obj1, &val2);
6442 if (!SWIG_IsOK(ecode2)) {
6443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6444 }
6445 arg2 = static_cast< int >(val2);
6446 {
6447 PyThreadState* __tstate = wxPyBeginAllowThreads();
6448 (arg1)->SetHeight(arg2);
6449 wxPyEndAllowThreads(__tstate);
6450 if (PyErr_Occurred()) SWIG_fail;
6451 }
6452 resultobj = SWIG_Py_Void();
6453 return resultobj;
6454 fail:
6455 return NULL;
6456 }
6457
6458
6459 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6460 PyObject *resultobj = 0;
6461 wxRect *arg1 = (wxRect *) 0 ;
6462 wxPoint result;
6463 void *argp1 = 0 ;
6464 int res1 = 0 ;
6465 PyObject *swig_obj[1] ;
6466
6467 if (!args) SWIG_fail;
6468 swig_obj[0] = args;
6469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6470 if (!SWIG_IsOK(res1)) {
6471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6472 }
6473 arg1 = reinterpret_cast< wxRect * >(argp1);
6474 {
6475 PyThreadState* __tstate = wxPyBeginAllowThreads();
6476 result = ((wxRect const *)arg1)->GetPosition();
6477 wxPyEndAllowThreads(__tstate);
6478 if (PyErr_Occurred()) SWIG_fail;
6479 }
6480 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6481 return resultobj;
6482 fail:
6483 return NULL;
6484 }
6485
6486
6487 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6488 PyObject *resultobj = 0;
6489 wxRect *arg1 = (wxRect *) 0 ;
6490 wxPoint *arg2 = 0 ;
6491 void *argp1 = 0 ;
6492 int res1 = 0 ;
6493 wxPoint temp2 ;
6494 PyObject * obj0 = 0 ;
6495 PyObject * obj1 = 0 ;
6496 char * kwnames[] = {
6497 (char *) "self",(char *) "p", NULL
6498 };
6499
6500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6502 if (!SWIG_IsOK(res1)) {
6503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6504 }
6505 arg1 = reinterpret_cast< wxRect * >(argp1);
6506 {
6507 arg2 = &temp2;
6508 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6509 }
6510 {
6511 PyThreadState* __tstate = wxPyBeginAllowThreads();
6512 (arg1)->SetPosition((wxPoint const &)*arg2);
6513 wxPyEndAllowThreads(__tstate);
6514 if (PyErr_Occurred()) SWIG_fail;
6515 }
6516 resultobj = SWIG_Py_Void();
6517 return resultobj;
6518 fail:
6519 return NULL;
6520 }
6521
6522
6523 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6524 PyObject *resultobj = 0;
6525 wxRect *arg1 = (wxRect *) 0 ;
6526 wxSize result;
6527 void *argp1 = 0 ;
6528 int res1 = 0 ;
6529 PyObject *swig_obj[1] ;
6530
6531 if (!args) SWIG_fail;
6532 swig_obj[0] = args;
6533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6534 if (!SWIG_IsOK(res1)) {
6535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6536 }
6537 arg1 = reinterpret_cast< wxRect * >(argp1);
6538 {
6539 PyThreadState* __tstate = wxPyBeginAllowThreads();
6540 result = ((wxRect const *)arg1)->GetSize();
6541 wxPyEndAllowThreads(__tstate);
6542 if (PyErr_Occurred()) SWIG_fail;
6543 }
6544 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6545 return resultobj;
6546 fail:
6547 return NULL;
6548 }
6549
6550
6551 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6552 PyObject *resultobj = 0;
6553 wxRect *arg1 = (wxRect *) 0 ;
6554 wxSize *arg2 = 0 ;
6555 void *argp1 = 0 ;
6556 int res1 = 0 ;
6557 wxSize temp2 ;
6558 PyObject * obj0 = 0 ;
6559 PyObject * obj1 = 0 ;
6560 char * kwnames[] = {
6561 (char *) "self",(char *) "s", NULL
6562 };
6563
6564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6566 if (!SWIG_IsOK(res1)) {
6567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6568 }
6569 arg1 = reinterpret_cast< wxRect * >(argp1);
6570 {
6571 arg2 = &temp2;
6572 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6573 }
6574 {
6575 PyThreadState* __tstate = wxPyBeginAllowThreads();
6576 (arg1)->SetSize((wxSize const &)*arg2);
6577 wxPyEndAllowThreads(__tstate);
6578 if (PyErr_Occurred()) SWIG_fail;
6579 }
6580 resultobj = SWIG_Py_Void();
6581 return resultobj;
6582 fail:
6583 return NULL;
6584 }
6585
6586
6587 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6588 PyObject *resultobj = 0;
6589 wxRect *arg1 = (wxRect *) 0 ;
6590 bool result;
6591 void *argp1 = 0 ;
6592 int res1 = 0 ;
6593 PyObject *swig_obj[1] ;
6594
6595 if (!args) SWIG_fail;
6596 swig_obj[0] = args;
6597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6598 if (!SWIG_IsOK(res1)) {
6599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6600 }
6601 arg1 = reinterpret_cast< wxRect * >(argp1);
6602 {
6603 PyThreadState* __tstate = wxPyBeginAllowThreads();
6604 result = (bool)((wxRect const *)arg1)->IsEmpty();
6605 wxPyEndAllowThreads(__tstate);
6606 if (PyErr_Occurred()) SWIG_fail;
6607 }
6608 {
6609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6610 }
6611 return resultobj;
6612 fail:
6613 return NULL;
6614 }
6615
6616
6617 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6618 PyObject *resultobj = 0;
6619 wxRect *arg1 = (wxRect *) 0 ;
6620 wxPoint result;
6621 void *argp1 = 0 ;
6622 int res1 = 0 ;
6623 PyObject *swig_obj[1] ;
6624
6625 if (!args) SWIG_fail;
6626 swig_obj[0] = args;
6627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6628 if (!SWIG_IsOK(res1)) {
6629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6630 }
6631 arg1 = reinterpret_cast< wxRect * >(argp1);
6632 {
6633 PyThreadState* __tstate = wxPyBeginAllowThreads();
6634 result = ((wxRect const *)arg1)->GetTopLeft();
6635 wxPyEndAllowThreads(__tstate);
6636 if (PyErr_Occurred()) SWIG_fail;
6637 }
6638 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6639 return resultobj;
6640 fail:
6641 return NULL;
6642 }
6643
6644
6645 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6646 PyObject *resultobj = 0;
6647 wxRect *arg1 = (wxRect *) 0 ;
6648 wxPoint *arg2 = 0 ;
6649 void *argp1 = 0 ;
6650 int res1 = 0 ;
6651 wxPoint temp2 ;
6652 PyObject * obj0 = 0 ;
6653 PyObject * obj1 = 0 ;
6654 char * kwnames[] = {
6655 (char *) "self",(char *) "p", NULL
6656 };
6657
6658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6660 if (!SWIG_IsOK(res1)) {
6661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6662 }
6663 arg1 = reinterpret_cast< wxRect * >(argp1);
6664 {
6665 arg2 = &temp2;
6666 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6667 }
6668 {
6669 PyThreadState* __tstate = wxPyBeginAllowThreads();
6670 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6671 wxPyEndAllowThreads(__tstate);
6672 if (PyErr_Occurred()) SWIG_fail;
6673 }
6674 resultobj = SWIG_Py_Void();
6675 return resultobj;
6676 fail:
6677 return NULL;
6678 }
6679
6680
6681 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6682 PyObject *resultobj = 0;
6683 wxRect *arg1 = (wxRect *) 0 ;
6684 wxPoint result;
6685 void *argp1 = 0 ;
6686 int res1 = 0 ;
6687 PyObject *swig_obj[1] ;
6688
6689 if (!args) SWIG_fail;
6690 swig_obj[0] = args;
6691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6692 if (!SWIG_IsOK(res1)) {
6693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6694 }
6695 arg1 = reinterpret_cast< wxRect * >(argp1);
6696 {
6697 PyThreadState* __tstate = wxPyBeginAllowThreads();
6698 result = ((wxRect const *)arg1)->GetBottomRight();
6699 wxPyEndAllowThreads(__tstate);
6700 if (PyErr_Occurred()) SWIG_fail;
6701 }
6702 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6703 return resultobj;
6704 fail:
6705 return NULL;
6706 }
6707
6708
6709 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6710 PyObject *resultobj = 0;
6711 wxRect *arg1 = (wxRect *) 0 ;
6712 wxPoint *arg2 = 0 ;
6713 void *argp1 = 0 ;
6714 int res1 = 0 ;
6715 wxPoint temp2 ;
6716 PyObject * obj0 = 0 ;
6717 PyObject * obj1 = 0 ;
6718 char * kwnames[] = {
6719 (char *) "self",(char *) "p", NULL
6720 };
6721
6722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6724 if (!SWIG_IsOK(res1)) {
6725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6726 }
6727 arg1 = reinterpret_cast< wxRect * >(argp1);
6728 {
6729 arg2 = &temp2;
6730 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6731 }
6732 {
6733 PyThreadState* __tstate = wxPyBeginAllowThreads();
6734 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6735 wxPyEndAllowThreads(__tstate);
6736 if (PyErr_Occurred()) SWIG_fail;
6737 }
6738 resultobj = SWIG_Py_Void();
6739 return resultobj;
6740 fail:
6741 return NULL;
6742 }
6743
6744
6745 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6746 PyObject *resultobj = 0;
6747 wxRect *arg1 = (wxRect *) 0 ;
6748 int result;
6749 void *argp1 = 0 ;
6750 int res1 = 0 ;
6751 PyObject *swig_obj[1] ;
6752
6753 if (!args) SWIG_fail;
6754 swig_obj[0] = args;
6755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6756 if (!SWIG_IsOK(res1)) {
6757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6758 }
6759 arg1 = reinterpret_cast< wxRect * >(argp1);
6760 {
6761 PyThreadState* __tstate = wxPyBeginAllowThreads();
6762 result = (int)((wxRect const *)arg1)->GetLeft();
6763 wxPyEndAllowThreads(__tstate);
6764 if (PyErr_Occurred()) SWIG_fail;
6765 }
6766 resultobj = SWIG_From_int(static_cast< int >(result));
6767 return resultobj;
6768 fail:
6769 return NULL;
6770 }
6771
6772
6773 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6774 PyObject *resultobj = 0;
6775 wxRect *arg1 = (wxRect *) 0 ;
6776 int result;
6777 void *argp1 = 0 ;
6778 int res1 = 0 ;
6779 PyObject *swig_obj[1] ;
6780
6781 if (!args) SWIG_fail;
6782 swig_obj[0] = args;
6783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6784 if (!SWIG_IsOK(res1)) {
6785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6786 }
6787 arg1 = reinterpret_cast< wxRect * >(argp1);
6788 {
6789 PyThreadState* __tstate = wxPyBeginAllowThreads();
6790 result = (int)((wxRect const *)arg1)->GetTop();
6791 wxPyEndAllowThreads(__tstate);
6792 if (PyErr_Occurred()) SWIG_fail;
6793 }
6794 resultobj = SWIG_From_int(static_cast< int >(result));
6795 return resultobj;
6796 fail:
6797 return NULL;
6798 }
6799
6800
6801 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6802 PyObject *resultobj = 0;
6803 wxRect *arg1 = (wxRect *) 0 ;
6804 int result;
6805 void *argp1 = 0 ;
6806 int res1 = 0 ;
6807 PyObject *swig_obj[1] ;
6808
6809 if (!args) SWIG_fail;
6810 swig_obj[0] = args;
6811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6812 if (!SWIG_IsOK(res1)) {
6813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6814 }
6815 arg1 = reinterpret_cast< wxRect * >(argp1);
6816 {
6817 PyThreadState* __tstate = wxPyBeginAllowThreads();
6818 result = (int)((wxRect const *)arg1)->GetBottom();
6819 wxPyEndAllowThreads(__tstate);
6820 if (PyErr_Occurred()) SWIG_fail;
6821 }
6822 resultobj = SWIG_From_int(static_cast< int >(result));
6823 return resultobj;
6824 fail:
6825 return NULL;
6826 }
6827
6828
6829 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6830 PyObject *resultobj = 0;
6831 wxRect *arg1 = (wxRect *) 0 ;
6832 int result;
6833 void *argp1 = 0 ;
6834 int res1 = 0 ;
6835 PyObject *swig_obj[1] ;
6836
6837 if (!args) SWIG_fail;
6838 swig_obj[0] = args;
6839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6840 if (!SWIG_IsOK(res1)) {
6841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6842 }
6843 arg1 = reinterpret_cast< wxRect * >(argp1);
6844 {
6845 PyThreadState* __tstate = wxPyBeginAllowThreads();
6846 result = (int)((wxRect const *)arg1)->GetRight();
6847 wxPyEndAllowThreads(__tstate);
6848 if (PyErr_Occurred()) SWIG_fail;
6849 }
6850 resultobj = SWIG_From_int(static_cast< int >(result));
6851 return resultobj;
6852 fail:
6853 return NULL;
6854 }
6855
6856
6857 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6858 PyObject *resultobj = 0;
6859 wxRect *arg1 = (wxRect *) 0 ;
6860 int arg2 ;
6861 void *argp1 = 0 ;
6862 int res1 = 0 ;
6863 int val2 ;
6864 int ecode2 = 0 ;
6865 PyObject * obj0 = 0 ;
6866 PyObject * obj1 = 0 ;
6867 char * kwnames[] = {
6868 (char *) "self",(char *) "left", NULL
6869 };
6870
6871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6873 if (!SWIG_IsOK(res1)) {
6874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6875 }
6876 arg1 = reinterpret_cast< wxRect * >(argp1);
6877 ecode2 = SWIG_AsVal_int(obj1, &val2);
6878 if (!SWIG_IsOK(ecode2)) {
6879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6880 }
6881 arg2 = static_cast< int >(val2);
6882 {
6883 PyThreadState* __tstate = wxPyBeginAllowThreads();
6884 (arg1)->SetLeft(arg2);
6885 wxPyEndAllowThreads(__tstate);
6886 if (PyErr_Occurred()) SWIG_fail;
6887 }
6888 resultobj = SWIG_Py_Void();
6889 return resultobj;
6890 fail:
6891 return NULL;
6892 }
6893
6894
6895 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6896 PyObject *resultobj = 0;
6897 wxRect *arg1 = (wxRect *) 0 ;
6898 int arg2 ;
6899 void *argp1 = 0 ;
6900 int res1 = 0 ;
6901 int val2 ;
6902 int ecode2 = 0 ;
6903 PyObject * obj0 = 0 ;
6904 PyObject * obj1 = 0 ;
6905 char * kwnames[] = {
6906 (char *) "self",(char *) "right", NULL
6907 };
6908
6909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6911 if (!SWIG_IsOK(res1)) {
6912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6913 }
6914 arg1 = reinterpret_cast< wxRect * >(argp1);
6915 ecode2 = SWIG_AsVal_int(obj1, &val2);
6916 if (!SWIG_IsOK(ecode2)) {
6917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6918 }
6919 arg2 = static_cast< int >(val2);
6920 {
6921 PyThreadState* __tstate = wxPyBeginAllowThreads();
6922 (arg1)->SetRight(arg2);
6923 wxPyEndAllowThreads(__tstate);
6924 if (PyErr_Occurred()) SWIG_fail;
6925 }
6926 resultobj = SWIG_Py_Void();
6927 return resultobj;
6928 fail:
6929 return NULL;
6930 }
6931
6932
6933 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6934 PyObject *resultobj = 0;
6935 wxRect *arg1 = (wxRect *) 0 ;
6936 int arg2 ;
6937 void *argp1 = 0 ;
6938 int res1 = 0 ;
6939 int val2 ;
6940 int ecode2 = 0 ;
6941 PyObject * obj0 = 0 ;
6942 PyObject * obj1 = 0 ;
6943 char * kwnames[] = {
6944 (char *) "self",(char *) "top", NULL
6945 };
6946
6947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6949 if (!SWIG_IsOK(res1)) {
6950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6951 }
6952 arg1 = reinterpret_cast< wxRect * >(argp1);
6953 ecode2 = SWIG_AsVal_int(obj1, &val2);
6954 if (!SWIG_IsOK(ecode2)) {
6955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6956 }
6957 arg2 = static_cast< int >(val2);
6958 {
6959 PyThreadState* __tstate = wxPyBeginAllowThreads();
6960 (arg1)->SetTop(arg2);
6961 wxPyEndAllowThreads(__tstate);
6962 if (PyErr_Occurred()) SWIG_fail;
6963 }
6964 resultobj = SWIG_Py_Void();
6965 return resultobj;
6966 fail:
6967 return NULL;
6968 }
6969
6970
6971 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6972 PyObject *resultobj = 0;
6973 wxRect *arg1 = (wxRect *) 0 ;
6974 int arg2 ;
6975 void *argp1 = 0 ;
6976 int res1 = 0 ;
6977 int val2 ;
6978 int ecode2 = 0 ;
6979 PyObject * obj0 = 0 ;
6980 PyObject * obj1 = 0 ;
6981 char * kwnames[] = {
6982 (char *) "self",(char *) "bottom", NULL
6983 };
6984
6985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6987 if (!SWIG_IsOK(res1)) {
6988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6989 }
6990 arg1 = reinterpret_cast< wxRect * >(argp1);
6991 ecode2 = SWIG_AsVal_int(obj1, &val2);
6992 if (!SWIG_IsOK(ecode2)) {
6993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6994 }
6995 arg2 = static_cast< int >(val2);
6996 {
6997 PyThreadState* __tstate = wxPyBeginAllowThreads();
6998 (arg1)->SetBottom(arg2);
6999 wxPyEndAllowThreads(__tstate);
7000 if (PyErr_Occurred()) SWIG_fail;
7001 }
7002 resultobj = SWIG_Py_Void();
7003 return resultobj;
7004 fail:
7005 return NULL;
7006 }
7007
7008
7009 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7010 PyObject *resultobj = 0;
7011 wxRect *arg1 = (wxRect *) 0 ;
7012 int arg2 ;
7013 int arg3 ;
7014 wxRect *result = 0 ;
7015 void *argp1 = 0 ;
7016 int res1 = 0 ;
7017 int val2 ;
7018 int ecode2 = 0 ;
7019 int val3 ;
7020 int ecode3 = 0 ;
7021 PyObject * obj0 = 0 ;
7022 PyObject * obj1 = 0 ;
7023 PyObject * obj2 = 0 ;
7024 char * kwnames[] = {
7025 (char *) "self",(char *) "dx",(char *) "dy", NULL
7026 };
7027
7028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7030 if (!SWIG_IsOK(res1)) {
7031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7032 }
7033 arg1 = reinterpret_cast< wxRect * >(argp1);
7034 ecode2 = SWIG_AsVal_int(obj1, &val2);
7035 if (!SWIG_IsOK(ecode2)) {
7036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7037 }
7038 arg2 = static_cast< int >(val2);
7039 ecode3 = SWIG_AsVal_int(obj2, &val3);
7040 if (!SWIG_IsOK(ecode3)) {
7041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7042 }
7043 arg3 = static_cast< int >(val3);
7044 {
7045 PyThreadState* __tstate = wxPyBeginAllowThreads();
7046 {
7047 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7048 result = (wxRect *) &_result_ref;
7049 }
7050 wxPyEndAllowThreads(__tstate);
7051 if (PyErr_Occurred()) SWIG_fail;
7052 }
7053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
7060 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7061 PyObject *resultobj = 0;
7062 wxRect *arg1 = (wxRect *) 0 ;
7063 int arg2 ;
7064 int arg3 ;
7065 wxRect *result = 0 ;
7066 void *argp1 = 0 ;
7067 int res1 = 0 ;
7068 int val2 ;
7069 int ecode2 = 0 ;
7070 int val3 ;
7071 int ecode3 = 0 ;
7072 PyObject * obj0 = 0 ;
7073 PyObject * obj1 = 0 ;
7074 PyObject * obj2 = 0 ;
7075 char * kwnames[] = {
7076 (char *) "self",(char *) "dx",(char *) "dy", NULL
7077 };
7078
7079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7081 if (!SWIG_IsOK(res1)) {
7082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7083 }
7084 arg1 = reinterpret_cast< wxRect * >(argp1);
7085 ecode2 = SWIG_AsVal_int(obj1, &val2);
7086 if (!SWIG_IsOK(ecode2)) {
7087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7088 }
7089 arg2 = static_cast< int >(val2);
7090 ecode3 = SWIG_AsVal_int(obj2, &val3);
7091 if (!SWIG_IsOK(ecode3)) {
7092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7093 }
7094 arg3 = static_cast< int >(val3);
7095 {
7096 PyThreadState* __tstate = wxPyBeginAllowThreads();
7097 {
7098 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7099 result = (wxRect *) &_result_ref;
7100 }
7101 wxPyEndAllowThreads(__tstate);
7102 if (PyErr_Occurred()) SWIG_fail;
7103 }
7104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7105 return resultobj;
7106 fail:
7107 return NULL;
7108 }
7109
7110
7111 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7112 PyObject *resultobj = 0;
7113 wxRect *arg1 = (wxRect *) 0 ;
7114 int arg2 ;
7115 int arg3 ;
7116 void *argp1 = 0 ;
7117 int res1 = 0 ;
7118 int val2 ;
7119 int ecode2 = 0 ;
7120 int val3 ;
7121 int ecode3 = 0 ;
7122 PyObject * obj0 = 0 ;
7123 PyObject * obj1 = 0 ;
7124 PyObject * obj2 = 0 ;
7125 char * kwnames[] = {
7126 (char *) "self",(char *) "dx",(char *) "dy", NULL
7127 };
7128
7129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7131 if (!SWIG_IsOK(res1)) {
7132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7133 }
7134 arg1 = reinterpret_cast< wxRect * >(argp1);
7135 ecode2 = SWIG_AsVal_int(obj1, &val2);
7136 if (!SWIG_IsOK(ecode2)) {
7137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7138 }
7139 arg2 = static_cast< int >(val2);
7140 ecode3 = SWIG_AsVal_int(obj2, &val3);
7141 if (!SWIG_IsOK(ecode3)) {
7142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7143 }
7144 arg3 = static_cast< int >(val3);
7145 {
7146 PyThreadState* __tstate = wxPyBeginAllowThreads();
7147 (arg1)->Offset(arg2,arg3);
7148 wxPyEndAllowThreads(__tstate);
7149 if (PyErr_Occurred()) SWIG_fail;
7150 }
7151 resultobj = SWIG_Py_Void();
7152 return resultobj;
7153 fail:
7154 return NULL;
7155 }
7156
7157
7158 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7159 PyObject *resultobj = 0;
7160 wxRect *arg1 = (wxRect *) 0 ;
7161 wxPoint *arg2 = 0 ;
7162 void *argp1 = 0 ;
7163 int res1 = 0 ;
7164 wxPoint temp2 ;
7165 PyObject * obj0 = 0 ;
7166 PyObject * obj1 = 0 ;
7167 char * kwnames[] = {
7168 (char *) "self",(char *) "pt", NULL
7169 };
7170
7171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7173 if (!SWIG_IsOK(res1)) {
7174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7175 }
7176 arg1 = reinterpret_cast< wxRect * >(argp1);
7177 {
7178 arg2 = &temp2;
7179 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7180 }
7181 {
7182 PyThreadState* __tstate = wxPyBeginAllowThreads();
7183 (arg1)->Offset((wxPoint const &)*arg2);
7184 wxPyEndAllowThreads(__tstate);
7185 if (PyErr_Occurred()) SWIG_fail;
7186 }
7187 resultobj = SWIG_Py_Void();
7188 return resultobj;
7189 fail:
7190 return NULL;
7191 }
7192
7193
7194 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7195 PyObject *resultobj = 0;
7196 wxRect *arg1 = (wxRect *) 0 ;
7197 wxRect *arg2 = 0 ;
7198 wxRect result;
7199 void *argp1 = 0 ;
7200 int res1 = 0 ;
7201 wxRect temp2 ;
7202 PyObject * obj0 = 0 ;
7203 PyObject * obj1 = 0 ;
7204 char * kwnames[] = {
7205 (char *) "self",(char *) "rect", NULL
7206 };
7207
7208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7210 if (!SWIG_IsOK(res1)) {
7211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7212 }
7213 arg1 = reinterpret_cast< wxRect * >(argp1);
7214 {
7215 arg2 = &temp2;
7216 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7217 }
7218 {
7219 PyThreadState* __tstate = wxPyBeginAllowThreads();
7220 result = (arg1)->Intersect((wxRect const &)*arg2);
7221 wxPyEndAllowThreads(__tstate);
7222 if (PyErr_Occurred()) SWIG_fail;
7223 }
7224 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7225 return resultobj;
7226 fail:
7227 return NULL;
7228 }
7229
7230
7231 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7232 PyObject *resultobj = 0;
7233 wxRect *arg1 = (wxRect *) 0 ;
7234 wxRect *arg2 = 0 ;
7235 wxRect result;
7236 void *argp1 = 0 ;
7237 int res1 = 0 ;
7238 wxRect temp2 ;
7239 PyObject * obj0 = 0 ;
7240 PyObject * obj1 = 0 ;
7241 char * kwnames[] = {
7242 (char *) "self",(char *) "rect", NULL
7243 };
7244
7245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7247 if (!SWIG_IsOK(res1)) {
7248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7249 }
7250 arg1 = reinterpret_cast< wxRect * >(argp1);
7251 {
7252 arg2 = &temp2;
7253 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7254 }
7255 {
7256 PyThreadState* __tstate = wxPyBeginAllowThreads();
7257 result = (arg1)->Union((wxRect const &)*arg2);
7258 wxPyEndAllowThreads(__tstate);
7259 if (PyErr_Occurred()) SWIG_fail;
7260 }
7261 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7262 return resultobj;
7263 fail:
7264 return NULL;
7265 }
7266
7267
7268 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7269 PyObject *resultobj = 0;
7270 wxRect *arg1 = (wxRect *) 0 ;
7271 wxRect *arg2 = 0 ;
7272 wxRect result;
7273 void *argp1 = 0 ;
7274 int res1 = 0 ;
7275 wxRect temp2 ;
7276 PyObject * obj0 = 0 ;
7277 PyObject * obj1 = 0 ;
7278 char * kwnames[] = {
7279 (char *) "self",(char *) "rect", NULL
7280 };
7281
7282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7284 if (!SWIG_IsOK(res1)) {
7285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7286 }
7287 arg1 = reinterpret_cast< wxRect * >(argp1);
7288 {
7289 arg2 = &temp2;
7290 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7291 }
7292 {
7293 PyThreadState* __tstate = wxPyBeginAllowThreads();
7294 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7295 wxPyEndAllowThreads(__tstate);
7296 if (PyErr_Occurred()) SWIG_fail;
7297 }
7298 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7299 return resultobj;
7300 fail:
7301 return NULL;
7302 }
7303
7304
7305 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7306 PyObject *resultobj = 0;
7307 wxRect *arg1 = (wxRect *) 0 ;
7308 wxRect *arg2 = 0 ;
7309 wxRect *result = 0 ;
7310 void *argp1 = 0 ;
7311 int res1 = 0 ;
7312 wxRect temp2 ;
7313 PyObject * obj0 = 0 ;
7314 PyObject * obj1 = 0 ;
7315 char * kwnames[] = {
7316 (char *) "self",(char *) "rect", NULL
7317 };
7318
7319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7321 if (!SWIG_IsOK(res1)) {
7322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7323 }
7324 arg1 = reinterpret_cast< wxRect * >(argp1);
7325 {
7326 arg2 = &temp2;
7327 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7328 }
7329 {
7330 PyThreadState* __tstate = wxPyBeginAllowThreads();
7331 {
7332 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7333 result = (wxRect *) &_result_ref;
7334 }
7335 wxPyEndAllowThreads(__tstate);
7336 if (PyErr_Occurred()) SWIG_fail;
7337 }
7338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7339 return resultobj;
7340 fail:
7341 return NULL;
7342 }
7343
7344
7345 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7346 PyObject *resultobj = 0;
7347 wxRect *arg1 = (wxRect *) 0 ;
7348 PyObject *arg2 = (PyObject *) 0 ;
7349 bool result;
7350 void *argp1 = 0 ;
7351 int res1 = 0 ;
7352 PyObject * obj0 = 0 ;
7353 PyObject * obj1 = 0 ;
7354 char * kwnames[] = {
7355 (char *) "self",(char *) "other", NULL
7356 };
7357
7358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7360 if (!SWIG_IsOK(res1)) {
7361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7362 }
7363 arg1 = reinterpret_cast< wxRect * >(argp1);
7364 arg2 = obj1;
7365 {
7366 result = (bool)wxRect___eq__(arg1,arg2);
7367 if (PyErr_Occurred()) SWIG_fail;
7368 }
7369 {
7370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7371 }
7372 return resultobj;
7373 fail:
7374 return NULL;
7375 }
7376
7377
7378 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7379 PyObject *resultobj = 0;
7380 wxRect *arg1 = (wxRect *) 0 ;
7381 PyObject *arg2 = (PyObject *) 0 ;
7382 bool result;
7383 void *argp1 = 0 ;
7384 int res1 = 0 ;
7385 PyObject * obj0 = 0 ;
7386 PyObject * obj1 = 0 ;
7387 char * kwnames[] = {
7388 (char *) "self",(char *) "other", NULL
7389 };
7390
7391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7393 if (!SWIG_IsOK(res1)) {
7394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7395 }
7396 arg1 = reinterpret_cast< wxRect * >(argp1);
7397 arg2 = obj1;
7398 {
7399 result = (bool)wxRect___ne__(arg1,arg2);
7400 if (PyErr_Occurred()) SWIG_fail;
7401 }
7402 {
7403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7404 }
7405 return resultobj;
7406 fail:
7407 return NULL;
7408 }
7409
7410
7411 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7412 PyObject *resultobj = 0;
7413 wxRect *arg1 = (wxRect *) 0 ;
7414 int arg2 ;
7415 int arg3 ;
7416 bool result;
7417 void *argp1 = 0 ;
7418 int res1 = 0 ;
7419 int val2 ;
7420 int ecode2 = 0 ;
7421 int val3 ;
7422 int ecode3 = 0 ;
7423 PyObject * obj0 = 0 ;
7424 PyObject * obj1 = 0 ;
7425 PyObject * obj2 = 0 ;
7426 char * kwnames[] = {
7427 (char *) "self",(char *) "x",(char *) "y", NULL
7428 };
7429
7430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7432 if (!SWIG_IsOK(res1)) {
7433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7434 }
7435 arg1 = reinterpret_cast< wxRect * >(argp1);
7436 ecode2 = SWIG_AsVal_int(obj1, &val2);
7437 if (!SWIG_IsOK(ecode2)) {
7438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7439 }
7440 arg2 = static_cast< int >(val2);
7441 ecode3 = SWIG_AsVal_int(obj2, &val3);
7442 if (!SWIG_IsOK(ecode3)) {
7443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7444 }
7445 arg3 = static_cast< int >(val3);
7446 {
7447 PyThreadState* __tstate = wxPyBeginAllowThreads();
7448 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7449 wxPyEndAllowThreads(__tstate);
7450 if (PyErr_Occurred()) SWIG_fail;
7451 }
7452 {
7453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7454 }
7455 return resultobj;
7456 fail:
7457 return NULL;
7458 }
7459
7460
7461 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7462 PyObject *resultobj = 0;
7463 wxRect *arg1 = (wxRect *) 0 ;
7464 wxPoint *arg2 = 0 ;
7465 bool result;
7466 void *argp1 = 0 ;
7467 int res1 = 0 ;
7468 wxPoint temp2 ;
7469 PyObject * obj0 = 0 ;
7470 PyObject * obj1 = 0 ;
7471 char * kwnames[] = {
7472 (char *) "self",(char *) "pt", NULL
7473 };
7474
7475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7477 if (!SWIG_IsOK(res1)) {
7478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7479 }
7480 arg1 = reinterpret_cast< wxRect * >(argp1);
7481 {
7482 arg2 = &temp2;
7483 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7484 }
7485 {
7486 PyThreadState* __tstate = wxPyBeginAllowThreads();
7487 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7488 wxPyEndAllowThreads(__tstate);
7489 if (PyErr_Occurred()) SWIG_fail;
7490 }
7491 {
7492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7493 }
7494 return resultobj;
7495 fail:
7496 return NULL;
7497 }
7498
7499
7500 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7501 PyObject *resultobj = 0;
7502 wxRect *arg1 = (wxRect *) 0 ;
7503 wxRect *arg2 = 0 ;
7504 bool result;
7505 void *argp1 = 0 ;
7506 int res1 = 0 ;
7507 wxRect temp2 ;
7508 PyObject * obj0 = 0 ;
7509 PyObject * obj1 = 0 ;
7510 char * kwnames[] = {
7511 (char *) "self",(char *) "rect", NULL
7512 };
7513
7514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7516 if (!SWIG_IsOK(res1)) {
7517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7518 }
7519 arg1 = reinterpret_cast< wxRect * >(argp1);
7520 {
7521 arg2 = &temp2;
7522 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7523 }
7524 {
7525 PyThreadState* __tstate = wxPyBeginAllowThreads();
7526 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7527 wxPyEndAllowThreads(__tstate);
7528 if (PyErr_Occurred()) SWIG_fail;
7529 }
7530 {
7531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7532 }
7533 return resultobj;
7534 fail:
7535 return NULL;
7536 }
7537
7538
7539 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7540 PyObject *resultobj = 0;
7541 wxRect *arg1 = (wxRect *) 0 ;
7542 wxRect *arg2 = 0 ;
7543 int arg3 = (int) wxBOTH ;
7544 wxRect result;
7545 void *argp1 = 0 ;
7546 int res1 = 0 ;
7547 wxRect temp2 ;
7548 int val3 ;
7549 int ecode3 = 0 ;
7550 PyObject * obj0 = 0 ;
7551 PyObject * obj1 = 0 ;
7552 PyObject * obj2 = 0 ;
7553 char * kwnames[] = {
7554 (char *) "self",(char *) "r",(char *) "dir", NULL
7555 };
7556
7557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7559 if (!SWIG_IsOK(res1)) {
7560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7561 }
7562 arg1 = reinterpret_cast< wxRect * >(argp1);
7563 {
7564 arg2 = &temp2;
7565 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7566 }
7567 if (obj2) {
7568 ecode3 = SWIG_AsVal_int(obj2, &val3);
7569 if (!SWIG_IsOK(ecode3)) {
7570 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7571 }
7572 arg3 = static_cast< int >(val3);
7573 }
7574 {
7575 PyThreadState* __tstate = wxPyBeginAllowThreads();
7576 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7577 wxPyEndAllowThreads(__tstate);
7578 if (PyErr_Occurred()) SWIG_fail;
7579 }
7580 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7581 return resultobj;
7582 fail:
7583 return NULL;
7584 }
7585
7586
7587 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7588 PyObject *resultobj = 0;
7589 wxRect *arg1 = (wxRect *) 0 ;
7590 int arg2 ;
7591 void *argp1 = 0 ;
7592 int res1 = 0 ;
7593 int val2 ;
7594 int ecode2 = 0 ;
7595 PyObject *swig_obj[2] ;
7596
7597 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7599 if (!SWIG_IsOK(res1)) {
7600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7601 }
7602 arg1 = reinterpret_cast< wxRect * >(argp1);
7603 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7604 if (!SWIG_IsOK(ecode2)) {
7605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7606 }
7607 arg2 = static_cast< int >(val2);
7608 if (arg1) (arg1)->x = arg2;
7609
7610 resultobj = SWIG_Py_Void();
7611 return resultobj;
7612 fail:
7613 return NULL;
7614 }
7615
7616
7617 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7618 PyObject *resultobj = 0;
7619 wxRect *arg1 = (wxRect *) 0 ;
7620 int result;
7621 void *argp1 = 0 ;
7622 int res1 = 0 ;
7623 PyObject *swig_obj[1] ;
7624
7625 if (!args) SWIG_fail;
7626 swig_obj[0] = args;
7627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7628 if (!SWIG_IsOK(res1)) {
7629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7630 }
7631 arg1 = reinterpret_cast< wxRect * >(argp1);
7632 result = (int) ((arg1)->x);
7633 resultobj = SWIG_From_int(static_cast< int >(result));
7634 return resultobj;
7635 fail:
7636 return NULL;
7637 }
7638
7639
7640 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7641 PyObject *resultobj = 0;
7642 wxRect *arg1 = (wxRect *) 0 ;
7643 int arg2 ;
7644 void *argp1 = 0 ;
7645 int res1 = 0 ;
7646 int val2 ;
7647 int ecode2 = 0 ;
7648 PyObject *swig_obj[2] ;
7649
7650 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7652 if (!SWIG_IsOK(res1)) {
7653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7654 }
7655 arg1 = reinterpret_cast< wxRect * >(argp1);
7656 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7657 if (!SWIG_IsOK(ecode2)) {
7658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7659 }
7660 arg2 = static_cast< int >(val2);
7661 if (arg1) (arg1)->y = arg2;
7662
7663 resultobj = SWIG_Py_Void();
7664 return resultobj;
7665 fail:
7666 return NULL;
7667 }
7668
7669
7670 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7671 PyObject *resultobj = 0;
7672 wxRect *arg1 = (wxRect *) 0 ;
7673 int result;
7674 void *argp1 = 0 ;
7675 int res1 = 0 ;
7676 PyObject *swig_obj[1] ;
7677
7678 if (!args) SWIG_fail;
7679 swig_obj[0] = args;
7680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7681 if (!SWIG_IsOK(res1)) {
7682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7683 }
7684 arg1 = reinterpret_cast< wxRect * >(argp1);
7685 result = (int) ((arg1)->y);
7686 resultobj = SWIG_From_int(static_cast< int >(result));
7687 return resultobj;
7688 fail:
7689 return NULL;
7690 }
7691
7692
7693 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7694 PyObject *resultobj = 0;
7695 wxRect *arg1 = (wxRect *) 0 ;
7696 int arg2 ;
7697 void *argp1 = 0 ;
7698 int res1 = 0 ;
7699 int val2 ;
7700 int ecode2 = 0 ;
7701 PyObject *swig_obj[2] ;
7702
7703 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7705 if (!SWIG_IsOK(res1)) {
7706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7707 }
7708 arg1 = reinterpret_cast< wxRect * >(argp1);
7709 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7710 if (!SWIG_IsOK(ecode2)) {
7711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7712 }
7713 arg2 = static_cast< int >(val2);
7714 if (arg1) (arg1)->width = arg2;
7715
7716 resultobj = SWIG_Py_Void();
7717 return resultobj;
7718 fail:
7719 return NULL;
7720 }
7721
7722
7723 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7724 PyObject *resultobj = 0;
7725 wxRect *arg1 = (wxRect *) 0 ;
7726 int result;
7727 void *argp1 = 0 ;
7728 int res1 = 0 ;
7729 PyObject *swig_obj[1] ;
7730
7731 if (!args) SWIG_fail;
7732 swig_obj[0] = args;
7733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7734 if (!SWIG_IsOK(res1)) {
7735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7736 }
7737 arg1 = reinterpret_cast< wxRect * >(argp1);
7738 result = (int) ((arg1)->width);
7739 resultobj = SWIG_From_int(static_cast< int >(result));
7740 return resultobj;
7741 fail:
7742 return NULL;
7743 }
7744
7745
7746 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7747 PyObject *resultobj = 0;
7748 wxRect *arg1 = (wxRect *) 0 ;
7749 int arg2 ;
7750 void *argp1 = 0 ;
7751 int res1 = 0 ;
7752 int val2 ;
7753 int ecode2 = 0 ;
7754 PyObject *swig_obj[2] ;
7755
7756 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7758 if (!SWIG_IsOK(res1)) {
7759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7760 }
7761 arg1 = reinterpret_cast< wxRect * >(argp1);
7762 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7763 if (!SWIG_IsOK(ecode2)) {
7764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7765 }
7766 arg2 = static_cast< int >(val2);
7767 if (arg1) (arg1)->height = arg2;
7768
7769 resultobj = SWIG_Py_Void();
7770 return resultobj;
7771 fail:
7772 return NULL;
7773 }
7774
7775
7776 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7777 PyObject *resultobj = 0;
7778 wxRect *arg1 = (wxRect *) 0 ;
7779 int result;
7780 void *argp1 = 0 ;
7781 int res1 = 0 ;
7782 PyObject *swig_obj[1] ;
7783
7784 if (!args) SWIG_fail;
7785 swig_obj[0] = args;
7786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7787 if (!SWIG_IsOK(res1)) {
7788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7789 }
7790 arg1 = reinterpret_cast< wxRect * >(argp1);
7791 result = (int) ((arg1)->height);
7792 resultobj = SWIG_From_int(static_cast< int >(result));
7793 return resultobj;
7794 fail:
7795 return NULL;
7796 }
7797
7798
7799 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7800 PyObject *resultobj = 0;
7801 wxRect *arg1 = (wxRect *) 0 ;
7802 int arg2 = (int) 0 ;
7803 int arg3 = (int) 0 ;
7804 int arg4 = (int) 0 ;
7805 int arg5 = (int) 0 ;
7806 void *argp1 = 0 ;
7807 int res1 = 0 ;
7808 int val2 ;
7809 int ecode2 = 0 ;
7810 int val3 ;
7811 int ecode3 = 0 ;
7812 int val4 ;
7813 int ecode4 = 0 ;
7814 int val5 ;
7815 int ecode5 = 0 ;
7816 PyObject * obj0 = 0 ;
7817 PyObject * obj1 = 0 ;
7818 PyObject * obj2 = 0 ;
7819 PyObject * obj3 = 0 ;
7820 PyObject * obj4 = 0 ;
7821 char * kwnames[] = {
7822 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7823 };
7824
7825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7827 if (!SWIG_IsOK(res1)) {
7828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7829 }
7830 arg1 = reinterpret_cast< wxRect * >(argp1);
7831 if (obj1) {
7832 ecode2 = SWIG_AsVal_int(obj1, &val2);
7833 if (!SWIG_IsOK(ecode2)) {
7834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7835 }
7836 arg2 = static_cast< int >(val2);
7837 }
7838 if (obj2) {
7839 ecode3 = SWIG_AsVal_int(obj2, &val3);
7840 if (!SWIG_IsOK(ecode3)) {
7841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7842 }
7843 arg3 = static_cast< int >(val3);
7844 }
7845 if (obj3) {
7846 ecode4 = SWIG_AsVal_int(obj3, &val4);
7847 if (!SWIG_IsOK(ecode4)) {
7848 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7849 }
7850 arg4 = static_cast< int >(val4);
7851 }
7852 if (obj4) {
7853 ecode5 = SWIG_AsVal_int(obj4, &val5);
7854 if (!SWIG_IsOK(ecode5)) {
7855 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7856 }
7857 arg5 = static_cast< int >(val5);
7858 }
7859 {
7860 PyThreadState* __tstate = wxPyBeginAllowThreads();
7861 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7862 wxPyEndAllowThreads(__tstate);
7863 if (PyErr_Occurred()) SWIG_fail;
7864 }
7865 resultobj = SWIG_Py_Void();
7866 return resultobj;
7867 fail:
7868 return NULL;
7869 }
7870
7871
7872 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7873 PyObject *resultobj = 0;
7874 wxRect *arg1 = (wxRect *) 0 ;
7875 PyObject *result = 0 ;
7876 void *argp1 = 0 ;
7877 int res1 = 0 ;
7878 PyObject *swig_obj[1] ;
7879
7880 if (!args) SWIG_fail;
7881 swig_obj[0] = args;
7882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7883 if (!SWIG_IsOK(res1)) {
7884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7885 }
7886 arg1 = reinterpret_cast< wxRect * >(argp1);
7887 {
7888 PyThreadState* __tstate = wxPyBeginAllowThreads();
7889 result = (PyObject *)wxRect_Get(arg1);
7890 wxPyEndAllowThreads(__tstate);
7891 if (PyErr_Occurred()) SWIG_fail;
7892 }
7893 resultobj = result;
7894 return resultobj;
7895 fail:
7896 return NULL;
7897 }
7898
7899
7900 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7901 PyObject *obj;
7902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7903 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7904 return SWIG_Py_Void();
7905 }
7906
7907 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7908 return SWIG_Python_InitShadowInstance(args);
7909 }
7910
7911 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7912 PyObject *resultobj = 0;
7913 wxRect *arg1 = (wxRect *) 0 ;
7914 wxRect *arg2 = (wxRect *) 0 ;
7915 PyObject *result = 0 ;
7916 void *argp1 = 0 ;
7917 int res1 = 0 ;
7918 void *argp2 = 0 ;
7919 int res2 = 0 ;
7920 PyObject * obj0 = 0 ;
7921 PyObject * obj1 = 0 ;
7922 char * kwnames[] = {
7923 (char *) "r1",(char *) "r2", NULL
7924 };
7925
7926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7928 if (!SWIG_IsOK(res1)) {
7929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7930 }
7931 arg1 = reinterpret_cast< wxRect * >(argp1);
7932 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7933 if (!SWIG_IsOK(res2)) {
7934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7935 }
7936 arg2 = reinterpret_cast< wxRect * >(argp2);
7937 {
7938 if (!wxPyCheckForApp()) SWIG_fail;
7939 PyThreadState* __tstate = wxPyBeginAllowThreads();
7940 result = (PyObject *)wxIntersectRect(arg1,arg2);
7941 wxPyEndAllowThreads(__tstate);
7942 if (PyErr_Occurred()) SWIG_fail;
7943 }
7944 resultobj = result;
7945 return resultobj;
7946 fail:
7947 return NULL;
7948 }
7949
7950
7951 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7952 PyObject *resultobj = 0;
7953 double arg1 = (double) 0.0 ;
7954 double arg2 = (double) 0.0 ;
7955 wxPoint2D *result = 0 ;
7956 double val1 ;
7957 int ecode1 = 0 ;
7958 double val2 ;
7959 int ecode2 = 0 ;
7960 PyObject * obj0 = 0 ;
7961 PyObject * obj1 = 0 ;
7962 char * kwnames[] = {
7963 (char *) "x",(char *) "y", NULL
7964 };
7965
7966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7967 if (obj0) {
7968 ecode1 = SWIG_AsVal_double(obj0, &val1);
7969 if (!SWIG_IsOK(ecode1)) {
7970 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7971 }
7972 arg1 = static_cast< double >(val1);
7973 }
7974 if (obj1) {
7975 ecode2 = SWIG_AsVal_double(obj1, &val2);
7976 if (!SWIG_IsOK(ecode2)) {
7977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7978 }
7979 arg2 = static_cast< double >(val2);
7980 }
7981 {
7982 PyThreadState* __tstate = wxPyBeginAllowThreads();
7983 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7984 wxPyEndAllowThreads(__tstate);
7985 if (PyErr_Occurred()) SWIG_fail;
7986 }
7987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7988 return resultobj;
7989 fail:
7990 return NULL;
7991 }
7992
7993
7994 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7995 PyObject *resultobj = 0;
7996 wxPoint2D *arg1 = 0 ;
7997 wxPoint2D *result = 0 ;
7998 wxPoint2D temp1 ;
7999 PyObject * obj0 = 0 ;
8000 char * kwnames[] = {
8001 (char *) "pt", NULL
8002 };
8003
8004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8005 {
8006 arg1 = &temp1;
8007 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8008 }
8009 {
8010 PyThreadState* __tstate = wxPyBeginAllowThreads();
8011 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8012 wxPyEndAllowThreads(__tstate);
8013 if (PyErr_Occurred()) SWIG_fail;
8014 }
8015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8016 return resultobj;
8017 fail:
8018 return NULL;
8019 }
8020
8021
8022 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8023 PyObject *resultobj = 0;
8024 wxPoint *arg1 = 0 ;
8025 wxPoint2D *result = 0 ;
8026 wxPoint temp1 ;
8027 PyObject * obj0 = 0 ;
8028 char * kwnames[] = {
8029 (char *) "pt", NULL
8030 };
8031
8032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8033 {
8034 arg1 = &temp1;
8035 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8036 }
8037 {
8038 PyThreadState* __tstate = wxPyBeginAllowThreads();
8039 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8040 wxPyEndAllowThreads(__tstate);
8041 if (PyErr_Occurred()) SWIG_fail;
8042 }
8043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8044 return resultobj;
8045 fail:
8046 return NULL;
8047 }
8048
8049
8050 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8051 PyObject *resultobj = 0;
8052 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8053 int *arg2 = (int *) 0 ;
8054 int *arg3 = (int *) 0 ;
8055 void *argp1 = 0 ;
8056 int res1 = 0 ;
8057 int temp2 ;
8058 int res2 = SWIG_TMPOBJ ;
8059 int temp3 ;
8060 int res3 = SWIG_TMPOBJ ;
8061 PyObject *swig_obj[1] ;
8062
8063 arg2 = &temp2;
8064 arg3 = &temp3;
8065 if (!args) SWIG_fail;
8066 swig_obj[0] = args;
8067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8068 if (!SWIG_IsOK(res1)) {
8069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8070 }
8071 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8072 {
8073 PyThreadState* __tstate = wxPyBeginAllowThreads();
8074 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8075 wxPyEndAllowThreads(__tstate);
8076 if (PyErr_Occurred()) SWIG_fail;
8077 }
8078 resultobj = SWIG_Py_Void();
8079 if (SWIG_IsTmpObj(res2)) {
8080 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8081 } else {
8082 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8084 }
8085 if (SWIG_IsTmpObj(res3)) {
8086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8087 } else {
8088 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8090 }
8091 return resultobj;
8092 fail:
8093 return NULL;
8094 }
8095
8096
8097 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8098 PyObject *resultobj = 0;
8099 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8100 int *arg2 = (int *) 0 ;
8101 int *arg3 = (int *) 0 ;
8102 void *argp1 = 0 ;
8103 int res1 = 0 ;
8104 int temp2 ;
8105 int res2 = SWIG_TMPOBJ ;
8106 int temp3 ;
8107 int res3 = SWIG_TMPOBJ ;
8108 PyObject *swig_obj[1] ;
8109
8110 arg2 = &temp2;
8111 arg3 = &temp3;
8112 if (!args) SWIG_fail;
8113 swig_obj[0] = args;
8114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8115 if (!SWIG_IsOK(res1)) {
8116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8117 }
8118 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8119 {
8120 PyThreadState* __tstate = wxPyBeginAllowThreads();
8121 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8122 wxPyEndAllowThreads(__tstate);
8123 if (PyErr_Occurred()) SWIG_fail;
8124 }
8125 resultobj = SWIG_Py_Void();
8126 if (SWIG_IsTmpObj(res2)) {
8127 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8128 } else {
8129 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8130 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8131 }
8132 if (SWIG_IsTmpObj(res3)) {
8133 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8134 } else {
8135 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8136 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8137 }
8138 return resultobj;
8139 fail:
8140 return NULL;
8141 }
8142
8143
8144 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8145 PyObject *resultobj = 0;
8146 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8147 double result;
8148 void *argp1 = 0 ;
8149 int res1 = 0 ;
8150 PyObject *swig_obj[1] ;
8151
8152 if (!args) SWIG_fail;
8153 swig_obj[0] = args;
8154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8155 if (!SWIG_IsOK(res1)) {
8156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8157 }
8158 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8159 {
8160 PyThreadState* __tstate = wxPyBeginAllowThreads();
8161 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8162 wxPyEndAllowThreads(__tstate);
8163 if (PyErr_Occurred()) SWIG_fail;
8164 }
8165 resultobj = SWIG_From_double(static_cast< double >(result));
8166 return resultobj;
8167 fail:
8168 return NULL;
8169 }
8170
8171
8172 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8173 PyObject *resultobj = 0;
8174 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8175 double result;
8176 void *argp1 = 0 ;
8177 int res1 = 0 ;
8178 PyObject *swig_obj[1] ;
8179
8180 if (!args) SWIG_fail;
8181 swig_obj[0] = args;
8182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8183 if (!SWIG_IsOK(res1)) {
8184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8185 }
8186 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8187 {
8188 PyThreadState* __tstate = wxPyBeginAllowThreads();
8189 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8190 wxPyEndAllowThreads(__tstate);
8191 if (PyErr_Occurred()) SWIG_fail;
8192 }
8193 resultobj = SWIG_From_double(static_cast< double >(result));
8194 return resultobj;
8195 fail:
8196 return NULL;
8197 }
8198
8199
8200 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8201 PyObject *resultobj = 0;
8202 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8203 double arg2 ;
8204 void *argp1 = 0 ;
8205 int res1 = 0 ;
8206 double val2 ;
8207 int ecode2 = 0 ;
8208 PyObject * obj0 = 0 ;
8209 PyObject * obj1 = 0 ;
8210 char * kwnames[] = {
8211 (char *) "self",(char *) "length", NULL
8212 };
8213
8214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8216 if (!SWIG_IsOK(res1)) {
8217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8218 }
8219 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8220 ecode2 = SWIG_AsVal_double(obj1, &val2);
8221 if (!SWIG_IsOK(ecode2)) {
8222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8223 }
8224 arg2 = static_cast< double >(val2);
8225 {
8226 PyThreadState* __tstate = wxPyBeginAllowThreads();
8227 (arg1)->SetVectorLength(arg2);
8228 wxPyEndAllowThreads(__tstate);
8229 if (PyErr_Occurred()) SWIG_fail;
8230 }
8231 resultobj = SWIG_Py_Void();
8232 return resultobj;
8233 fail:
8234 return NULL;
8235 }
8236
8237
8238 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8239 PyObject *resultobj = 0;
8240 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8241 double arg2 ;
8242 void *argp1 = 0 ;
8243 int res1 = 0 ;
8244 double val2 ;
8245 int ecode2 = 0 ;
8246 PyObject * obj0 = 0 ;
8247 PyObject * obj1 = 0 ;
8248 char * kwnames[] = {
8249 (char *) "self",(char *) "degrees", NULL
8250 };
8251
8252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8254 if (!SWIG_IsOK(res1)) {
8255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8256 }
8257 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8258 ecode2 = SWIG_AsVal_double(obj1, &val2);
8259 if (!SWIG_IsOK(ecode2)) {
8260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8261 }
8262 arg2 = static_cast< double >(val2);
8263 {
8264 PyThreadState* __tstate = wxPyBeginAllowThreads();
8265 (arg1)->SetVectorAngle(arg2);
8266 wxPyEndAllowThreads(__tstate);
8267 if (PyErr_Occurred()) SWIG_fail;
8268 }
8269 resultobj = SWIG_Py_Void();
8270 return resultobj;
8271 fail:
8272 return NULL;
8273 }
8274
8275
8276 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8277 PyObject *resultobj = 0;
8278 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8279 wxPoint2D *arg2 = 0 ;
8280 double result;
8281 void *argp1 = 0 ;
8282 int res1 = 0 ;
8283 wxPoint2D temp2 ;
8284 PyObject * obj0 = 0 ;
8285 PyObject * obj1 = 0 ;
8286 char * kwnames[] = {
8287 (char *) "self",(char *) "pt", NULL
8288 };
8289
8290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8292 if (!SWIG_IsOK(res1)) {
8293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8294 }
8295 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8296 {
8297 arg2 = &temp2;
8298 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8299 }
8300 {
8301 PyThreadState* __tstate = wxPyBeginAllowThreads();
8302 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8303 wxPyEndAllowThreads(__tstate);
8304 if (PyErr_Occurred()) SWIG_fail;
8305 }
8306 resultobj = SWIG_From_double(static_cast< double >(result));
8307 return resultobj;
8308 fail:
8309 return NULL;
8310 }
8311
8312
8313 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8314 PyObject *resultobj = 0;
8315 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8316 wxPoint2D *arg2 = 0 ;
8317 double result;
8318 void *argp1 = 0 ;
8319 int res1 = 0 ;
8320 wxPoint2D temp2 ;
8321 PyObject * obj0 = 0 ;
8322 PyObject * obj1 = 0 ;
8323 char * kwnames[] = {
8324 (char *) "self",(char *) "pt", NULL
8325 };
8326
8327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8329 if (!SWIG_IsOK(res1)) {
8330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8331 }
8332 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8333 {
8334 arg2 = &temp2;
8335 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8336 }
8337 {
8338 PyThreadState* __tstate = wxPyBeginAllowThreads();
8339 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8340 wxPyEndAllowThreads(__tstate);
8341 if (PyErr_Occurred()) SWIG_fail;
8342 }
8343 resultobj = SWIG_From_double(static_cast< double >(result));
8344 return resultobj;
8345 fail:
8346 return NULL;
8347 }
8348
8349
8350 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8351 PyObject *resultobj = 0;
8352 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8353 wxPoint2D *arg2 = 0 ;
8354 double result;
8355 void *argp1 = 0 ;
8356 int res1 = 0 ;
8357 wxPoint2D temp2 ;
8358 PyObject * obj0 = 0 ;
8359 PyObject * obj1 = 0 ;
8360 char * kwnames[] = {
8361 (char *) "self",(char *) "vec", NULL
8362 };
8363
8364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8366 if (!SWIG_IsOK(res1)) {
8367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8368 }
8369 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8370 {
8371 arg2 = &temp2;
8372 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8373 }
8374 {
8375 PyThreadState* __tstate = wxPyBeginAllowThreads();
8376 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8377 wxPyEndAllowThreads(__tstate);
8378 if (PyErr_Occurred()) SWIG_fail;
8379 }
8380 resultobj = SWIG_From_double(static_cast< double >(result));
8381 return resultobj;
8382 fail:
8383 return NULL;
8384 }
8385
8386
8387 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8388 PyObject *resultobj = 0;
8389 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8390 wxPoint2D *arg2 = 0 ;
8391 double result;
8392 void *argp1 = 0 ;
8393 int res1 = 0 ;
8394 wxPoint2D temp2 ;
8395 PyObject * obj0 = 0 ;
8396 PyObject * obj1 = 0 ;
8397 char * kwnames[] = {
8398 (char *) "self",(char *) "vec", NULL
8399 };
8400
8401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8403 if (!SWIG_IsOK(res1)) {
8404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8405 }
8406 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8407 {
8408 arg2 = &temp2;
8409 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8410 }
8411 {
8412 PyThreadState* __tstate = wxPyBeginAllowThreads();
8413 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8414 wxPyEndAllowThreads(__tstate);
8415 if (PyErr_Occurred()) SWIG_fail;
8416 }
8417 resultobj = SWIG_From_double(static_cast< double >(result));
8418 return resultobj;
8419 fail:
8420 return NULL;
8421 }
8422
8423
8424 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8425 PyObject *resultobj = 0;
8426 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8427 wxPoint2D result;
8428 void *argp1 = 0 ;
8429 int res1 = 0 ;
8430 PyObject *swig_obj[1] ;
8431
8432 if (!args) SWIG_fail;
8433 swig_obj[0] = args;
8434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8435 if (!SWIG_IsOK(res1)) {
8436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8437 }
8438 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8439 {
8440 PyThreadState* __tstate = wxPyBeginAllowThreads();
8441 result = (arg1)->operator -();
8442 wxPyEndAllowThreads(__tstate);
8443 if (PyErr_Occurred()) SWIG_fail;
8444 }
8445 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8446 return resultobj;
8447 fail:
8448 return NULL;
8449 }
8450
8451
8452 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8453 PyObject *resultobj = 0;
8454 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8455 wxPoint2D *arg2 = 0 ;
8456 wxPoint2D *result = 0 ;
8457 void *argp1 = 0 ;
8458 int res1 = 0 ;
8459 wxPoint2D temp2 ;
8460 PyObject * obj0 = 0 ;
8461 PyObject * obj1 = 0 ;
8462 char * kwnames[] = {
8463 (char *) "self",(char *) "pt", NULL
8464 };
8465
8466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8468 if (!SWIG_IsOK(res1)) {
8469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8470 }
8471 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8472 {
8473 arg2 = &temp2;
8474 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8475 }
8476 {
8477 PyThreadState* __tstate = wxPyBeginAllowThreads();
8478 {
8479 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8480 result = (wxPoint2D *) &_result_ref;
8481 }
8482 wxPyEndAllowThreads(__tstate);
8483 if (PyErr_Occurred()) SWIG_fail;
8484 }
8485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8486 return resultobj;
8487 fail:
8488 return NULL;
8489 }
8490
8491
8492 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8493 PyObject *resultobj = 0;
8494 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8495 wxPoint2D *arg2 = 0 ;
8496 wxPoint2D *result = 0 ;
8497 void *argp1 = 0 ;
8498 int res1 = 0 ;
8499 wxPoint2D temp2 ;
8500 PyObject * obj0 = 0 ;
8501 PyObject * obj1 = 0 ;
8502 char * kwnames[] = {
8503 (char *) "self",(char *) "pt", NULL
8504 };
8505
8506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8508 if (!SWIG_IsOK(res1)) {
8509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8510 }
8511 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8512 {
8513 arg2 = &temp2;
8514 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8515 }
8516 {
8517 PyThreadState* __tstate = wxPyBeginAllowThreads();
8518 {
8519 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8520 result = (wxPoint2D *) &_result_ref;
8521 }
8522 wxPyEndAllowThreads(__tstate);
8523 if (PyErr_Occurred()) SWIG_fail;
8524 }
8525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8526 return resultobj;
8527 fail:
8528 return NULL;
8529 }
8530
8531
8532 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8533 PyObject *resultobj = 0;
8534 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8535 wxPoint2D *arg2 = 0 ;
8536 wxPoint2D *result = 0 ;
8537 void *argp1 = 0 ;
8538 int res1 = 0 ;
8539 wxPoint2D temp2 ;
8540 PyObject * obj0 = 0 ;
8541 PyObject * obj1 = 0 ;
8542 char * kwnames[] = {
8543 (char *) "self",(char *) "pt", NULL
8544 };
8545
8546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8548 if (!SWIG_IsOK(res1)) {
8549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8550 }
8551 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8552 {
8553 arg2 = &temp2;
8554 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8555 }
8556 {
8557 PyThreadState* __tstate = wxPyBeginAllowThreads();
8558 {
8559 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8560 result = (wxPoint2D *) &_result_ref;
8561 }
8562 wxPyEndAllowThreads(__tstate);
8563 if (PyErr_Occurred()) SWIG_fail;
8564 }
8565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8566 return resultobj;
8567 fail:
8568 return NULL;
8569 }
8570
8571
8572 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8573 PyObject *resultobj = 0;
8574 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8575 wxPoint2D *arg2 = 0 ;
8576 wxPoint2D *result = 0 ;
8577 void *argp1 = 0 ;
8578 int res1 = 0 ;
8579 wxPoint2D temp2 ;
8580 PyObject * obj0 = 0 ;
8581 PyObject * obj1 = 0 ;
8582 char * kwnames[] = {
8583 (char *) "self",(char *) "pt", NULL
8584 };
8585
8586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8588 if (!SWIG_IsOK(res1)) {
8589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8590 }
8591 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8592 {
8593 arg2 = &temp2;
8594 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8595 }
8596 {
8597 PyThreadState* __tstate = wxPyBeginAllowThreads();
8598 {
8599 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8600 result = (wxPoint2D *) &_result_ref;
8601 }
8602 wxPyEndAllowThreads(__tstate);
8603 if (PyErr_Occurred()) SWIG_fail;
8604 }
8605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8606 return resultobj;
8607 fail:
8608 return NULL;
8609 }
8610
8611
8612 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8613 PyObject *resultobj = 0;
8614 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8615 PyObject *arg2 = (PyObject *) 0 ;
8616 bool result;
8617 void *argp1 = 0 ;
8618 int res1 = 0 ;
8619 PyObject * obj0 = 0 ;
8620 PyObject * obj1 = 0 ;
8621 char * kwnames[] = {
8622 (char *) "self",(char *) "other", NULL
8623 };
8624
8625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8627 if (!SWIG_IsOK(res1)) {
8628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8629 }
8630 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8631 arg2 = obj1;
8632 {
8633 result = (bool)wxPoint2D___eq__(arg1,arg2);
8634 if (PyErr_Occurred()) SWIG_fail;
8635 }
8636 {
8637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8638 }
8639 return resultobj;
8640 fail:
8641 return NULL;
8642 }
8643
8644
8645 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8646 PyObject *resultobj = 0;
8647 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8648 PyObject *arg2 = (PyObject *) 0 ;
8649 bool result;
8650 void *argp1 = 0 ;
8651 int res1 = 0 ;
8652 PyObject * obj0 = 0 ;
8653 PyObject * obj1 = 0 ;
8654 char * kwnames[] = {
8655 (char *) "self",(char *) "other", NULL
8656 };
8657
8658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8660 if (!SWIG_IsOK(res1)) {
8661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8662 }
8663 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8664 arg2 = obj1;
8665 {
8666 result = (bool)wxPoint2D___ne__(arg1,arg2);
8667 if (PyErr_Occurred()) SWIG_fail;
8668 }
8669 {
8670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8671 }
8672 return resultobj;
8673 fail:
8674 return NULL;
8675 }
8676
8677
8678 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8679 PyObject *resultobj = 0;
8680 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8681 double arg2 ;
8682 void *argp1 = 0 ;
8683 int res1 = 0 ;
8684 double val2 ;
8685 int ecode2 = 0 ;
8686 PyObject *swig_obj[2] ;
8687
8688 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8690 if (!SWIG_IsOK(res1)) {
8691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8692 }
8693 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8694 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8695 if (!SWIG_IsOK(ecode2)) {
8696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8697 }
8698 arg2 = static_cast< double >(val2);
8699 if (arg1) (arg1)->m_x = arg2;
8700
8701 resultobj = SWIG_Py_Void();
8702 return resultobj;
8703 fail:
8704 return NULL;
8705 }
8706
8707
8708 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8709 PyObject *resultobj = 0;
8710 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8711 double result;
8712 void *argp1 = 0 ;
8713 int res1 = 0 ;
8714 PyObject *swig_obj[1] ;
8715
8716 if (!args) SWIG_fail;
8717 swig_obj[0] = args;
8718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8719 if (!SWIG_IsOK(res1)) {
8720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8721 }
8722 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8723 result = (double) ((arg1)->m_x);
8724 resultobj = SWIG_From_double(static_cast< double >(result));
8725 return resultobj;
8726 fail:
8727 return NULL;
8728 }
8729
8730
8731 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8732 PyObject *resultobj = 0;
8733 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8734 double arg2 ;
8735 void *argp1 = 0 ;
8736 int res1 = 0 ;
8737 double val2 ;
8738 int ecode2 = 0 ;
8739 PyObject *swig_obj[2] ;
8740
8741 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8743 if (!SWIG_IsOK(res1)) {
8744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8745 }
8746 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8747 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8748 if (!SWIG_IsOK(ecode2)) {
8749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8750 }
8751 arg2 = static_cast< double >(val2);
8752 if (arg1) (arg1)->m_y = arg2;
8753
8754 resultobj = SWIG_Py_Void();
8755 return resultobj;
8756 fail:
8757 return NULL;
8758 }
8759
8760
8761 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8762 PyObject *resultobj = 0;
8763 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8764 double result;
8765 void *argp1 = 0 ;
8766 int res1 = 0 ;
8767 PyObject *swig_obj[1] ;
8768
8769 if (!args) SWIG_fail;
8770 swig_obj[0] = args;
8771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8772 if (!SWIG_IsOK(res1)) {
8773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8774 }
8775 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8776 result = (double) ((arg1)->m_y);
8777 resultobj = SWIG_From_double(static_cast< double >(result));
8778 return resultobj;
8779 fail:
8780 return NULL;
8781 }
8782
8783
8784 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8785 PyObject *resultobj = 0;
8786 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8787 double arg2 = (double) 0 ;
8788 double arg3 = (double) 0 ;
8789 void *argp1 = 0 ;
8790 int res1 = 0 ;
8791 double val2 ;
8792 int ecode2 = 0 ;
8793 double val3 ;
8794 int ecode3 = 0 ;
8795 PyObject * obj0 = 0 ;
8796 PyObject * obj1 = 0 ;
8797 PyObject * obj2 = 0 ;
8798 char * kwnames[] = {
8799 (char *) "self",(char *) "x",(char *) "y", NULL
8800 };
8801
8802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8804 if (!SWIG_IsOK(res1)) {
8805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8806 }
8807 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8808 if (obj1) {
8809 ecode2 = SWIG_AsVal_double(obj1, &val2);
8810 if (!SWIG_IsOK(ecode2)) {
8811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8812 }
8813 arg2 = static_cast< double >(val2);
8814 }
8815 if (obj2) {
8816 ecode3 = SWIG_AsVal_double(obj2, &val3);
8817 if (!SWIG_IsOK(ecode3)) {
8818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8819 }
8820 arg3 = static_cast< double >(val3);
8821 }
8822 {
8823 PyThreadState* __tstate = wxPyBeginAllowThreads();
8824 wxPoint2D_Set(arg1,arg2,arg3);
8825 wxPyEndAllowThreads(__tstate);
8826 if (PyErr_Occurred()) SWIG_fail;
8827 }
8828 resultobj = SWIG_Py_Void();
8829 return resultobj;
8830 fail:
8831 return NULL;
8832 }
8833
8834
8835 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8836 PyObject *resultobj = 0;
8837 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8838 PyObject *result = 0 ;
8839 void *argp1 = 0 ;
8840 int res1 = 0 ;
8841 PyObject *swig_obj[1] ;
8842
8843 if (!args) SWIG_fail;
8844 swig_obj[0] = args;
8845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8846 if (!SWIG_IsOK(res1)) {
8847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8848 }
8849 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8850 {
8851 PyThreadState* __tstate = wxPyBeginAllowThreads();
8852 result = (PyObject *)wxPoint2D_Get(arg1);
8853 wxPyEndAllowThreads(__tstate);
8854 if (PyErr_Occurred()) SWIG_fail;
8855 }
8856 resultobj = result;
8857 return resultobj;
8858 fail:
8859 return NULL;
8860 }
8861
8862
8863 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8864 PyObject *obj;
8865 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8866 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8867 return SWIG_Py_Void();
8868 }
8869
8870 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8871 return SWIG_Python_InitShadowInstance(args);
8872 }
8873
8874 SWIGINTERN int DefaultPosition_set(PyObject *) {
8875 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8876 return 1;
8877 }
8878
8879
8880 SWIGINTERN PyObject *DefaultPosition_get(void) {
8881 PyObject *pyobj = 0;
8882
8883 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8884 return pyobj;
8885 }
8886
8887
8888 SWIGINTERN int DefaultSize_set(PyObject *) {
8889 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8890 return 1;
8891 }
8892
8893
8894 SWIGINTERN PyObject *DefaultSize_get(void) {
8895 PyObject *pyobj = 0;
8896
8897 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8898 return pyobj;
8899 }
8900
8901
8902 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8903 PyObject *resultobj = 0;
8904 PyObject *arg1 = (PyObject *) 0 ;
8905 wxPyInputStream *result = 0 ;
8906 PyObject * obj0 = 0 ;
8907 char * kwnames[] = {
8908 (char *) "p", NULL
8909 };
8910
8911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8912 arg1 = obj0;
8913 {
8914 PyThreadState* __tstate = wxPyBeginAllowThreads();
8915 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8916 wxPyEndAllowThreads(__tstate);
8917 if (PyErr_Occurred()) SWIG_fail;
8918 }
8919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8920 return resultobj;
8921 fail:
8922 return NULL;
8923 }
8924
8925
8926 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8927 PyObject *resultobj = 0;
8928 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8929 void *argp1 = 0 ;
8930 int res1 = 0 ;
8931 PyObject *swig_obj[1] ;
8932
8933 if (!args) SWIG_fail;
8934 swig_obj[0] = args;
8935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8936 if (!SWIG_IsOK(res1)) {
8937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8938 }
8939 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8940 {
8941 PyThreadState* __tstate = wxPyBeginAllowThreads();
8942 delete arg1;
8943
8944 wxPyEndAllowThreads(__tstate);
8945 if (PyErr_Occurred()) SWIG_fail;
8946 }
8947 resultobj = SWIG_Py_Void();
8948 return resultobj;
8949 fail:
8950 return NULL;
8951 }
8952
8953
8954 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8955 PyObject *resultobj = 0;
8956 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8957 void *argp1 = 0 ;
8958 int res1 = 0 ;
8959 PyObject *swig_obj[1] ;
8960
8961 if (!args) SWIG_fail;
8962 swig_obj[0] = args;
8963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8964 if (!SWIG_IsOK(res1)) {
8965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8966 }
8967 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8968 {
8969 PyThreadState* __tstate = wxPyBeginAllowThreads();
8970 (arg1)->close();
8971 wxPyEndAllowThreads(__tstate);
8972 if (PyErr_Occurred()) SWIG_fail;
8973 }
8974 resultobj = SWIG_Py_Void();
8975 return resultobj;
8976 fail:
8977 return NULL;
8978 }
8979
8980
8981 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8982 PyObject *resultobj = 0;
8983 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8984 void *argp1 = 0 ;
8985 int res1 = 0 ;
8986 PyObject *swig_obj[1] ;
8987
8988 if (!args) SWIG_fail;
8989 swig_obj[0] = args;
8990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8991 if (!SWIG_IsOK(res1)) {
8992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8993 }
8994 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8995 {
8996 PyThreadState* __tstate = wxPyBeginAllowThreads();
8997 (arg1)->flush();
8998 wxPyEndAllowThreads(__tstate);
8999 if (PyErr_Occurred()) SWIG_fail;
9000 }
9001 resultobj = SWIG_Py_Void();
9002 return resultobj;
9003 fail:
9004 return NULL;
9005 }
9006
9007
9008 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9009 PyObject *resultobj = 0;
9010 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9011 bool result;
9012 void *argp1 = 0 ;
9013 int res1 = 0 ;
9014 PyObject *swig_obj[1] ;
9015
9016 if (!args) SWIG_fail;
9017 swig_obj[0] = args;
9018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9019 if (!SWIG_IsOK(res1)) {
9020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9021 }
9022 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9023 {
9024 PyThreadState* __tstate = wxPyBeginAllowThreads();
9025 result = (bool)(arg1)->eof();
9026 wxPyEndAllowThreads(__tstate);
9027 if (PyErr_Occurred()) SWIG_fail;
9028 }
9029 {
9030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9031 }
9032 return resultobj;
9033 fail:
9034 return NULL;
9035 }
9036
9037
9038 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9039 PyObject *resultobj = 0;
9040 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9041 int arg2 = (int) -1 ;
9042 PyObject *result = 0 ;
9043 void *argp1 = 0 ;
9044 int res1 = 0 ;
9045 int val2 ;
9046 int ecode2 = 0 ;
9047 PyObject * obj0 = 0 ;
9048 PyObject * obj1 = 0 ;
9049 char * kwnames[] = {
9050 (char *) "self",(char *) "size", NULL
9051 };
9052
9053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9055 if (!SWIG_IsOK(res1)) {
9056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9057 }
9058 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9059 if (obj1) {
9060 ecode2 = SWIG_AsVal_int(obj1, &val2);
9061 if (!SWIG_IsOK(ecode2)) {
9062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9063 }
9064 arg2 = static_cast< int >(val2);
9065 }
9066 {
9067 PyThreadState* __tstate = wxPyBeginAllowThreads();
9068 result = (PyObject *)(arg1)->read(arg2);
9069 wxPyEndAllowThreads(__tstate);
9070 if (PyErr_Occurred()) SWIG_fail;
9071 }
9072 resultobj = result;
9073 return resultobj;
9074 fail:
9075 return NULL;
9076 }
9077
9078
9079 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9080 PyObject *resultobj = 0;
9081 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9082 int arg2 = (int) -1 ;
9083 PyObject *result = 0 ;
9084 void *argp1 = 0 ;
9085 int res1 = 0 ;
9086 int val2 ;
9087 int ecode2 = 0 ;
9088 PyObject * obj0 = 0 ;
9089 PyObject * obj1 = 0 ;
9090 char * kwnames[] = {
9091 (char *) "self",(char *) "size", NULL
9092 };
9093
9094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9096 if (!SWIG_IsOK(res1)) {
9097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9098 }
9099 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9100 if (obj1) {
9101 ecode2 = SWIG_AsVal_int(obj1, &val2);
9102 if (!SWIG_IsOK(ecode2)) {
9103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9104 }
9105 arg2 = static_cast< int >(val2);
9106 }
9107 {
9108 PyThreadState* __tstate = wxPyBeginAllowThreads();
9109 result = (PyObject *)(arg1)->readline(arg2);
9110 wxPyEndAllowThreads(__tstate);
9111 if (PyErr_Occurred()) SWIG_fail;
9112 }
9113 resultobj = result;
9114 return resultobj;
9115 fail:
9116 return NULL;
9117 }
9118
9119
9120 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9121 PyObject *resultobj = 0;
9122 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9123 int arg2 = (int) -1 ;
9124 PyObject *result = 0 ;
9125 void *argp1 = 0 ;
9126 int res1 = 0 ;
9127 int val2 ;
9128 int ecode2 = 0 ;
9129 PyObject * obj0 = 0 ;
9130 PyObject * obj1 = 0 ;
9131 char * kwnames[] = {
9132 (char *) "self",(char *) "sizehint", NULL
9133 };
9134
9135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9137 if (!SWIG_IsOK(res1)) {
9138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9139 }
9140 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9141 if (obj1) {
9142 ecode2 = SWIG_AsVal_int(obj1, &val2);
9143 if (!SWIG_IsOK(ecode2)) {
9144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9145 }
9146 arg2 = static_cast< int >(val2);
9147 }
9148 {
9149 PyThreadState* __tstate = wxPyBeginAllowThreads();
9150 result = (PyObject *)(arg1)->readlines(arg2);
9151 wxPyEndAllowThreads(__tstate);
9152 if (PyErr_Occurred()) SWIG_fail;
9153 }
9154 resultobj = result;
9155 return resultobj;
9156 fail:
9157 return NULL;
9158 }
9159
9160
9161 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9162 PyObject *resultobj = 0;
9163 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9164 int arg2 ;
9165 int arg3 = (int) 0 ;
9166 void *argp1 = 0 ;
9167 int res1 = 0 ;
9168 int val2 ;
9169 int ecode2 = 0 ;
9170 int val3 ;
9171 int ecode3 = 0 ;
9172 PyObject * obj0 = 0 ;
9173 PyObject * obj1 = 0 ;
9174 PyObject * obj2 = 0 ;
9175 char * kwnames[] = {
9176 (char *) "self",(char *) "offset",(char *) "whence", NULL
9177 };
9178
9179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9181 if (!SWIG_IsOK(res1)) {
9182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9183 }
9184 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9185 ecode2 = SWIG_AsVal_int(obj1, &val2);
9186 if (!SWIG_IsOK(ecode2)) {
9187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9188 }
9189 arg2 = static_cast< int >(val2);
9190 if (obj2) {
9191 ecode3 = SWIG_AsVal_int(obj2, &val3);
9192 if (!SWIG_IsOK(ecode3)) {
9193 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9194 }
9195 arg3 = static_cast< int >(val3);
9196 }
9197 {
9198 PyThreadState* __tstate = wxPyBeginAllowThreads();
9199 (arg1)->seek(arg2,arg3);
9200 wxPyEndAllowThreads(__tstate);
9201 if (PyErr_Occurred()) SWIG_fail;
9202 }
9203 resultobj = SWIG_Py_Void();
9204 return resultobj;
9205 fail:
9206 return NULL;
9207 }
9208
9209
9210 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9211 PyObject *resultobj = 0;
9212 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9213 int result;
9214 void *argp1 = 0 ;
9215 int res1 = 0 ;
9216 PyObject *swig_obj[1] ;
9217
9218 if (!args) SWIG_fail;
9219 swig_obj[0] = args;
9220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9221 if (!SWIG_IsOK(res1)) {
9222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9223 }
9224 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9225 {
9226 PyThreadState* __tstate = wxPyBeginAllowThreads();
9227 result = (int)(arg1)->tell();
9228 wxPyEndAllowThreads(__tstate);
9229 if (PyErr_Occurred()) SWIG_fail;
9230 }
9231 resultobj = SWIG_From_int(static_cast< int >(result));
9232 return resultobj;
9233 fail:
9234 return NULL;
9235 }
9236
9237
9238 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9239 PyObject *resultobj = 0;
9240 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9241 char result;
9242 void *argp1 = 0 ;
9243 int res1 = 0 ;
9244 PyObject *swig_obj[1] ;
9245
9246 if (!args) SWIG_fail;
9247 swig_obj[0] = args;
9248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9249 if (!SWIG_IsOK(res1)) {
9250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9251 }
9252 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9253 {
9254 PyThreadState* __tstate = wxPyBeginAllowThreads();
9255 result = (char)(arg1)->Peek();
9256 wxPyEndAllowThreads(__tstate);
9257 if (PyErr_Occurred()) SWIG_fail;
9258 }
9259 resultobj = SWIG_From_char(static_cast< char >(result));
9260 return resultobj;
9261 fail:
9262 return NULL;
9263 }
9264
9265
9266 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9267 PyObject *resultobj = 0;
9268 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9269 char result;
9270 void *argp1 = 0 ;
9271 int res1 = 0 ;
9272 PyObject *swig_obj[1] ;
9273
9274 if (!args) SWIG_fail;
9275 swig_obj[0] = args;
9276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9277 if (!SWIG_IsOK(res1)) {
9278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9279 }
9280 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9281 {
9282 PyThreadState* __tstate = wxPyBeginAllowThreads();
9283 result = (char)(arg1)->GetC();
9284 wxPyEndAllowThreads(__tstate);
9285 if (PyErr_Occurred()) SWIG_fail;
9286 }
9287 resultobj = SWIG_From_char(static_cast< char >(result));
9288 return resultobj;
9289 fail:
9290 return NULL;
9291 }
9292
9293
9294 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9295 PyObject *resultobj = 0;
9296 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9297 size_t result;
9298 void *argp1 = 0 ;
9299 int res1 = 0 ;
9300 PyObject *swig_obj[1] ;
9301
9302 if (!args) SWIG_fail;
9303 swig_obj[0] = args;
9304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9305 if (!SWIG_IsOK(res1)) {
9306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9307 }
9308 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9309 {
9310 PyThreadState* __tstate = wxPyBeginAllowThreads();
9311 result = (size_t)(arg1)->LastRead();
9312 wxPyEndAllowThreads(__tstate);
9313 if (PyErr_Occurred()) SWIG_fail;
9314 }
9315 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9316 return resultobj;
9317 fail:
9318 return NULL;
9319 }
9320
9321
9322 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9323 PyObject *resultobj = 0;
9324 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9325 bool result;
9326 void *argp1 = 0 ;
9327 int res1 = 0 ;
9328 PyObject *swig_obj[1] ;
9329
9330 if (!args) SWIG_fail;
9331 swig_obj[0] = args;
9332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9333 if (!SWIG_IsOK(res1)) {
9334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9335 }
9336 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9337 {
9338 PyThreadState* __tstate = wxPyBeginAllowThreads();
9339 result = (bool)(arg1)->CanRead();
9340 wxPyEndAllowThreads(__tstate);
9341 if (PyErr_Occurred()) SWIG_fail;
9342 }
9343 {
9344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9345 }
9346 return resultobj;
9347 fail:
9348 return NULL;
9349 }
9350
9351
9352 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9353 PyObject *resultobj = 0;
9354 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9355 bool result;
9356 void *argp1 = 0 ;
9357 int res1 = 0 ;
9358 PyObject *swig_obj[1] ;
9359
9360 if (!args) SWIG_fail;
9361 swig_obj[0] = args;
9362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9363 if (!SWIG_IsOK(res1)) {
9364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9365 }
9366 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9367 {
9368 PyThreadState* __tstate = wxPyBeginAllowThreads();
9369 result = (bool)(arg1)->Eof();
9370 wxPyEndAllowThreads(__tstate);
9371 if (PyErr_Occurred()) SWIG_fail;
9372 }
9373 {
9374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9375 }
9376 return resultobj;
9377 fail:
9378 return NULL;
9379 }
9380
9381
9382 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9383 PyObject *resultobj = 0;
9384 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9385 char arg2 ;
9386 bool result;
9387 void *argp1 = 0 ;
9388 int res1 = 0 ;
9389 char val2 ;
9390 int ecode2 = 0 ;
9391 PyObject * obj0 = 0 ;
9392 PyObject * obj1 = 0 ;
9393 char * kwnames[] = {
9394 (char *) "self",(char *) "c", NULL
9395 };
9396
9397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9399 if (!SWIG_IsOK(res1)) {
9400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9401 }
9402 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9403 ecode2 = SWIG_AsVal_char(obj1, &val2);
9404 if (!SWIG_IsOK(ecode2)) {
9405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9406 }
9407 arg2 = static_cast< char >(val2);
9408 {
9409 PyThreadState* __tstate = wxPyBeginAllowThreads();
9410 result = (bool)(arg1)->Ungetch(arg2);
9411 wxPyEndAllowThreads(__tstate);
9412 if (PyErr_Occurred()) SWIG_fail;
9413 }
9414 {
9415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9416 }
9417 return resultobj;
9418 fail:
9419 return NULL;
9420 }
9421
9422
9423 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9424 PyObject *resultobj = 0;
9425 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9426 long arg2 ;
9427 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9428 long result;
9429 void *argp1 = 0 ;
9430 int res1 = 0 ;
9431 long val2 ;
9432 int ecode2 = 0 ;
9433 int val3 ;
9434 int ecode3 = 0 ;
9435 PyObject * obj0 = 0 ;
9436 PyObject * obj1 = 0 ;
9437 PyObject * obj2 = 0 ;
9438 char * kwnames[] = {
9439 (char *) "self",(char *) "pos",(char *) "mode", NULL
9440 };
9441
9442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9444 if (!SWIG_IsOK(res1)) {
9445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9446 }
9447 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9448 ecode2 = SWIG_AsVal_long(obj1, &val2);
9449 if (!SWIG_IsOK(ecode2)) {
9450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9451 }
9452 arg2 = static_cast< long >(val2);
9453 if (obj2) {
9454 ecode3 = SWIG_AsVal_int(obj2, &val3);
9455 if (!SWIG_IsOK(ecode3)) {
9456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9457 }
9458 arg3 = static_cast< wxSeekMode >(val3);
9459 }
9460 {
9461 PyThreadState* __tstate = wxPyBeginAllowThreads();
9462 result = (long)(arg1)->SeekI(arg2,arg3);
9463 wxPyEndAllowThreads(__tstate);
9464 if (PyErr_Occurred()) SWIG_fail;
9465 }
9466 resultobj = SWIG_From_long(static_cast< long >(result));
9467 return resultobj;
9468 fail:
9469 return NULL;
9470 }
9471
9472
9473 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9474 PyObject *resultobj = 0;
9475 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9476 long result;
9477 void *argp1 = 0 ;
9478 int res1 = 0 ;
9479 PyObject *swig_obj[1] ;
9480
9481 if (!args) SWIG_fail;
9482 swig_obj[0] = args;
9483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9484 if (!SWIG_IsOK(res1)) {
9485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9486 }
9487 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9488 {
9489 PyThreadState* __tstate = wxPyBeginAllowThreads();
9490 result = (long)(arg1)->TellI();
9491 wxPyEndAllowThreads(__tstate);
9492 if (PyErr_Occurred()) SWIG_fail;
9493 }
9494 resultobj = SWIG_From_long(static_cast< long >(result));
9495 return resultobj;
9496 fail:
9497 return NULL;
9498 }
9499
9500
9501 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9502 PyObject *obj;
9503 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9504 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9505 return SWIG_Py_Void();
9506 }
9507
9508 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9509 return SWIG_Python_InitShadowInstance(args);
9510 }
9511
9512 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9513 PyObject *resultobj = 0;
9514 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9515 PyObject *arg2 = (PyObject *) 0 ;
9516 void *argp1 = 0 ;
9517 int res1 = 0 ;
9518 PyObject * obj0 = 0 ;
9519 PyObject * obj1 = 0 ;
9520 char * kwnames[] = {
9521 (char *) "self",(char *) "obj", NULL
9522 };
9523
9524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9526 if (!SWIG_IsOK(res1)) {
9527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9528 }
9529 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9530 arg2 = obj1;
9531 {
9532 PyThreadState* __tstate = wxPyBeginAllowThreads();
9533 wxOutputStream_write(arg1,arg2);
9534 wxPyEndAllowThreads(__tstate);
9535 if (PyErr_Occurred()) SWIG_fail;
9536 }
9537 resultobj = SWIG_Py_Void();
9538 return resultobj;
9539 fail:
9540 return NULL;
9541 }
9542
9543
9544 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9545 PyObject *resultobj = 0;
9546 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9547 size_t result;
9548 void *argp1 = 0 ;
9549 int res1 = 0 ;
9550 PyObject *swig_obj[1] ;
9551
9552 if (!args) SWIG_fail;
9553 swig_obj[0] = args;
9554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9555 if (!SWIG_IsOK(res1)) {
9556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9557 }
9558 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9559 {
9560 PyThreadState* __tstate = wxPyBeginAllowThreads();
9561 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9562 wxPyEndAllowThreads(__tstate);
9563 if (PyErr_Occurred()) SWIG_fail;
9564 }
9565 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9566 return resultobj;
9567 fail:
9568 return NULL;
9569 }
9570
9571
9572 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9573 PyObject *obj;
9574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9575 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9576 return SWIG_Py_Void();
9577 }
9578
9579 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9580 PyObject *resultobj = 0;
9581 wxInputStream *arg1 = (wxInputStream *) 0 ;
9582 wxString *arg2 = 0 ;
9583 wxString *arg3 = 0 ;
9584 wxString *arg4 = 0 ;
9585 wxDateTime arg5 ;
9586 wxFSFile *result = 0 ;
9587 wxPyInputStream *temp1 ;
9588 bool temp2 = false ;
9589 bool temp3 = false ;
9590 bool temp4 = false ;
9591 void *argp5 ;
9592 int res5 = 0 ;
9593 PyObject * obj0 = 0 ;
9594 PyObject * obj1 = 0 ;
9595 PyObject * obj2 = 0 ;
9596 PyObject * obj3 = 0 ;
9597 PyObject * obj4 = 0 ;
9598 char * kwnames[] = {
9599 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9600 };
9601
9602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9603 {
9604 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9605 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9606 } else {
9607 PyErr_Clear(); // clear the failure of the wxPyConvert above
9608 arg1 = wxPyCBInputStream_create(obj0, true);
9609 if (arg1 == NULL) {
9610 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9611 SWIG_fail;
9612 }
9613 }
9614 }
9615 {
9616 arg2 = wxString_in_helper(obj1);
9617 if (arg2 == NULL) SWIG_fail;
9618 temp2 = true;
9619 }
9620 {
9621 arg3 = wxString_in_helper(obj2);
9622 if (arg3 == NULL) SWIG_fail;
9623 temp3 = true;
9624 }
9625 {
9626 arg4 = wxString_in_helper(obj3);
9627 if (arg4 == NULL) SWIG_fail;
9628 temp4 = true;
9629 }
9630 {
9631 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9632 if (!SWIG_IsOK(res5)) {
9633 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9634 }
9635 if (!argp5) {
9636 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9637 } else {
9638 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9639 arg5 = *temp;
9640 if (SWIG_IsNewObj(res5)) delete temp;
9641 }
9642 }
9643 {
9644 PyThreadState* __tstate = wxPyBeginAllowThreads();
9645 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9646 wxPyEndAllowThreads(__tstate);
9647 if (PyErr_Occurred()) SWIG_fail;
9648 }
9649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9650 {
9651 if (temp2)
9652 delete arg2;
9653 }
9654 {
9655 if (temp3)
9656 delete arg3;
9657 }
9658 {
9659 if (temp4)
9660 delete arg4;
9661 }
9662 return resultobj;
9663 fail:
9664 {
9665 if (temp2)
9666 delete arg2;
9667 }
9668 {
9669 if (temp3)
9670 delete arg3;
9671 }
9672 {
9673 if (temp4)
9674 delete arg4;
9675 }
9676 return NULL;
9677 }
9678
9679
9680 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9681 PyObject *resultobj = 0;
9682 wxFSFile *arg1 = (wxFSFile *) 0 ;
9683 void *argp1 = 0 ;
9684 int res1 = 0 ;
9685 PyObject *swig_obj[1] ;
9686
9687 if (!args) SWIG_fail;
9688 swig_obj[0] = args;
9689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9690 if (!SWIG_IsOK(res1)) {
9691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9692 }
9693 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9694 {
9695 PyThreadState* __tstate = wxPyBeginAllowThreads();
9696 delete arg1;
9697
9698 wxPyEndAllowThreads(__tstate);
9699 if (PyErr_Occurred()) SWIG_fail;
9700 }
9701 resultobj = SWIG_Py_Void();
9702 return resultobj;
9703 fail:
9704 return NULL;
9705 }
9706
9707
9708 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9709 PyObject *resultobj = 0;
9710 wxFSFile *arg1 = (wxFSFile *) 0 ;
9711 wxInputStream *result = 0 ;
9712 void *argp1 = 0 ;
9713 int res1 = 0 ;
9714 PyObject *swig_obj[1] ;
9715
9716 if (!args) SWIG_fail;
9717 swig_obj[0] = args;
9718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9719 if (!SWIG_IsOK(res1)) {
9720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9721 }
9722 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9723 {
9724 PyThreadState* __tstate = wxPyBeginAllowThreads();
9725 result = (wxInputStream *)(arg1)->GetStream();
9726 wxPyEndAllowThreads(__tstate);
9727 if (PyErr_Occurred()) SWIG_fail;
9728 }
9729 {
9730 wxPyInputStream * _ptr = NULL;
9731
9732 if (result) {
9733 _ptr = new wxPyInputStream(result);
9734 }
9735 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9736 }
9737 return resultobj;
9738 fail:
9739 return NULL;
9740 }
9741
9742
9743 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9744 PyObject *resultobj = 0;
9745 wxFSFile *arg1 = (wxFSFile *) 0 ;
9746 wxString *result = 0 ;
9747 void *argp1 = 0 ;
9748 int res1 = 0 ;
9749 PyObject *swig_obj[1] ;
9750
9751 if (!args) SWIG_fail;
9752 swig_obj[0] = args;
9753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9754 if (!SWIG_IsOK(res1)) {
9755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9756 }
9757 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9758 {
9759 PyThreadState* __tstate = wxPyBeginAllowThreads();
9760 {
9761 wxString const &_result_ref = (arg1)->GetMimeType();
9762 result = (wxString *) &_result_ref;
9763 }
9764 wxPyEndAllowThreads(__tstate);
9765 if (PyErr_Occurred()) SWIG_fail;
9766 }
9767 {
9768 #if wxUSE_UNICODE
9769 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9770 #else
9771 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9772 #endif
9773 }
9774 return resultobj;
9775 fail:
9776 return NULL;
9777 }
9778
9779
9780 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9781 PyObject *resultobj = 0;
9782 wxFSFile *arg1 = (wxFSFile *) 0 ;
9783 wxString *result = 0 ;
9784 void *argp1 = 0 ;
9785 int res1 = 0 ;
9786 PyObject *swig_obj[1] ;
9787
9788 if (!args) SWIG_fail;
9789 swig_obj[0] = args;
9790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9791 if (!SWIG_IsOK(res1)) {
9792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9793 }
9794 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9795 {
9796 PyThreadState* __tstate = wxPyBeginAllowThreads();
9797 {
9798 wxString const &_result_ref = (arg1)->GetLocation();
9799 result = (wxString *) &_result_ref;
9800 }
9801 wxPyEndAllowThreads(__tstate);
9802 if (PyErr_Occurred()) SWIG_fail;
9803 }
9804 {
9805 #if wxUSE_UNICODE
9806 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9807 #else
9808 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9809 #endif
9810 }
9811 return resultobj;
9812 fail:
9813 return NULL;
9814 }
9815
9816
9817 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9818 PyObject *resultobj = 0;
9819 wxFSFile *arg1 = (wxFSFile *) 0 ;
9820 wxString *result = 0 ;
9821 void *argp1 = 0 ;
9822 int res1 = 0 ;
9823 PyObject *swig_obj[1] ;
9824
9825 if (!args) SWIG_fail;
9826 swig_obj[0] = args;
9827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9828 if (!SWIG_IsOK(res1)) {
9829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9830 }
9831 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9832 {
9833 PyThreadState* __tstate = wxPyBeginAllowThreads();
9834 {
9835 wxString const &_result_ref = (arg1)->GetAnchor();
9836 result = (wxString *) &_result_ref;
9837 }
9838 wxPyEndAllowThreads(__tstate);
9839 if (PyErr_Occurred()) SWIG_fail;
9840 }
9841 {
9842 #if wxUSE_UNICODE
9843 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9844 #else
9845 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9846 #endif
9847 }
9848 return resultobj;
9849 fail:
9850 return NULL;
9851 }
9852
9853
9854 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9855 PyObject *resultobj = 0;
9856 wxFSFile *arg1 = (wxFSFile *) 0 ;
9857 wxDateTime result;
9858 void *argp1 = 0 ;
9859 int res1 = 0 ;
9860 PyObject *swig_obj[1] ;
9861
9862 if (!args) SWIG_fail;
9863 swig_obj[0] = args;
9864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9865 if (!SWIG_IsOK(res1)) {
9866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9867 }
9868 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9869 {
9870 PyThreadState* __tstate = wxPyBeginAllowThreads();
9871 result = (arg1)->GetModificationTime();
9872 wxPyEndAllowThreads(__tstate);
9873 if (PyErr_Occurred()) SWIG_fail;
9874 }
9875 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9876 return resultobj;
9877 fail:
9878 return NULL;
9879 }
9880
9881
9882 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9883 PyObject *obj;
9884 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9885 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9886 return SWIG_Py_Void();
9887 }
9888
9889 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9890 return SWIG_Python_InitShadowInstance(args);
9891 }
9892
9893 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9894 PyObject *resultobj = 0;
9895 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9896 void *argp1 = 0 ;
9897 int res1 = 0 ;
9898 PyObject *swig_obj[1] ;
9899
9900 if (!args) SWIG_fail;
9901 swig_obj[0] = args;
9902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9903 if (!SWIG_IsOK(res1)) {
9904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9905 }
9906 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9907 {
9908 PyThreadState* __tstate = wxPyBeginAllowThreads();
9909 delete arg1;
9910
9911 wxPyEndAllowThreads(__tstate);
9912 if (PyErr_Occurred()) SWIG_fail;
9913 }
9914 resultobj = SWIG_Py_Void();
9915 return resultobj;
9916 fail:
9917 return NULL;
9918 }
9919
9920
9921 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9922 PyObject *obj;
9923 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9924 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9925 return SWIG_Py_Void();
9926 }
9927
9928 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9929 PyObject *resultobj = 0;
9930 wxPyFileSystemHandler *result = 0 ;
9931
9932 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9933 {
9934 PyThreadState* __tstate = wxPyBeginAllowThreads();
9935 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9936 wxPyEndAllowThreads(__tstate);
9937 if (PyErr_Occurred()) SWIG_fail;
9938 }
9939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9940 return resultobj;
9941 fail:
9942 return NULL;
9943 }
9944
9945
9946 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9947 PyObject *resultobj = 0;
9948 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9949 PyObject *arg2 = (PyObject *) 0 ;
9950 PyObject *arg3 = (PyObject *) 0 ;
9951 void *argp1 = 0 ;
9952 int res1 = 0 ;
9953 PyObject * obj0 = 0 ;
9954 PyObject * obj1 = 0 ;
9955 PyObject * obj2 = 0 ;
9956 char * kwnames[] = {
9957 (char *) "self",(char *) "self",(char *) "_class", NULL
9958 };
9959
9960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9962 if (!SWIG_IsOK(res1)) {
9963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9964 }
9965 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9966 arg2 = obj1;
9967 arg3 = obj2;
9968 {
9969 PyThreadState* __tstate = wxPyBeginAllowThreads();
9970 (arg1)->_setCallbackInfo(arg2,arg3);
9971 wxPyEndAllowThreads(__tstate);
9972 if (PyErr_Occurred()) SWIG_fail;
9973 }
9974 resultobj = SWIG_Py_Void();
9975 return resultobj;
9976 fail:
9977 return NULL;
9978 }
9979
9980
9981 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9982 PyObject *resultobj = 0;
9983 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9984 wxString *arg2 = 0 ;
9985 bool result;
9986 void *argp1 = 0 ;
9987 int res1 = 0 ;
9988 bool temp2 = false ;
9989 PyObject * obj0 = 0 ;
9990 PyObject * obj1 = 0 ;
9991 char * kwnames[] = {
9992 (char *) "self",(char *) "location", NULL
9993 };
9994
9995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
9996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9997 if (!SWIG_IsOK(res1)) {
9998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9999 }
10000 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10001 {
10002 arg2 = wxString_in_helper(obj1);
10003 if (arg2 == NULL) SWIG_fail;
10004 temp2 = true;
10005 }
10006 {
10007 PyThreadState* __tstate = wxPyBeginAllowThreads();
10008 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10009 wxPyEndAllowThreads(__tstate);
10010 if (PyErr_Occurred()) SWIG_fail;
10011 }
10012 {
10013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10014 }
10015 {
10016 if (temp2)
10017 delete arg2;
10018 }
10019 return resultobj;
10020 fail:
10021 {
10022 if (temp2)
10023 delete arg2;
10024 }
10025 return NULL;
10026 }
10027
10028
10029 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10030 PyObject *resultobj = 0;
10031 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10032 wxFileSystem *arg2 = 0 ;
10033 wxString *arg3 = 0 ;
10034 wxFSFile *result = 0 ;
10035 void *argp1 = 0 ;
10036 int res1 = 0 ;
10037 void *argp2 = 0 ;
10038 int res2 = 0 ;
10039 bool temp3 = false ;
10040 PyObject * obj0 = 0 ;
10041 PyObject * obj1 = 0 ;
10042 PyObject * obj2 = 0 ;
10043 char * kwnames[] = {
10044 (char *) "self",(char *) "fs",(char *) "location", NULL
10045 };
10046
10047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10049 if (!SWIG_IsOK(res1)) {
10050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10051 }
10052 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10053 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10054 if (!SWIG_IsOK(res2)) {
10055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10056 }
10057 if (!argp2) {
10058 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10059 }
10060 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10061 {
10062 arg3 = wxString_in_helper(obj2);
10063 if (arg3 == NULL) SWIG_fail;
10064 temp3 = true;
10065 }
10066 {
10067 PyThreadState* __tstate = wxPyBeginAllowThreads();
10068 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10069 wxPyEndAllowThreads(__tstate);
10070 if (PyErr_Occurred()) SWIG_fail;
10071 }
10072 {
10073 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10074 }
10075 {
10076 if (temp3)
10077 delete arg3;
10078 }
10079 return resultobj;
10080 fail:
10081 {
10082 if (temp3)
10083 delete arg3;
10084 }
10085 return NULL;
10086 }
10087
10088
10089 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10090 PyObject *resultobj = 0;
10091 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10092 wxString *arg2 = 0 ;
10093 int arg3 = (int) 0 ;
10094 wxString result;
10095 void *argp1 = 0 ;
10096 int res1 = 0 ;
10097 bool temp2 = false ;
10098 int val3 ;
10099 int ecode3 = 0 ;
10100 PyObject * obj0 = 0 ;
10101 PyObject * obj1 = 0 ;
10102 PyObject * obj2 = 0 ;
10103 char * kwnames[] = {
10104 (char *) "self",(char *) "spec",(char *) "flags", NULL
10105 };
10106
10107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10109 if (!SWIG_IsOK(res1)) {
10110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10111 }
10112 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10113 {
10114 arg2 = wxString_in_helper(obj1);
10115 if (arg2 == NULL) SWIG_fail;
10116 temp2 = true;
10117 }
10118 if (obj2) {
10119 ecode3 = SWIG_AsVal_int(obj2, &val3);
10120 if (!SWIG_IsOK(ecode3)) {
10121 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10122 }
10123 arg3 = static_cast< int >(val3);
10124 }
10125 {
10126 PyThreadState* __tstate = wxPyBeginAllowThreads();
10127 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10128 wxPyEndAllowThreads(__tstate);
10129 if (PyErr_Occurred()) SWIG_fail;
10130 }
10131 {
10132 #if wxUSE_UNICODE
10133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10134 #else
10135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10136 #endif
10137 }
10138 {
10139 if (temp2)
10140 delete arg2;
10141 }
10142 return resultobj;
10143 fail:
10144 {
10145 if (temp2)
10146 delete arg2;
10147 }
10148 return NULL;
10149 }
10150
10151
10152 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10153 PyObject *resultobj = 0;
10154 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10155 wxString result;
10156 void *argp1 = 0 ;
10157 int res1 = 0 ;
10158 PyObject *swig_obj[1] ;
10159
10160 if (!args) SWIG_fail;
10161 swig_obj[0] = args;
10162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10163 if (!SWIG_IsOK(res1)) {
10164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10165 }
10166 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10167 {
10168 PyThreadState* __tstate = wxPyBeginAllowThreads();
10169 result = (arg1)->FindNext();
10170 wxPyEndAllowThreads(__tstate);
10171 if (PyErr_Occurred()) SWIG_fail;
10172 }
10173 {
10174 #if wxUSE_UNICODE
10175 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10176 #else
10177 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10178 #endif
10179 }
10180 return resultobj;
10181 fail:
10182 return NULL;
10183 }
10184
10185
10186 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10187 PyObject *resultobj = 0;
10188 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10189 wxString *arg2 = 0 ;
10190 wxString result;
10191 void *argp1 = 0 ;
10192 int res1 = 0 ;
10193 bool temp2 = false ;
10194 PyObject * obj0 = 0 ;
10195 PyObject * obj1 = 0 ;
10196 char * kwnames[] = {
10197 (char *) "self",(char *) "location", NULL
10198 };
10199
10200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10202 if (!SWIG_IsOK(res1)) {
10203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10204 }
10205 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10206 {
10207 arg2 = wxString_in_helper(obj1);
10208 if (arg2 == NULL) SWIG_fail;
10209 temp2 = true;
10210 }
10211 {
10212 PyThreadState* __tstate = wxPyBeginAllowThreads();
10213 result = (arg1)->GetProtocol((wxString const &)*arg2);
10214 wxPyEndAllowThreads(__tstate);
10215 if (PyErr_Occurred()) SWIG_fail;
10216 }
10217 {
10218 #if wxUSE_UNICODE
10219 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10220 #else
10221 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10222 #endif
10223 }
10224 {
10225 if (temp2)
10226 delete arg2;
10227 }
10228 return resultobj;
10229 fail:
10230 {
10231 if (temp2)
10232 delete arg2;
10233 }
10234 return NULL;
10235 }
10236
10237
10238 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10239 PyObject *resultobj = 0;
10240 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10241 wxString *arg2 = 0 ;
10242 wxString result;
10243 void *argp1 = 0 ;
10244 int res1 = 0 ;
10245 bool temp2 = false ;
10246 PyObject * obj0 = 0 ;
10247 PyObject * obj1 = 0 ;
10248 char * kwnames[] = {
10249 (char *) "self",(char *) "location", NULL
10250 };
10251
10252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10254 if (!SWIG_IsOK(res1)) {
10255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10256 }
10257 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10258 {
10259 arg2 = wxString_in_helper(obj1);
10260 if (arg2 == NULL) SWIG_fail;
10261 temp2 = true;
10262 }
10263 {
10264 PyThreadState* __tstate = wxPyBeginAllowThreads();
10265 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10266 wxPyEndAllowThreads(__tstate);
10267 if (PyErr_Occurred()) SWIG_fail;
10268 }
10269 {
10270 #if wxUSE_UNICODE
10271 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10272 #else
10273 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10274 #endif
10275 }
10276 {
10277 if (temp2)
10278 delete arg2;
10279 }
10280 return resultobj;
10281 fail:
10282 {
10283 if (temp2)
10284 delete arg2;
10285 }
10286 return NULL;
10287 }
10288
10289
10290 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10291 PyObject *resultobj = 0;
10292 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10293 wxString *arg2 = 0 ;
10294 wxString result;
10295 void *argp1 = 0 ;
10296 int res1 = 0 ;
10297 bool temp2 = false ;
10298 PyObject * obj0 = 0 ;
10299 PyObject * obj1 = 0 ;
10300 char * kwnames[] = {
10301 (char *) "self",(char *) "location", NULL
10302 };
10303
10304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10306 if (!SWIG_IsOK(res1)) {
10307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10308 }
10309 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10310 {
10311 arg2 = wxString_in_helper(obj1);
10312 if (arg2 == NULL) SWIG_fail;
10313 temp2 = true;
10314 }
10315 {
10316 PyThreadState* __tstate = wxPyBeginAllowThreads();
10317 result = (arg1)->GetAnchor((wxString const &)*arg2);
10318 wxPyEndAllowThreads(__tstate);
10319 if (PyErr_Occurred()) SWIG_fail;
10320 }
10321 {
10322 #if wxUSE_UNICODE
10323 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10324 #else
10325 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10326 #endif
10327 }
10328 {
10329 if (temp2)
10330 delete arg2;
10331 }
10332 return resultobj;
10333 fail:
10334 {
10335 if (temp2)
10336 delete arg2;
10337 }
10338 return NULL;
10339 }
10340
10341
10342 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10343 PyObject *resultobj = 0;
10344 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10345 wxString *arg2 = 0 ;
10346 wxString result;
10347 void *argp1 = 0 ;
10348 int res1 = 0 ;
10349 bool temp2 = false ;
10350 PyObject * obj0 = 0 ;
10351 PyObject * obj1 = 0 ;
10352 char * kwnames[] = {
10353 (char *) "self",(char *) "location", NULL
10354 };
10355
10356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10358 if (!SWIG_IsOK(res1)) {
10359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10360 }
10361 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10362 {
10363 arg2 = wxString_in_helper(obj1);
10364 if (arg2 == NULL) SWIG_fail;
10365 temp2 = true;
10366 }
10367 {
10368 PyThreadState* __tstate = wxPyBeginAllowThreads();
10369 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10370 wxPyEndAllowThreads(__tstate);
10371 if (PyErr_Occurred()) SWIG_fail;
10372 }
10373 {
10374 #if wxUSE_UNICODE
10375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10376 #else
10377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10378 #endif
10379 }
10380 {
10381 if (temp2)
10382 delete arg2;
10383 }
10384 return resultobj;
10385 fail:
10386 {
10387 if (temp2)
10388 delete arg2;
10389 }
10390 return NULL;
10391 }
10392
10393
10394 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10395 PyObject *resultobj = 0;
10396 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10397 wxString *arg2 = 0 ;
10398 wxString result;
10399 void *argp1 = 0 ;
10400 int res1 = 0 ;
10401 bool temp2 = false ;
10402 PyObject * obj0 = 0 ;
10403 PyObject * obj1 = 0 ;
10404 char * kwnames[] = {
10405 (char *) "self",(char *) "location", NULL
10406 };
10407
10408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10410 if (!SWIG_IsOK(res1)) {
10411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10412 }
10413 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10414 {
10415 arg2 = wxString_in_helper(obj1);
10416 if (arg2 == NULL) SWIG_fail;
10417 temp2 = true;
10418 }
10419 {
10420 PyThreadState* __tstate = wxPyBeginAllowThreads();
10421 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10422 wxPyEndAllowThreads(__tstate);
10423 if (PyErr_Occurred()) SWIG_fail;
10424 }
10425 {
10426 #if wxUSE_UNICODE
10427 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10428 #else
10429 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10430 #endif
10431 }
10432 {
10433 if (temp2)
10434 delete arg2;
10435 }
10436 return resultobj;
10437 fail:
10438 {
10439 if (temp2)
10440 delete arg2;
10441 }
10442 return NULL;
10443 }
10444
10445
10446 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10447 PyObject *obj;
10448 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10449 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10450 return SWIG_Py_Void();
10451 }
10452
10453 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10454 return SWIG_Python_InitShadowInstance(args);
10455 }
10456
10457 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10458 PyObject *resultobj = 0;
10459 wxFileSystem *result = 0 ;
10460
10461 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10462 {
10463 PyThreadState* __tstate = wxPyBeginAllowThreads();
10464 result = (wxFileSystem *)new wxFileSystem();
10465 wxPyEndAllowThreads(__tstate);
10466 if (PyErr_Occurred()) SWIG_fail;
10467 }
10468 {
10469 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10470 }
10471 return resultobj;
10472 fail:
10473 return NULL;
10474 }
10475
10476
10477 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10478 PyObject *resultobj = 0;
10479 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10480 void *argp1 = 0 ;
10481 int res1 = 0 ;
10482 PyObject *swig_obj[1] ;
10483
10484 if (!args) SWIG_fail;
10485 swig_obj[0] = args;
10486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10487 if (!SWIG_IsOK(res1)) {
10488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10489 }
10490 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10491 {
10492 PyThreadState* __tstate = wxPyBeginAllowThreads();
10493 delete arg1;
10494
10495 wxPyEndAllowThreads(__tstate);
10496 if (PyErr_Occurred()) SWIG_fail;
10497 }
10498 resultobj = SWIG_Py_Void();
10499 return resultobj;
10500 fail:
10501 return NULL;
10502 }
10503
10504
10505 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10506 PyObject *resultobj = 0;
10507 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10508 wxString *arg2 = 0 ;
10509 bool arg3 = (bool) false ;
10510 void *argp1 = 0 ;
10511 int res1 = 0 ;
10512 bool temp2 = false ;
10513 bool val3 ;
10514 int ecode3 = 0 ;
10515 PyObject * obj0 = 0 ;
10516 PyObject * obj1 = 0 ;
10517 PyObject * obj2 = 0 ;
10518 char * kwnames[] = {
10519 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10520 };
10521
10522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10524 if (!SWIG_IsOK(res1)) {
10525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10526 }
10527 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10528 {
10529 arg2 = wxString_in_helper(obj1);
10530 if (arg2 == NULL) SWIG_fail;
10531 temp2 = true;
10532 }
10533 if (obj2) {
10534 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10535 if (!SWIG_IsOK(ecode3)) {
10536 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10537 }
10538 arg3 = static_cast< bool >(val3);
10539 }
10540 {
10541 PyThreadState* __tstate = wxPyBeginAllowThreads();
10542 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10543 wxPyEndAllowThreads(__tstate);
10544 if (PyErr_Occurred()) SWIG_fail;
10545 }
10546 resultobj = SWIG_Py_Void();
10547 {
10548 if (temp2)
10549 delete arg2;
10550 }
10551 return resultobj;
10552 fail:
10553 {
10554 if (temp2)
10555 delete arg2;
10556 }
10557 return NULL;
10558 }
10559
10560
10561 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10562 PyObject *resultobj = 0;
10563 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10564 wxString result;
10565 void *argp1 = 0 ;
10566 int res1 = 0 ;
10567 PyObject *swig_obj[1] ;
10568
10569 if (!args) SWIG_fail;
10570 swig_obj[0] = args;
10571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10572 if (!SWIG_IsOK(res1)) {
10573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10574 }
10575 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10576 {
10577 PyThreadState* __tstate = wxPyBeginAllowThreads();
10578 result = (arg1)->GetPath();
10579 wxPyEndAllowThreads(__tstate);
10580 if (PyErr_Occurred()) SWIG_fail;
10581 }
10582 {
10583 #if wxUSE_UNICODE
10584 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10585 #else
10586 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10587 #endif
10588 }
10589 return resultobj;
10590 fail:
10591 return NULL;
10592 }
10593
10594
10595 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10596 PyObject *resultobj = 0;
10597 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10598 wxString *arg2 = 0 ;
10599 wxFSFile *result = 0 ;
10600 void *argp1 = 0 ;
10601 int res1 = 0 ;
10602 bool temp2 = false ;
10603 PyObject * obj0 = 0 ;
10604 PyObject * obj1 = 0 ;
10605 char * kwnames[] = {
10606 (char *) "self",(char *) "location", NULL
10607 };
10608
10609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10611 if (!SWIG_IsOK(res1)) {
10612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10613 }
10614 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10615 {
10616 arg2 = wxString_in_helper(obj1);
10617 if (arg2 == NULL) SWIG_fail;
10618 temp2 = true;
10619 }
10620 {
10621 PyThreadState* __tstate = wxPyBeginAllowThreads();
10622 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10623 wxPyEndAllowThreads(__tstate);
10624 if (PyErr_Occurred()) SWIG_fail;
10625 }
10626 {
10627 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10628 }
10629 {
10630 if (temp2)
10631 delete arg2;
10632 }
10633 return resultobj;
10634 fail:
10635 {
10636 if (temp2)
10637 delete arg2;
10638 }
10639 return NULL;
10640 }
10641
10642
10643 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10644 PyObject *resultobj = 0;
10645 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10646 wxString *arg2 = 0 ;
10647 int arg3 = (int) 0 ;
10648 wxString result;
10649 void *argp1 = 0 ;
10650 int res1 = 0 ;
10651 bool temp2 = false ;
10652 int val3 ;
10653 int ecode3 = 0 ;
10654 PyObject * obj0 = 0 ;
10655 PyObject * obj1 = 0 ;
10656 PyObject * obj2 = 0 ;
10657 char * kwnames[] = {
10658 (char *) "self",(char *) "spec",(char *) "flags", NULL
10659 };
10660
10661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10663 if (!SWIG_IsOK(res1)) {
10664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10665 }
10666 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10667 {
10668 arg2 = wxString_in_helper(obj1);
10669 if (arg2 == NULL) SWIG_fail;
10670 temp2 = true;
10671 }
10672 if (obj2) {
10673 ecode3 = SWIG_AsVal_int(obj2, &val3);
10674 if (!SWIG_IsOK(ecode3)) {
10675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10676 }
10677 arg3 = static_cast< int >(val3);
10678 }
10679 {
10680 PyThreadState* __tstate = wxPyBeginAllowThreads();
10681 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10682 wxPyEndAllowThreads(__tstate);
10683 if (PyErr_Occurred()) SWIG_fail;
10684 }
10685 {
10686 #if wxUSE_UNICODE
10687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10688 #else
10689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10690 #endif
10691 }
10692 {
10693 if (temp2)
10694 delete arg2;
10695 }
10696 return resultobj;
10697 fail:
10698 {
10699 if (temp2)
10700 delete arg2;
10701 }
10702 return NULL;
10703 }
10704
10705
10706 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10707 PyObject *resultobj = 0;
10708 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10709 wxString result;
10710 void *argp1 = 0 ;
10711 int res1 = 0 ;
10712 PyObject *swig_obj[1] ;
10713
10714 if (!args) SWIG_fail;
10715 swig_obj[0] = args;
10716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10717 if (!SWIG_IsOK(res1)) {
10718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10719 }
10720 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10721 {
10722 PyThreadState* __tstate = wxPyBeginAllowThreads();
10723 result = (arg1)->FindNext();
10724 wxPyEndAllowThreads(__tstate);
10725 if (PyErr_Occurred()) SWIG_fail;
10726 }
10727 {
10728 #if wxUSE_UNICODE
10729 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10730 #else
10731 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10732 #endif
10733 }
10734 return resultobj;
10735 fail:
10736 return NULL;
10737 }
10738
10739
10740 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10741 PyObject *resultobj = 0;
10742 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10743 int res1 = 0 ;
10744 PyObject * obj0 = 0 ;
10745 char * kwnames[] = {
10746 (char *) "handler", NULL
10747 };
10748
10749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10750 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10751 if (!SWIG_IsOK(res1)) {
10752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10753 }
10754 {
10755 PyThreadState* __tstate = wxPyBeginAllowThreads();
10756 wxFileSystem::AddHandler(arg1);
10757 wxPyEndAllowThreads(__tstate);
10758 if (PyErr_Occurred()) SWIG_fail;
10759 }
10760 resultobj = SWIG_Py_Void();
10761 return resultobj;
10762 fail:
10763 return NULL;
10764 }
10765
10766
10767 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10768 PyObject *resultobj = 0;
10769
10770 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10771 {
10772 PyThreadState* __tstate = wxPyBeginAllowThreads();
10773 wxFileSystem::CleanUpHandlers();
10774 wxPyEndAllowThreads(__tstate);
10775 if (PyErr_Occurred()) SWIG_fail;
10776 }
10777 resultobj = SWIG_Py_Void();
10778 return resultobj;
10779 fail:
10780 return NULL;
10781 }
10782
10783
10784 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10785 PyObject *resultobj = 0;
10786 wxString *arg1 = 0 ;
10787 wxString result;
10788 bool temp1 = false ;
10789 PyObject * obj0 = 0 ;
10790 char * kwnames[] = {
10791 (char *) "filename", NULL
10792 };
10793
10794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10795 {
10796 arg1 = wxString_in_helper(obj0);
10797 if (arg1 == NULL) SWIG_fail;
10798 temp1 = true;
10799 }
10800 {
10801 PyThreadState* __tstate = wxPyBeginAllowThreads();
10802 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10803 wxPyEndAllowThreads(__tstate);
10804 if (PyErr_Occurred()) SWIG_fail;
10805 }
10806 {
10807 #if wxUSE_UNICODE
10808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10809 #else
10810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10811 #endif
10812 }
10813 {
10814 if (temp1)
10815 delete arg1;
10816 }
10817 return resultobj;
10818 fail:
10819 {
10820 if (temp1)
10821 delete arg1;
10822 }
10823 return NULL;
10824 }
10825
10826
10827 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10828 PyObject *resultobj = 0;
10829 wxString *arg1 = 0 ;
10830 wxString result;
10831 bool temp1 = false ;
10832 PyObject * obj0 = 0 ;
10833 char * kwnames[] = {
10834 (char *) "url", NULL
10835 };
10836
10837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10838 {
10839 arg1 = wxString_in_helper(obj0);
10840 if (arg1 == NULL) SWIG_fail;
10841 temp1 = true;
10842 }
10843 {
10844 PyThreadState* __tstate = wxPyBeginAllowThreads();
10845 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10846 wxPyEndAllowThreads(__tstate);
10847 if (PyErr_Occurred()) SWIG_fail;
10848 }
10849 {
10850 #if wxUSE_UNICODE
10851 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10852 #else
10853 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10854 #endif
10855 }
10856 {
10857 if (temp1)
10858 delete arg1;
10859 }
10860 return resultobj;
10861 fail:
10862 {
10863 if (temp1)
10864 delete arg1;
10865 }
10866 return NULL;
10867 }
10868
10869
10870 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10871 PyObject *obj;
10872 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10873 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10874 return SWIG_Py_Void();
10875 }
10876
10877 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10878 return SWIG_Python_InitShadowInstance(args);
10879 }
10880
10881 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10882 PyObject *resultobj = 0;
10883 wxInternetFSHandler *result = 0 ;
10884
10885 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10886 {
10887 PyThreadState* __tstate = wxPyBeginAllowThreads();
10888 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10889 wxPyEndAllowThreads(__tstate);
10890 if (PyErr_Occurred()) SWIG_fail;
10891 }
10892 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10893 return resultobj;
10894 fail:
10895 return NULL;
10896 }
10897
10898
10899 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10900 PyObject *resultobj = 0;
10901 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10902 wxString *arg2 = 0 ;
10903 bool result;
10904 void *argp1 = 0 ;
10905 int res1 = 0 ;
10906 bool temp2 = false ;
10907 PyObject * obj0 = 0 ;
10908 PyObject * obj1 = 0 ;
10909 char * kwnames[] = {
10910 (char *) "self",(char *) "location", NULL
10911 };
10912
10913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10915 if (!SWIG_IsOK(res1)) {
10916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10917 }
10918 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10919 {
10920 arg2 = wxString_in_helper(obj1);
10921 if (arg2 == NULL) SWIG_fail;
10922 temp2 = true;
10923 }
10924 {
10925 PyThreadState* __tstate = wxPyBeginAllowThreads();
10926 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10927 wxPyEndAllowThreads(__tstate);
10928 if (PyErr_Occurred()) SWIG_fail;
10929 }
10930 {
10931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10932 }
10933 {
10934 if (temp2)
10935 delete arg2;
10936 }
10937 return resultobj;
10938 fail:
10939 {
10940 if (temp2)
10941 delete arg2;
10942 }
10943 return NULL;
10944 }
10945
10946
10947 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10948 PyObject *resultobj = 0;
10949 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10950 wxFileSystem *arg2 = 0 ;
10951 wxString *arg3 = 0 ;
10952 wxFSFile *result = 0 ;
10953 void *argp1 = 0 ;
10954 int res1 = 0 ;
10955 void *argp2 = 0 ;
10956 int res2 = 0 ;
10957 bool temp3 = false ;
10958 PyObject * obj0 = 0 ;
10959 PyObject * obj1 = 0 ;
10960 PyObject * obj2 = 0 ;
10961 char * kwnames[] = {
10962 (char *) "self",(char *) "fs",(char *) "location", NULL
10963 };
10964
10965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10967 if (!SWIG_IsOK(res1)) {
10968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10969 }
10970 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10971 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10972 if (!SWIG_IsOK(res2)) {
10973 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10974 }
10975 if (!argp2) {
10976 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10977 }
10978 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10979 {
10980 arg3 = wxString_in_helper(obj2);
10981 if (arg3 == NULL) SWIG_fail;
10982 temp3 = true;
10983 }
10984 {
10985 PyThreadState* __tstate = wxPyBeginAllowThreads();
10986 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10987 wxPyEndAllowThreads(__tstate);
10988 if (PyErr_Occurred()) SWIG_fail;
10989 }
10990 {
10991 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10992 }
10993 {
10994 if (temp3)
10995 delete arg3;
10996 }
10997 return resultobj;
10998 fail:
10999 {
11000 if (temp3)
11001 delete arg3;
11002 }
11003 return NULL;
11004 }
11005
11006
11007 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11008 PyObject *obj;
11009 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11010 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11011 return SWIG_Py_Void();
11012 }
11013
11014 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11015 return SWIG_Python_InitShadowInstance(args);
11016 }
11017
11018 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11019 PyObject *resultobj = 0;
11020 wxZipFSHandler *result = 0 ;
11021
11022 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11023 {
11024 PyThreadState* __tstate = wxPyBeginAllowThreads();
11025 result = (wxZipFSHandler *)new wxZipFSHandler();
11026 wxPyEndAllowThreads(__tstate);
11027 if (PyErr_Occurred()) SWIG_fail;
11028 }
11029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11030 return resultobj;
11031 fail:
11032 return NULL;
11033 }
11034
11035
11036 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11037 PyObject *resultobj = 0;
11038 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11039 wxString *arg2 = 0 ;
11040 bool result;
11041 void *argp1 = 0 ;
11042 int res1 = 0 ;
11043 bool temp2 = false ;
11044 PyObject * obj0 = 0 ;
11045 PyObject * obj1 = 0 ;
11046 char * kwnames[] = {
11047 (char *) "self",(char *) "location", NULL
11048 };
11049
11050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11052 if (!SWIG_IsOK(res1)) {
11053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11054 }
11055 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11056 {
11057 arg2 = wxString_in_helper(obj1);
11058 if (arg2 == NULL) SWIG_fail;
11059 temp2 = true;
11060 }
11061 {
11062 PyThreadState* __tstate = wxPyBeginAllowThreads();
11063 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11064 wxPyEndAllowThreads(__tstate);
11065 if (PyErr_Occurred()) SWIG_fail;
11066 }
11067 {
11068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11069 }
11070 {
11071 if (temp2)
11072 delete arg2;
11073 }
11074 return resultobj;
11075 fail:
11076 {
11077 if (temp2)
11078 delete arg2;
11079 }
11080 return NULL;
11081 }
11082
11083
11084 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11085 PyObject *resultobj = 0;
11086 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11087 wxFileSystem *arg2 = 0 ;
11088 wxString *arg3 = 0 ;
11089 wxFSFile *result = 0 ;
11090 void *argp1 = 0 ;
11091 int res1 = 0 ;
11092 void *argp2 = 0 ;
11093 int res2 = 0 ;
11094 bool temp3 = false ;
11095 PyObject * obj0 = 0 ;
11096 PyObject * obj1 = 0 ;
11097 PyObject * obj2 = 0 ;
11098 char * kwnames[] = {
11099 (char *) "self",(char *) "fs",(char *) "location", NULL
11100 };
11101
11102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11104 if (!SWIG_IsOK(res1)) {
11105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11106 }
11107 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11108 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11109 if (!SWIG_IsOK(res2)) {
11110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11111 }
11112 if (!argp2) {
11113 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11114 }
11115 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11116 {
11117 arg3 = wxString_in_helper(obj2);
11118 if (arg3 == NULL) SWIG_fail;
11119 temp3 = true;
11120 }
11121 {
11122 PyThreadState* __tstate = wxPyBeginAllowThreads();
11123 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11124 wxPyEndAllowThreads(__tstate);
11125 if (PyErr_Occurred()) SWIG_fail;
11126 }
11127 {
11128 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11129 }
11130 {
11131 if (temp3)
11132 delete arg3;
11133 }
11134 return resultobj;
11135 fail:
11136 {
11137 if (temp3)
11138 delete arg3;
11139 }
11140 return NULL;
11141 }
11142
11143
11144 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11145 PyObject *resultobj = 0;
11146 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11147 wxString *arg2 = 0 ;
11148 int arg3 = (int) 0 ;
11149 wxString result;
11150 void *argp1 = 0 ;
11151 int res1 = 0 ;
11152 bool temp2 = false ;
11153 int val3 ;
11154 int ecode3 = 0 ;
11155 PyObject * obj0 = 0 ;
11156 PyObject * obj1 = 0 ;
11157 PyObject * obj2 = 0 ;
11158 char * kwnames[] = {
11159 (char *) "self",(char *) "spec",(char *) "flags", NULL
11160 };
11161
11162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11164 if (!SWIG_IsOK(res1)) {
11165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11166 }
11167 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11168 {
11169 arg2 = wxString_in_helper(obj1);
11170 if (arg2 == NULL) SWIG_fail;
11171 temp2 = true;
11172 }
11173 if (obj2) {
11174 ecode3 = SWIG_AsVal_int(obj2, &val3);
11175 if (!SWIG_IsOK(ecode3)) {
11176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11177 }
11178 arg3 = static_cast< int >(val3);
11179 }
11180 {
11181 PyThreadState* __tstate = wxPyBeginAllowThreads();
11182 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11183 wxPyEndAllowThreads(__tstate);
11184 if (PyErr_Occurred()) SWIG_fail;
11185 }
11186 {
11187 #if wxUSE_UNICODE
11188 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11189 #else
11190 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11191 #endif
11192 }
11193 {
11194 if (temp2)
11195 delete arg2;
11196 }
11197 return resultobj;
11198 fail:
11199 {
11200 if (temp2)
11201 delete arg2;
11202 }
11203 return NULL;
11204 }
11205
11206
11207 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11208 PyObject *resultobj = 0;
11209 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11210 wxString result;
11211 void *argp1 = 0 ;
11212 int res1 = 0 ;
11213 PyObject *swig_obj[1] ;
11214
11215 if (!args) SWIG_fail;
11216 swig_obj[0] = args;
11217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11218 if (!SWIG_IsOK(res1)) {
11219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11220 }
11221 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11222 {
11223 PyThreadState* __tstate = wxPyBeginAllowThreads();
11224 result = (arg1)->FindNext();
11225 wxPyEndAllowThreads(__tstate);
11226 if (PyErr_Occurred()) SWIG_fail;
11227 }
11228 {
11229 #if wxUSE_UNICODE
11230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11231 #else
11232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11233 #endif
11234 }
11235 return resultobj;
11236 fail:
11237 return NULL;
11238 }
11239
11240
11241 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11242 PyObject *obj;
11243 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11244 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11245 return SWIG_Py_Void();
11246 }
11247
11248 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11249 return SWIG_Python_InitShadowInstance(args);
11250 }
11251
11252 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11253 PyObject *resultobj = 0;
11254 wxString *arg1 = 0 ;
11255 wxImage *arg2 = 0 ;
11256 long arg3 ;
11257 bool temp1 = false ;
11258 void *argp2 = 0 ;
11259 int res2 = 0 ;
11260 long val3 ;
11261 int ecode3 = 0 ;
11262 PyObject * obj0 = 0 ;
11263 PyObject * obj1 = 0 ;
11264 PyObject * obj2 = 0 ;
11265 char * kwnames[] = {
11266 (char *) "filename",(char *) "image",(char *) "type", NULL
11267 };
11268
11269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11270 {
11271 arg1 = wxString_in_helper(obj0);
11272 if (arg1 == NULL) SWIG_fail;
11273 temp1 = true;
11274 }
11275 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11276 if (!SWIG_IsOK(res2)) {
11277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11278 }
11279 if (!argp2) {
11280 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11281 }
11282 arg2 = reinterpret_cast< wxImage * >(argp2);
11283 ecode3 = SWIG_AsVal_long(obj2, &val3);
11284 if (!SWIG_IsOK(ecode3)) {
11285 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11286 }
11287 arg3 = static_cast< long >(val3);
11288 {
11289 PyThreadState* __tstate = wxPyBeginAllowThreads();
11290 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11291 wxPyEndAllowThreads(__tstate);
11292 if (PyErr_Occurred()) SWIG_fail;
11293 }
11294 resultobj = SWIG_Py_Void();
11295 {
11296 if (temp1)
11297 delete arg1;
11298 }
11299 return resultobj;
11300 fail:
11301 {
11302 if (temp1)
11303 delete arg1;
11304 }
11305 return NULL;
11306 }
11307
11308
11309 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11310 PyObject *resultobj = 0;
11311 wxString *arg1 = 0 ;
11312 wxBitmap *arg2 = 0 ;
11313 long arg3 ;
11314 bool temp1 = false ;
11315 void *argp2 = 0 ;
11316 int res2 = 0 ;
11317 long val3 ;
11318 int ecode3 = 0 ;
11319 PyObject * obj0 = 0 ;
11320 PyObject * obj1 = 0 ;
11321 PyObject * obj2 = 0 ;
11322 char * kwnames[] = {
11323 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11324 };
11325
11326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11327 {
11328 arg1 = wxString_in_helper(obj0);
11329 if (arg1 == NULL) SWIG_fail;
11330 temp1 = true;
11331 }
11332 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11333 if (!SWIG_IsOK(res2)) {
11334 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11335 }
11336 if (!argp2) {
11337 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11338 }
11339 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11340 ecode3 = SWIG_AsVal_long(obj2, &val3);
11341 if (!SWIG_IsOK(ecode3)) {
11342 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11343 }
11344 arg3 = static_cast< long >(val3);
11345 {
11346 PyThreadState* __tstate = wxPyBeginAllowThreads();
11347 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11348 wxPyEndAllowThreads(__tstate);
11349 if (PyErr_Occurred()) SWIG_fail;
11350 }
11351 resultobj = SWIG_Py_Void();
11352 {
11353 if (temp1)
11354 delete arg1;
11355 }
11356 return resultobj;
11357 fail:
11358 {
11359 if (temp1)
11360 delete arg1;
11361 }
11362 return NULL;
11363 }
11364
11365
11366 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11367 PyObject *resultobj = 0;
11368 wxString *arg1 = 0 ;
11369 PyObject *arg2 = (PyObject *) 0 ;
11370 bool temp1 = false ;
11371 PyObject * obj0 = 0 ;
11372 PyObject * obj1 = 0 ;
11373 char * kwnames[] = {
11374 (char *) "filename",(char *) "data", NULL
11375 };
11376
11377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11378 {
11379 arg1 = wxString_in_helper(obj0);
11380 if (arg1 == NULL) SWIG_fail;
11381 temp1 = true;
11382 }
11383 arg2 = obj1;
11384 {
11385 PyThreadState* __tstate = wxPyBeginAllowThreads();
11386 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11387 wxPyEndAllowThreads(__tstate);
11388 if (PyErr_Occurred()) SWIG_fail;
11389 }
11390 resultobj = SWIG_Py_Void();
11391 {
11392 if (temp1)
11393 delete arg1;
11394 }
11395 return resultobj;
11396 fail:
11397 {
11398 if (temp1)
11399 delete arg1;
11400 }
11401 return NULL;
11402 }
11403
11404
11405 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11406 PyObject *resultobj = 0;
11407 wxMemoryFSHandler *result = 0 ;
11408
11409 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11410 {
11411 PyThreadState* __tstate = wxPyBeginAllowThreads();
11412 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11413 wxPyEndAllowThreads(__tstate);
11414 if (PyErr_Occurred()) SWIG_fail;
11415 }
11416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11417 return resultobj;
11418 fail:
11419 return NULL;
11420 }
11421
11422
11423 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11424 PyObject *resultobj = 0;
11425 wxString *arg1 = 0 ;
11426 bool temp1 = false ;
11427 PyObject * obj0 = 0 ;
11428 char * kwnames[] = {
11429 (char *) "filename", NULL
11430 };
11431
11432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11433 {
11434 arg1 = wxString_in_helper(obj0);
11435 if (arg1 == NULL) SWIG_fail;
11436 temp1 = true;
11437 }
11438 {
11439 PyThreadState* __tstate = wxPyBeginAllowThreads();
11440 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11441 wxPyEndAllowThreads(__tstate);
11442 if (PyErr_Occurred()) SWIG_fail;
11443 }
11444 resultobj = SWIG_Py_Void();
11445 {
11446 if (temp1)
11447 delete arg1;
11448 }
11449 return resultobj;
11450 fail:
11451 {
11452 if (temp1)
11453 delete arg1;
11454 }
11455 return NULL;
11456 }
11457
11458
11459 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11460 PyObject *resultobj = 0;
11461 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11462 wxString *arg2 = 0 ;
11463 bool result;
11464 void *argp1 = 0 ;
11465 int res1 = 0 ;
11466 bool temp2 = false ;
11467 PyObject * obj0 = 0 ;
11468 PyObject * obj1 = 0 ;
11469 char * kwnames[] = {
11470 (char *) "self",(char *) "location", NULL
11471 };
11472
11473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11475 if (!SWIG_IsOK(res1)) {
11476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11477 }
11478 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11479 {
11480 arg2 = wxString_in_helper(obj1);
11481 if (arg2 == NULL) SWIG_fail;
11482 temp2 = true;
11483 }
11484 {
11485 PyThreadState* __tstate = wxPyBeginAllowThreads();
11486 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11487 wxPyEndAllowThreads(__tstate);
11488 if (PyErr_Occurred()) SWIG_fail;
11489 }
11490 {
11491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11492 }
11493 {
11494 if (temp2)
11495 delete arg2;
11496 }
11497 return resultobj;
11498 fail:
11499 {
11500 if (temp2)
11501 delete arg2;
11502 }
11503 return NULL;
11504 }
11505
11506
11507 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11508 PyObject *resultobj = 0;
11509 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11510 wxFileSystem *arg2 = 0 ;
11511 wxString *arg3 = 0 ;
11512 wxFSFile *result = 0 ;
11513 void *argp1 = 0 ;
11514 int res1 = 0 ;
11515 void *argp2 = 0 ;
11516 int res2 = 0 ;
11517 bool temp3 = false ;
11518 PyObject * obj0 = 0 ;
11519 PyObject * obj1 = 0 ;
11520 PyObject * obj2 = 0 ;
11521 char * kwnames[] = {
11522 (char *) "self",(char *) "fs",(char *) "location", NULL
11523 };
11524
11525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11527 if (!SWIG_IsOK(res1)) {
11528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11529 }
11530 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11531 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11532 if (!SWIG_IsOK(res2)) {
11533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11534 }
11535 if (!argp2) {
11536 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11537 }
11538 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11539 {
11540 arg3 = wxString_in_helper(obj2);
11541 if (arg3 == NULL) SWIG_fail;
11542 temp3 = true;
11543 }
11544 {
11545 PyThreadState* __tstate = wxPyBeginAllowThreads();
11546 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11547 wxPyEndAllowThreads(__tstate);
11548 if (PyErr_Occurred()) SWIG_fail;
11549 }
11550 {
11551 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11552 }
11553 {
11554 if (temp3)
11555 delete arg3;
11556 }
11557 return resultobj;
11558 fail:
11559 {
11560 if (temp3)
11561 delete arg3;
11562 }
11563 return NULL;
11564 }
11565
11566
11567 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11568 PyObject *resultobj = 0;
11569 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11570 wxString *arg2 = 0 ;
11571 int arg3 = (int) 0 ;
11572 wxString result;
11573 void *argp1 = 0 ;
11574 int res1 = 0 ;
11575 bool temp2 = false ;
11576 int val3 ;
11577 int ecode3 = 0 ;
11578 PyObject * obj0 = 0 ;
11579 PyObject * obj1 = 0 ;
11580 PyObject * obj2 = 0 ;
11581 char * kwnames[] = {
11582 (char *) "self",(char *) "spec",(char *) "flags", NULL
11583 };
11584
11585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11587 if (!SWIG_IsOK(res1)) {
11588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11589 }
11590 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11591 {
11592 arg2 = wxString_in_helper(obj1);
11593 if (arg2 == NULL) SWIG_fail;
11594 temp2 = true;
11595 }
11596 if (obj2) {
11597 ecode3 = SWIG_AsVal_int(obj2, &val3);
11598 if (!SWIG_IsOK(ecode3)) {
11599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11600 }
11601 arg3 = static_cast< int >(val3);
11602 }
11603 {
11604 PyThreadState* __tstate = wxPyBeginAllowThreads();
11605 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11606 wxPyEndAllowThreads(__tstate);
11607 if (PyErr_Occurred()) SWIG_fail;
11608 }
11609 {
11610 #if wxUSE_UNICODE
11611 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11612 #else
11613 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11614 #endif
11615 }
11616 {
11617 if (temp2)
11618 delete arg2;
11619 }
11620 return resultobj;
11621 fail:
11622 {
11623 if (temp2)
11624 delete arg2;
11625 }
11626 return NULL;
11627 }
11628
11629
11630 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11631 PyObject *resultobj = 0;
11632 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11633 wxString result;
11634 void *argp1 = 0 ;
11635 int res1 = 0 ;
11636 PyObject *swig_obj[1] ;
11637
11638 if (!args) SWIG_fail;
11639 swig_obj[0] = args;
11640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11641 if (!SWIG_IsOK(res1)) {
11642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11643 }
11644 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11645 {
11646 PyThreadState* __tstate = wxPyBeginAllowThreads();
11647 result = (arg1)->FindNext();
11648 wxPyEndAllowThreads(__tstate);
11649 if (PyErr_Occurred()) SWIG_fail;
11650 }
11651 {
11652 #if wxUSE_UNICODE
11653 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11654 #else
11655 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11656 #endif
11657 }
11658 return resultobj;
11659 fail:
11660 return NULL;
11661 }
11662
11663
11664 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11665 PyObject *obj;
11666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11667 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11668 return SWIG_Py_Void();
11669 }
11670
11671 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11672 return SWIG_Python_InitShadowInstance(args);
11673 }
11674
11675 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11676 PyObject *resultobj = 0;
11677 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11678 wxString result;
11679 void *argp1 = 0 ;
11680 int res1 = 0 ;
11681 PyObject *swig_obj[1] ;
11682
11683 if (!args) SWIG_fail;
11684 swig_obj[0] = args;
11685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11686 if (!SWIG_IsOK(res1)) {
11687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11688 }
11689 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11690 {
11691 PyThreadState* __tstate = wxPyBeginAllowThreads();
11692 result = (arg1)->GetName();
11693 wxPyEndAllowThreads(__tstate);
11694 if (PyErr_Occurred()) SWIG_fail;
11695 }
11696 {
11697 #if wxUSE_UNICODE
11698 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11699 #else
11700 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11701 #endif
11702 }
11703 return resultobj;
11704 fail:
11705 return NULL;
11706 }
11707
11708
11709 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11710 PyObject *resultobj = 0;
11711 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11712 wxString result;
11713 void *argp1 = 0 ;
11714 int res1 = 0 ;
11715 PyObject *swig_obj[1] ;
11716
11717 if (!args) SWIG_fail;
11718 swig_obj[0] = args;
11719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11720 if (!SWIG_IsOK(res1)) {
11721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11722 }
11723 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11724 {
11725 PyThreadState* __tstate = wxPyBeginAllowThreads();
11726 result = (arg1)->GetExtension();
11727 wxPyEndAllowThreads(__tstate);
11728 if (PyErr_Occurred()) SWIG_fail;
11729 }
11730 {
11731 #if wxUSE_UNICODE
11732 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11733 #else
11734 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11735 #endif
11736 }
11737 return resultobj;
11738 fail:
11739 return NULL;
11740 }
11741
11742
11743 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11744 PyObject *resultobj = 0;
11745 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11746 long result;
11747 void *argp1 = 0 ;
11748 int res1 = 0 ;
11749 PyObject *swig_obj[1] ;
11750
11751 if (!args) SWIG_fail;
11752 swig_obj[0] = args;
11753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11754 if (!SWIG_IsOK(res1)) {
11755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11756 }
11757 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11758 {
11759 PyThreadState* __tstate = wxPyBeginAllowThreads();
11760 result = (long)(arg1)->GetType();
11761 wxPyEndAllowThreads(__tstate);
11762 if (PyErr_Occurred()) SWIG_fail;
11763 }
11764 resultobj = SWIG_From_long(static_cast< long >(result));
11765 return resultobj;
11766 fail:
11767 return NULL;
11768 }
11769
11770
11771 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11772 PyObject *resultobj = 0;
11773 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11774 wxString result;
11775 void *argp1 = 0 ;
11776 int res1 = 0 ;
11777 PyObject *swig_obj[1] ;
11778
11779 if (!args) SWIG_fail;
11780 swig_obj[0] = args;
11781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11782 if (!SWIG_IsOK(res1)) {
11783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11784 }
11785 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11786 {
11787 PyThreadState* __tstate = wxPyBeginAllowThreads();
11788 result = (arg1)->GetMimeType();
11789 wxPyEndAllowThreads(__tstate);
11790 if (PyErr_Occurred()) SWIG_fail;
11791 }
11792 {
11793 #if wxUSE_UNICODE
11794 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11795 #else
11796 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11797 #endif
11798 }
11799 return resultobj;
11800 fail:
11801 return NULL;
11802 }
11803
11804
11805 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11806 PyObject *resultobj = 0;
11807 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11808 wxString *arg2 = 0 ;
11809 bool result;
11810 void *argp1 = 0 ;
11811 int res1 = 0 ;
11812 bool temp2 = false ;
11813 PyObject * obj0 = 0 ;
11814 PyObject * obj1 = 0 ;
11815 char * kwnames[] = {
11816 (char *) "self",(char *) "name", NULL
11817 };
11818
11819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11821 if (!SWIG_IsOK(res1)) {
11822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11823 }
11824 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11825 {
11826 arg2 = wxString_in_helper(obj1);
11827 if (arg2 == NULL) SWIG_fail;
11828 temp2 = true;
11829 }
11830 {
11831 PyThreadState* __tstate = wxPyBeginAllowThreads();
11832 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11833 wxPyEndAllowThreads(__tstate);
11834 if (PyErr_Occurred()) SWIG_fail;
11835 }
11836 {
11837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11838 }
11839 {
11840 if (temp2)
11841 delete arg2;
11842 }
11843 return resultobj;
11844 fail:
11845 {
11846 if (temp2)
11847 delete arg2;
11848 }
11849 return NULL;
11850 }
11851
11852
11853 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11854 PyObject *resultobj = 0;
11855 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11856 wxInputStream *arg2 = 0 ;
11857 bool result;
11858 void *argp1 = 0 ;
11859 int res1 = 0 ;
11860 wxPyInputStream *temp2 ;
11861 bool created2 ;
11862 PyObject * obj0 = 0 ;
11863 PyObject * obj1 = 0 ;
11864 char * kwnames[] = {
11865 (char *) "self",(char *) "stream", NULL
11866 };
11867
11868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11870 if (!SWIG_IsOK(res1)) {
11871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11872 }
11873 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11874 {
11875 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11876 arg2 = temp2->m_wxis;
11877 created2 = false;
11878 } else {
11879 PyErr_Clear(); // clear the failure of the wxPyConvert above
11880 arg2 = wxPyCBInputStream_create(obj1, false);
11881 if (arg2 == NULL) {
11882 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11883 SWIG_fail;
11884 }
11885 created2 = true;
11886 }
11887 }
11888 {
11889 PyThreadState* __tstate = wxPyBeginAllowThreads();
11890 result = (bool)(arg1)->CanRead(*arg2);
11891 wxPyEndAllowThreads(__tstate);
11892 if (PyErr_Occurred()) SWIG_fail;
11893 }
11894 {
11895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11896 }
11897 {
11898 if (created2) delete arg2;
11899 }
11900 return resultobj;
11901 fail:
11902 {
11903 if (created2) delete arg2;
11904 }
11905 return NULL;
11906 }
11907
11908
11909 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11910 PyObject *resultobj = 0;
11911 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11912 wxString *arg2 = 0 ;
11913 void *argp1 = 0 ;
11914 int res1 = 0 ;
11915 bool temp2 = false ;
11916 PyObject * obj0 = 0 ;
11917 PyObject * obj1 = 0 ;
11918 char * kwnames[] = {
11919 (char *) "self",(char *) "name", NULL
11920 };
11921
11922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11924 if (!SWIG_IsOK(res1)) {
11925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11926 }
11927 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11928 {
11929 arg2 = wxString_in_helper(obj1);
11930 if (arg2 == NULL) SWIG_fail;
11931 temp2 = true;
11932 }
11933 {
11934 PyThreadState* __tstate = wxPyBeginAllowThreads();
11935 (arg1)->SetName((wxString const &)*arg2);
11936 wxPyEndAllowThreads(__tstate);
11937 if (PyErr_Occurred()) SWIG_fail;
11938 }
11939 resultobj = SWIG_Py_Void();
11940 {
11941 if (temp2)
11942 delete arg2;
11943 }
11944 return resultobj;
11945 fail:
11946 {
11947 if (temp2)
11948 delete arg2;
11949 }
11950 return NULL;
11951 }
11952
11953
11954 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11955 PyObject *resultobj = 0;
11956 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11957 wxString *arg2 = 0 ;
11958 void *argp1 = 0 ;
11959 int res1 = 0 ;
11960 bool temp2 = false ;
11961 PyObject * obj0 = 0 ;
11962 PyObject * obj1 = 0 ;
11963 char * kwnames[] = {
11964 (char *) "self",(char *) "extension", NULL
11965 };
11966
11967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11969 if (!SWIG_IsOK(res1)) {
11970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11971 }
11972 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11973 {
11974 arg2 = wxString_in_helper(obj1);
11975 if (arg2 == NULL) SWIG_fail;
11976 temp2 = true;
11977 }
11978 {
11979 PyThreadState* __tstate = wxPyBeginAllowThreads();
11980 (arg1)->SetExtension((wxString const &)*arg2);
11981 wxPyEndAllowThreads(__tstate);
11982 if (PyErr_Occurred()) SWIG_fail;
11983 }
11984 resultobj = SWIG_Py_Void();
11985 {
11986 if (temp2)
11987 delete arg2;
11988 }
11989 return resultobj;
11990 fail:
11991 {
11992 if (temp2)
11993 delete arg2;
11994 }
11995 return NULL;
11996 }
11997
11998
11999 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12000 PyObject *resultobj = 0;
12001 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12002 long arg2 ;
12003 void *argp1 = 0 ;
12004 int res1 = 0 ;
12005 long val2 ;
12006 int ecode2 = 0 ;
12007 PyObject * obj0 = 0 ;
12008 PyObject * obj1 = 0 ;
12009 char * kwnames[] = {
12010 (char *) "self",(char *) "type", NULL
12011 };
12012
12013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12015 if (!SWIG_IsOK(res1)) {
12016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12017 }
12018 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12019 ecode2 = SWIG_AsVal_long(obj1, &val2);
12020 if (!SWIG_IsOK(ecode2)) {
12021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12022 }
12023 arg2 = static_cast< long >(val2);
12024 {
12025 PyThreadState* __tstate = wxPyBeginAllowThreads();
12026 (arg1)->SetType(arg2);
12027 wxPyEndAllowThreads(__tstate);
12028 if (PyErr_Occurred()) SWIG_fail;
12029 }
12030 resultobj = SWIG_Py_Void();
12031 return resultobj;
12032 fail:
12033 return NULL;
12034 }
12035
12036
12037 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12038 PyObject *resultobj = 0;
12039 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12040 wxString *arg2 = 0 ;
12041 void *argp1 = 0 ;
12042 int res1 = 0 ;
12043 bool temp2 = false ;
12044 PyObject * obj0 = 0 ;
12045 PyObject * obj1 = 0 ;
12046 char * kwnames[] = {
12047 (char *) "self",(char *) "mimetype", NULL
12048 };
12049
12050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12052 if (!SWIG_IsOK(res1)) {
12053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12054 }
12055 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12056 {
12057 arg2 = wxString_in_helper(obj1);
12058 if (arg2 == NULL) SWIG_fail;
12059 temp2 = true;
12060 }
12061 {
12062 PyThreadState* __tstate = wxPyBeginAllowThreads();
12063 (arg1)->SetMimeType((wxString const &)*arg2);
12064 wxPyEndAllowThreads(__tstate);
12065 if (PyErr_Occurred()) SWIG_fail;
12066 }
12067 resultobj = SWIG_Py_Void();
12068 {
12069 if (temp2)
12070 delete arg2;
12071 }
12072 return resultobj;
12073 fail:
12074 {
12075 if (temp2)
12076 delete arg2;
12077 }
12078 return NULL;
12079 }
12080
12081
12082 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12083 PyObject *obj;
12084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12085 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12086 return SWIG_Py_Void();
12087 }
12088
12089 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12090 PyObject *resultobj = 0;
12091 wxPyImageHandler *result = 0 ;
12092
12093 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12094 {
12095 PyThreadState* __tstate = wxPyBeginAllowThreads();
12096 result = (wxPyImageHandler *)new wxPyImageHandler();
12097 wxPyEndAllowThreads(__tstate);
12098 if (PyErr_Occurred()) SWIG_fail;
12099 }
12100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12101 return resultobj;
12102 fail:
12103 return NULL;
12104 }
12105
12106
12107 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12108 PyObject *resultobj = 0;
12109 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12110 PyObject *arg2 = (PyObject *) 0 ;
12111 void *argp1 = 0 ;
12112 int res1 = 0 ;
12113 PyObject * obj0 = 0 ;
12114 PyObject * obj1 = 0 ;
12115 char * kwnames[] = {
12116 (char *) "self",(char *) "self", NULL
12117 };
12118
12119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12121 if (!SWIG_IsOK(res1)) {
12122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12123 }
12124 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12125 arg2 = obj1;
12126 {
12127 PyThreadState* __tstate = wxPyBeginAllowThreads();
12128 (arg1)->_SetSelf(arg2);
12129 wxPyEndAllowThreads(__tstate);
12130 if (PyErr_Occurred()) SWIG_fail;
12131 }
12132 resultobj = SWIG_Py_Void();
12133 return resultobj;
12134 fail:
12135 return NULL;
12136 }
12137
12138
12139 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12140 PyObject *obj;
12141 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12142 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12143 return SWIG_Py_Void();
12144 }
12145
12146 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12147 return SWIG_Python_InitShadowInstance(args);
12148 }
12149
12150 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12151 PyObject *resultobj = 0;
12152 wxImageHistogram *result = 0 ;
12153
12154 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12155 {
12156 PyThreadState* __tstate = wxPyBeginAllowThreads();
12157 result = (wxImageHistogram *)new wxImageHistogram();
12158 wxPyEndAllowThreads(__tstate);
12159 if (PyErr_Occurred()) SWIG_fail;
12160 }
12161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12162 return resultobj;
12163 fail:
12164 return NULL;
12165 }
12166
12167
12168 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12169 PyObject *resultobj = 0;
12170 byte arg1 ;
12171 byte arg2 ;
12172 byte arg3 ;
12173 unsigned long result;
12174 unsigned char val1 ;
12175 int ecode1 = 0 ;
12176 unsigned char val2 ;
12177 int ecode2 = 0 ;
12178 unsigned char val3 ;
12179 int ecode3 = 0 ;
12180 PyObject * obj0 = 0 ;
12181 PyObject * obj1 = 0 ;
12182 PyObject * obj2 = 0 ;
12183 char * kwnames[] = {
12184 (char *) "r",(char *) "g",(char *) "b", NULL
12185 };
12186
12187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12188 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12189 if (!SWIG_IsOK(ecode1)) {
12190 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12191 }
12192 arg1 = static_cast< byte >(val1);
12193 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12194 if (!SWIG_IsOK(ecode2)) {
12195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12196 }
12197 arg2 = static_cast< byte >(val2);
12198 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12199 if (!SWIG_IsOK(ecode3)) {
12200 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12201 }
12202 arg3 = static_cast< byte >(val3);
12203 {
12204 PyThreadState* __tstate = wxPyBeginAllowThreads();
12205 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12206 wxPyEndAllowThreads(__tstate);
12207 if (PyErr_Occurred()) SWIG_fail;
12208 }
12209 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12210 return resultobj;
12211 fail:
12212 return NULL;
12213 }
12214
12215
12216 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12217 PyObject *resultobj = 0;
12218 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12219 byte *arg2 = (byte *) 0 ;
12220 byte *arg3 = (byte *) 0 ;
12221 byte *arg4 = (byte *) 0 ;
12222 byte arg5 = (byte) 1 ;
12223 byte arg6 = (byte) 0 ;
12224 byte arg7 = (byte) 0 ;
12225 bool result;
12226 void *argp1 = 0 ;
12227 int res1 = 0 ;
12228 byte temp2 ;
12229 int res2 = SWIG_TMPOBJ ;
12230 byte temp3 ;
12231 int res3 = SWIG_TMPOBJ ;
12232 byte temp4 ;
12233 int res4 = SWIG_TMPOBJ ;
12234 unsigned char val5 ;
12235 int ecode5 = 0 ;
12236 unsigned char val6 ;
12237 int ecode6 = 0 ;
12238 unsigned char val7 ;
12239 int ecode7 = 0 ;
12240 PyObject * obj0 = 0 ;
12241 PyObject * obj1 = 0 ;
12242 PyObject * obj2 = 0 ;
12243 PyObject * obj3 = 0 ;
12244 char * kwnames[] = {
12245 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12246 };
12247
12248 arg2 = &temp2;
12249 arg3 = &temp3;
12250 arg4 = &temp4;
12251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12253 if (!SWIG_IsOK(res1)) {
12254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12255 }
12256 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12257 if (obj1) {
12258 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12259 if (!SWIG_IsOK(ecode5)) {
12260 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12261 }
12262 arg5 = static_cast< byte >(val5);
12263 }
12264 if (obj2) {
12265 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12266 if (!SWIG_IsOK(ecode6)) {
12267 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12268 }
12269 arg6 = static_cast< byte >(val6);
12270 }
12271 if (obj3) {
12272 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12273 if (!SWIG_IsOK(ecode7)) {
12274 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12275 }
12276 arg7 = static_cast< byte >(val7);
12277 }
12278 {
12279 PyThreadState* __tstate = wxPyBeginAllowThreads();
12280 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12281 wxPyEndAllowThreads(__tstate);
12282 if (PyErr_Occurred()) SWIG_fail;
12283 }
12284 {
12285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12286 }
12287 if (SWIG_IsTmpObj(res2)) {
12288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12289 } else {
12290 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12292 }
12293 if (SWIG_IsTmpObj(res3)) {
12294 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12295 } else {
12296 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12297 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12298 }
12299 if (SWIG_IsTmpObj(res4)) {
12300 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12301 } else {
12302 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12303 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12304 }
12305 return resultobj;
12306 fail:
12307 return NULL;
12308 }
12309
12310
12311 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12312 PyObject *resultobj = 0;
12313 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12314 unsigned long arg2 ;
12315 unsigned long result;
12316 void *argp1 = 0 ;
12317 int res1 = 0 ;
12318 unsigned long val2 ;
12319 int ecode2 = 0 ;
12320 PyObject * obj0 = 0 ;
12321 PyObject * obj1 = 0 ;
12322 char * kwnames[] = {
12323 (char *) "self",(char *) "key", NULL
12324 };
12325
12326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12328 if (!SWIG_IsOK(res1)) {
12329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12330 }
12331 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12332 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12333 if (!SWIG_IsOK(ecode2)) {
12334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12335 }
12336 arg2 = static_cast< unsigned long >(val2);
12337 {
12338 PyThreadState* __tstate = wxPyBeginAllowThreads();
12339 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12340 wxPyEndAllowThreads(__tstate);
12341 if (PyErr_Occurred()) SWIG_fail;
12342 }
12343 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12344 return resultobj;
12345 fail:
12346 return NULL;
12347 }
12348
12349
12350 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12351 PyObject *resultobj = 0;
12352 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12353 byte arg2 ;
12354 byte arg3 ;
12355 byte arg4 ;
12356 unsigned long result;
12357 void *argp1 = 0 ;
12358 int res1 = 0 ;
12359 unsigned char val2 ;
12360 int ecode2 = 0 ;
12361 unsigned char val3 ;
12362 int ecode3 = 0 ;
12363 unsigned char val4 ;
12364 int ecode4 = 0 ;
12365 PyObject * obj0 = 0 ;
12366 PyObject * obj1 = 0 ;
12367 PyObject * obj2 = 0 ;
12368 PyObject * obj3 = 0 ;
12369 char * kwnames[] = {
12370 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12371 };
12372
12373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12375 if (!SWIG_IsOK(res1)) {
12376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12377 }
12378 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12379 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12380 if (!SWIG_IsOK(ecode2)) {
12381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12382 }
12383 arg2 = static_cast< byte >(val2);
12384 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12385 if (!SWIG_IsOK(ecode3)) {
12386 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12387 }
12388 arg3 = static_cast< byte >(val3);
12389 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12390 if (!SWIG_IsOK(ecode4)) {
12391 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12392 }
12393 arg4 = static_cast< byte >(val4);
12394 {
12395 PyThreadState* __tstate = wxPyBeginAllowThreads();
12396 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12397 wxPyEndAllowThreads(__tstate);
12398 if (PyErr_Occurred()) SWIG_fail;
12399 }
12400 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12401 return resultobj;
12402 fail:
12403 return NULL;
12404 }
12405
12406
12407 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12408 PyObject *resultobj = 0;
12409 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12410 wxColour *arg2 = 0 ;
12411 unsigned long result;
12412 void *argp1 = 0 ;
12413 int res1 = 0 ;
12414 wxColour temp2 ;
12415 PyObject * obj0 = 0 ;
12416 PyObject * obj1 = 0 ;
12417 char * kwnames[] = {
12418 (char *) "self",(char *) "colour", NULL
12419 };
12420
12421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12423 if (!SWIG_IsOK(res1)) {
12424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12425 }
12426 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12427 {
12428 arg2 = &temp2;
12429 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12430 }
12431 {
12432 PyThreadState* __tstate = wxPyBeginAllowThreads();
12433 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12434 wxPyEndAllowThreads(__tstate);
12435 if (PyErr_Occurred()) SWIG_fail;
12436 }
12437 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12438 return resultobj;
12439 fail:
12440 return NULL;
12441 }
12442
12443
12444 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12445 PyObject *obj;
12446 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12447 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12448 return SWIG_Py_Void();
12449 }
12450
12451 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12452 return SWIG_Python_InitShadowInstance(args);
12453 }
12454
12455 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12456 PyObject *resultobj = 0;
12457 byte arg1 = (byte) 0 ;
12458 byte arg2 = (byte) 0 ;
12459 byte arg3 = (byte) 0 ;
12460 wxImage_RGBValue *result = 0 ;
12461 unsigned char val1 ;
12462 int ecode1 = 0 ;
12463 unsigned char val2 ;
12464 int ecode2 = 0 ;
12465 unsigned char val3 ;
12466 int ecode3 = 0 ;
12467 PyObject * obj0 = 0 ;
12468 PyObject * obj1 = 0 ;
12469 PyObject * obj2 = 0 ;
12470 char * kwnames[] = {
12471 (char *) "r",(char *) "g",(char *) "b", NULL
12472 };
12473
12474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12475 if (obj0) {
12476 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12477 if (!SWIG_IsOK(ecode1)) {
12478 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12479 }
12480 arg1 = static_cast< byte >(val1);
12481 }
12482 if (obj1) {
12483 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12484 if (!SWIG_IsOK(ecode2)) {
12485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12486 }
12487 arg2 = static_cast< byte >(val2);
12488 }
12489 if (obj2) {
12490 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12491 if (!SWIG_IsOK(ecode3)) {
12492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12493 }
12494 arg3 = static_cast< byte >(val3);
12495 }
12496 {
12497 PyThreadState* __tstate = wxPyBeginAllowThreads();
12498 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12499 wxPyEndAllowThreads(__tstate);
12500 if (PyErr_Occurred()) SWIG_fail;
12501 }
12502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12503 return resultobj;
12504 fail:
12505 return NULL;
12506 }
12507
12508
12509 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12510 PyObject *resultobj = 0;
12511 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12512 byte arg2 ;
12513 void *argp1 = 0 ;
12514 int res1 = 0 ;
12515 unsigned char val2 ;
12516 int ecode2 = 0 ;
12517 PyObject *swig_obj[2] ;
12518
12519 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12521 if (!SWIG_IsOK(res1)) {
12522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12523 }
12524 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12525 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12526 if (!SWIG_IsOK(ecode2)) {
12527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12528 }
12529 arg2 = static_cast< byte >(val2);
12530 if (arg1) (arg1)->red = arg2;
12531
12532 resultobj = SWIG_Py_Void();
12533 return resultobj;
12534 fail:
12535 return NULL;
12536 }
12537
12538
12539 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12540 PyObject *resultobj = 0;
12541 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12542 byte result;
12543 void *argp1 = 0 ;
12544 int res1 = 0 ;
12545 PyObject *swig_obj[1] ;
12546
12547 if (!args) SWIG_fail;
12548 swig_obj[0] = args;
12549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12550 if (!SWIG_IsOK(res1)) {
12551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12552 }
12553 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12554 result = (byte) ((arg1)->red);
12555 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12556 return resultobj;
12557 fail:
12558 return NULL;
12559 }
12560
12561
12562 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12563 PyObject *resultobj = 0;
12564 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12565 byte arg2 ;
12566 void *argp1 = 0 ;
12567 int res1 = 0 ;
12568 unsigned char val2 ;
12569 int ecode2 = 0 ;
12570 PyObject *swig_obj[2] ;
12571
12572 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12574 if (!SWIG_IsOK(res1)) {
12575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12576 }
12577 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12578 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12579 if (!SWIG_IsOK(ecode2)) {
12580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12581 }
12582 arg2 = static_cast< byte >(val2);
12583 if (arg1) (arg1)->green = arg2;
12584
12585 resultobj = SWIG_Py_Void();
12586 return resultobj;
12587 fail:
12588 return NULL;
12589 }
12590
12591
12592 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12593 PyObject *resultobj = 0;
12594 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12595 byte result;
12596 void *argp1 = 0 ;
12597 int res1 = 0 ;
12598 PyObject *swig_obj[1] ;
12599
12600 if (!args) SWIG_fail;
12601 swig_obj[0] = args;
12602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12603 if (!SWIG_IsOK(res1)) {
12604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12605 }
12606 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12607 result = (byte) ((arg1)->green);
12608 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12609 return resultobj;
12610 fail:
12611 return NULL;
12612 }
12613
12614
12615 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12616 PyObject *resultobj = 0;
12617 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12618 byte arg2 ;
12619 void *argp1 = 0 ;
12620 int res1 = 0 ;
12621 unsigned char val2 ;
12622 int ecode2 = 0 ;
12623 PyObject *swig_obj[2] ;
12624
12625 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12627 if (!SWIG_IsOK(res1)) {
12628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12629 }
12630 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12631 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12632 if (!SWIG_IsOK(ecode2)) {
12633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12634 }
12635 arg2 = static_cast< byte >(val2);
12636 if (arg1) (arg1)->blue = arg2;
12637
12638 resultobj = SWIG_Py_Void();
12639 return resultobj;
12640 fail:
12641 return NULL;
12642 }
12643
12644
12645 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12646 PyObject *resultobj = 0;
12647 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12648 byte result;
12649 void *argp1 = 0 ;
12650 int res1 = 0 ;
12651 PyObject *swig_obj[1] ;
12652
12653 if (!args) SWIG_fail;
12654 swig_obj[0] = args;
12655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12656 if (!SWIG_IsOK(res1)) {
12657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12658 }
12659 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12660 result = (byte) ((arg1)->blue);
12661 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12662 return resultobj;
12663 fail:
12664 return NULL;
12665 }
12666
12667
12668 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12669 PyObject *obj;
12670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12671 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12672 return SWIG_Py_Void();
12673 }
12674
12675 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12676 return SWIG_Python_InitShadowInstance(args);
12677 }
12678
12679 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12680 PyObject *resultobj = 0;
12681 double arg1 = (double) 0.0 ;
12682 double arg2 = (double) 0.0 ;
12683 double arg3 = (double) 0.0 ;
12684 wxImage_HSVValue *result = 0 ;
12685 double val1 ;
12686 int ecode1 = 0 ;
12687 double val2 ;
12688 int ecode2 = 0 ;
12689 double val3 ;
12690 int ecode3 = 0 ;
12691 PyObject * obj0 = 0 ;
12692 PyObject * obj1 = 0 ;
12693 PyObject * obj2 = 0 ;
12694 char * kwnames[] = {
12695 (char *) "h",(char *) "s",(char *) "v", NULL
12696 };
12697
12698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12699 if (obj0) {
12700 ecode1 = SWIG_AsVal_double(obj0, &val1);
12701 if (!SWIG_IsOK(ecode1)) {
12702 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12703 }
12704 arg1 = static_cast< double >(val1);
12705 }
12706 if (obj1) {
12707 ecode2 = SWIG_AsVal_double(obj1, &val2);
12708 if (!SWIG_IsOK(ecode2)) {
12709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12710 }
12711 arg2 = static_cast< double >(val2);
12712 }
12713 if (obj2) {
12714 ecode3 = SWIG_AsVal_double(obj2, &val3);
12715 if (!SWIG_IsOK(ecode3)) {
12716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12717 }
12718 arg3 = static_cast< double >(val3);
12719 }
12720 {
12721 PyThreadState* __tstate = wxPyBeginAllowThreads();
12722 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12723 wxPyEndAllowThreads(__tstate);
12724 if (PyErr_Occurred()) SWIG_fail;
12725 }
12726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12727 return resultobj;
12728 fail:
12729 return NULL;
12730 }
12731
12732
12733 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12734 PyObject *resultobj = 0;
12735 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12736 double arg2 ;
12737 void *argp1 = 0 ;
12738 int res1 = 0 ;
12739 double val2 ;
12740 int ecode2 = 0 ;
12741 PyObject *swig_obj[2] ;
12742
12743 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12745 if (!SWIG_IsOK(res1)) {
12746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12747 }
12748 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12749 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12750 if (!SWIG_IsOK(ecode2)) {
12751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12752 }
12753 arg2 = static_cast< double >(val2);
12754 if (arg1) (arg1)->hue = arg2;
12755
12756 resultobj = SWIG_Py_Void();
12757 return resultobj;
12758 fail:
12759 return NULL;
12760 }
12761
12762
12763 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12764 PyObject *resultobj = 0;
12765 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12766 double result;
12767 void *argp1 = 0 ;
12768 int res1 = 0 ;
12769 PyObject *swig_obj[1] ;
12770
12771 if (!args) SWIG_fail;
12772 swig_obj[0] = args;
12773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12774 if (!SWIG_IsOK(res1)) {
12775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12776 }
12777 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12778 result = (double) ((arg1)->hue);
12779 resultobj = SWIG_From_double(static_cast< double >(result));
12780 return resultobj;
12781 fail:
12782 return NULL;
12783 }
12784
12785
12786 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12787 PyObject *resultobj = 0;
12788 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12789 double arg2 ;
12790 void *argp1 = 0 ;
12791 int res1 = 0 ;
12792 double val2 ;
12793 int ecode2 = 0 ;
12794 PyObject *swig_obj[2] ;
12795
12796 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12798 if (!SWIG_IsOK(res1)) {
12799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12800 }
12801 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12802 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12803 if (!SWIG_IsOK(ecode2)) {
12804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12805 }
12806 arg2 = static_cast< double >(val2);
12807 if (arg1) (arg1)->saturation = arg2;
12808
12809 resultobj = SWIG_Py_Void();
12810 return resultobj;
12811 fail:
12812 return NULL;
12813 }
12814
12815
12816 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12817 PyObject *resultobj = 0;
12818 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12819 double result;
12820 void *argp1 = 0 ;
12821 int res1 = 0 ;
12822 PyObject *swig_obj[1] ;
12823
12824 if (!args) SWIG_fail;
12825 swig_obj[0] = args;
12826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12827 if (!SWIG_IsOK(res1)) {
12828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12829 }
12830 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12831 result = (double) ((arg1)->saturation);
12832 resultobj = SWIG_From_double(static_cast< double >(result));
12833 return resultobj;
12834 fail:
12835 return NULL;
12836 }
12837
12838
12839 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12840 PyObject *resultobj = 0;
12841 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12842 double arg2 ;
12843 void *argp1 = 0 ;
12844 int res1 = 0 ;
12845 double val2 ;
12846 int ecode2 = 0 ;
12847 PyObject *swig_obj[2] ;
12848
12849 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12851 if (!SWIG_IsOK(res1)) {
12852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12853 }
12854 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12855 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12856 if (!SWIG_IsOK(ecode2)) {
12857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12858 }
12859 arg2 = static_cast< double >(val2);
12860 if (arg1) (arg1)->value = arg2;
12861
12862 resultobj = SWIG_Py_Void();
12863 return resultobj;
12864 fail:
12865 return NULL;
12866 }
12867
12868
12869 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12870 PyObject *resultobj = 0;
12871 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12872 double result;
12873 void *argp1 = 0 ;
12874 int res1 = 0 ;
12875 PyObject *swig_obj[1] ;
12876
12877 if (!args) SWIG_fail;
12878 swig_obj[0] = args;
12879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12880 if (!SWIG_IsOK(res1)) {
12881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12882 }
12883 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12884 result = (double) ((arg1)->value);
12885 resultobj = SWIG_From_double(static_cast< double >(result));
12886 return resultobj;
12887 fail:
12888 return NULL;
12889 }
12890
12891
12892 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12893 PyObject *obj;
12894 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12895 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12896 return SWIG_Py_Void();
12897 }
12898
12899 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12900 return SWIG_Python_InitShadowInstance(args);
12901 }
12902
12903 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12904 PyObject *resultobj = 0;
12905 wxString *arg1 = 0 ;
12906 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12907 int arg3 = (int) -1 ;
12908 wxImage *result = 0 ;
12909 bool temp1 = false ;
12910 long val2 ;
12911 int ecode2 = 0 ;
12912 int val3 ;
12913 int ecode3 = 0 ;
12914 PyObject * obj0 = 0 ;
12915 PyObject * obj1 = 0 ;
12916 PyObject * obj2 = 0 ;
12917 char * kwnames[] = {
12918 (char *) "name",(char *) "type",(char *) "index", NULL
12919 };
12920
12921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12922 {
12923 arg1 = wxString_in_helper(obj0);
12924 if (arg1 == NULL) SWIG_fail;
12925 temp1 = true;
12926 }
12927 if (obj1) {
12928 ecode2 = SWIG_AsVal_long(obj1, &val2);
12929 if (!SWIG_IsOK(ecode2)) {
12930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12931 }
12932 arg2 = static_cast< long >(val2);
12933 }
12934 if (obj2) {
12935 ecode3 = SWIG_AsVal_int(obj2, &val3);
12936 if (!SWIG_IsOK(ecode3)) {
12937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12938 }
12939 arg3 = static_cast< int >(val3);
12940 }
12941 {
12942 PyThreadState* __tstate = wxPyBeginAllowThreads();
12943 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12944 wxPyEndAllowThreads(__tstate);
12945 if (PyErr_Occurred()) SWIG_fail;
12946 }
12947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12948 {
12949 if (temp1)
12950 delete arg1;
12951 }
12952 return resultobj;
12953 fail:
12954 {
12955 if (temp1)
12956 delete arg1;
12957 }
12958 return NULL;
12959 }
12960
12961
12962 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12963 PyObject *resultobj = 0;
12964 wxImage *arg1 = (wxImage *) 0 ;
12965 void *argp1 = 0 ;
12966 int res1 = 0 ;
12967 PyObject *swig_obj[1] ;
12968
12969 if (!args) SWIG_fail;
12970 swig_obj[0] = args;
12971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12972 if (!SWIG_IsOK(res1)) {
12973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12974 }
12975 arg1 = reinterpret_cast< wxImage * >(argp1);
12976 {
12977 PyThreadState* __tstate = wxPyBeginAllowThreads();
12978 delete arg1;
12979
12980 wxPyEndAllowThreads(__tstate);
12981 if (PyErr_Occurred()) SWIG_fail;
12982 }
12983 resultobj = SWIG_Py_Void();
12984 return resultobj;
12985 fail:
12986 return NULL;
12987 }
12988
12989
12990 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12991 PyObject *resultobj = 0;
12992 wxString *arg1 = 0 ;
12993 wxString *arg2 = 0 ;
12994 int arg3 = (int) -1 ;
12995 wxImage *result = 0 ;
12996 bool temp1 = false ;
12997 bool temp2 = false ;
12998 int val3 ;
12999 int ecode3 = 0 ;
13000 PyObject * obj0 = 0 ;
13001 PyObject * obj1 = 0 ;
13002 PyObject * obj2 = 0 ;
13003 char * kwnames[] = {
13004 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13005 };
13006
13007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13008 {
13009 arg1 = wxString_in_helper(obj0);
13010 if (arg1 == NULL) SWIG_fail;
13011 temp1 = true;
13012 }
13013 {
13014 arg2 = wxString_in_helper(obj1);
13015 if (arg2 == NULL) SWIG_fail;
13016 temp2 = true;
13017 }
13018 if (obj2) {
13019 ecode3 = SWIG_AsVal_int(obj2, &val3);
13020 if (!SWIG_IsOK(ecode3)) {
13021 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13022 }
13023 arg3 = static_cast< int >(val3);
13024 }
13025 {
13026 PyThreadState* __tstate = wxPyBeginAllowThreads();
13027 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13028 wxPyEndAllowThreads(__tstate);
13029 if (PyErr_Occurred()) SWIG_fail;
13030 }
13031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13032 {
13033 if (temp1)
13034 delete arg1;
13035 }
13036 {
13037 if (temp2)
13038 delete arg2;
13039 }
13040 return resultobj;
13041 fail:
13042 {
13043 if (temp1)
13044 delete arg1;
13045 }
13046 {
13047 if (temp2)
13048 delete arg2;
13049 }
13050 return NULL;
13051 }
13052
13053
13054 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13055 PyObject *resultobj = 0;
13056 wxInputStream *arg1 = 0 ;
13057 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13058 int arg3 = (int) -1 ;
13059 wxImage *result = 0 ;
13060 wxPyInputStream *temp1 ;
13061 bool created1 ;
13062 long val2 ;
13063 int ecode2 = 0 ;
13064 int val3 ;
13065 int ecode3 = 0 ;
13066 PyObject * obj0 = 0 ;
13067 PyObject * obj1 = 0 ;
13068 PyObject * obj2 = 0 ;
13069 char * kwnames[] = {
13070 (char *) "stream",(char *) "type",(char *) "index", NULL
13071 };
13072
13073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13074 {
13075 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13076 arg1 = temp1->m_wxis;
13077 created1 = false;
13078 } else {
13079 PyErr_Clear(); // clear the failure of the wxPyConvert above
13080 arg1 = wxPyCBInputStream_create(obj0, false);
13081 if (arg1 == NULL) {
13082 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13083 SWIG_fail;
13084 }
13085 created1 = true;
13086 }
13087 }
13088 if (obj1) {
13089 ecode2 = SWIG_AsVal_long(obj1, &val2);
13090 if (!SWIG_IsOK(ecode2)) {
13091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13092 }
13093 arg2 = static_cast< long >(val2);
13094 }
13095 if (obj2) {
13096 ecode3 = SWIG_AsVal_int(obj2, &val3);
13097 if (!SWIG_IsOK(ecode3)) {
13098 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13099 }
13100 arg3 = static_cast< int >(val3);
13101 }
13102 {
13103 PyThreadState* __tstate = wxPyBeginAllowThreads();
13104 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13105 wxPyEndAllowThreads(__tstate);
13106 if (PyErr_Occurred()) SWIG_fail;
13107 }
13108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13109 {
13110 if (created1) delete arg1;
13111 }
13112 return resultobj;
13113 fail:
13114 {
13115 if (created1) delete arg1;
13116 }
13117 return NULL;
13118 }
13119
13120
13121 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13122 PyObject *resultobj = 0;
13123 wxInputStream *arg1 = 0 ;
13124 wxString *arg2 = 0 ;
13125 int arg3 = (int) -1 ;
13126 wxImage *result = 0 ;
13127 wxPyInputStream *temp1 ;
13128 bool created1 ;
13129 bool temp2 = false ;
13130 int val3 ;
13131 int ecode3 = 0 ;
13132 PyObject * obj0 = 0 ;
13133 PyObject * obj1 = 0 ;
13134 PyObject * obj2 = 0 ;
13135 char * kwnames[] = {
13136 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13137 };
13138
13139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13140 {
13141 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13142 arg1 = temp1->m_wxis;
13143 created1 = false;
13144 } else {
13145 PyErr_Clear(); // clear the failure of the wxPyConvert above
13146 arg1 = wxPyCBInputStream_create(obj0, false);
13147 if (arg1 == NULL) {
13148 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13149 SWIG_fail;
13150 }
13151 created1 = true;
13152 }
13153 }
13154 {
13155 arg2 = wxString_in_helper(obj1);
13156 if (arg2 == NULL) SWIG_fail;
13157 temp2 = true;
13158 }
13159 if (obj2) {
13160 ecode3 = SWIG_AsVal_int(obj2, &val3);
13161 if (!SWIG_IsOK(ecode3)) {
13162 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13163 }
13164 arg3 = static_cast< int >(val3);
13165 }
13166 {
13167 PyThreadState* __tstate = wxPyBeginAllowThreads();
13168 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13169 wxPyEndAllowThreads(__tstate);
13170 if (PyErr_Occurred()) SWIG_fail;
13171 }
13172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13173 {
13174 if (created1) delete arg1;
13175 }
13176 {
13177 if (temp2)
13178 delete arg2;
13179 }
13180 return resultobj;
13181 fail:
13182 {
13183 if (created1) delete arg1;
13184 }
13185 {
13186 if (temp2)
13187 delete arg2;
13188 }
13189 return NULL;
13190 }
13191
13192
13193 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13194 PyObject *resultobj = 0;
13195 int arg1 = (int) 0 ;
13196 int arg2 = (int) 0 ;
13197 bool arg3 = (bool) true ;
13198 wxImage *result = 0 ;
13199 int val1 ;
13200 int ecode1 = 0 ;
13201 int val2 ;
13202 int ecode2 = 0 ;
13203 bool val3 ;
13204 int ecode3 = 0 ;
13205 PyObject * obj0 = 0 ;
13206 PyObject * obj1 = 0 ;
13207 PyObject * obj2 = 0 ;
13208 char * kwnames[] = {
13209 (char *) "width",(char *) "height",(char *) "clear", NULL
13210 };
13211
13212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13213 if (obj0) {
13214 ecode1 = SWIG_AsVal_int(obj0, &val1);
13215 if (!SWIG_IsOK(ecode1)) {
13216 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13217 }
13218 arg1 = static_cast< int >(val1);
13219 }
13220 if (obj1) {
13221 ecode2 = SWIG_AsVal_int(obj1, &val2);
13222 if (!SWIG_IsOK(ecode2)) {
13223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13224 }
13225 arg2 = static_cast< int >(val2);
13226 }
13227 if (obj2) {
13228 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13229 if (!SWIG_IsOK(ecode3)) {
13230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13231 }
13232 arg3 = static_cast< bool >(val3);
13233 }
13234 {
13235 PyThreadState* __tstate = wxPyBeginAllowThreads();
13236 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13237 wxPyEndAllowThreads(__tstate);
13238 if (PyErr_Occurred()) SWIG_fail;
13239 }
13240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13241 return resultobj;
13242 fail:
13243 return NULL;
13244 }
13245
13246
13247 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13248 PyObject *resultobj = 0;
13249 wxBitmap *arg1 = 0 ;
13250 wxImage *result = 0 ;
13251 void *argp1 = 0 ;
13252 int res1 = 0 ;
13253 PyObject * obj0 = 0 ;
13254 char * kwnames[] = {
13255 (char *) "bitmap", NULL
13256 };
13257
13258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13259 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13260 if (!SWIG_IsOK(res1)) {
13261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13262 }
13263 if (!argp1) {
13264 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13265 }
13266 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13267 {
13268 if (!wxPyCheckForApp()) SWIG_fail;
13269 PyThreadState* __tstate = wxPyBeginAllowThreads();
13270 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13271 wxPyEndAllowThreads(__tstate);
13272 if (PyErr_Occurred()) SWIG_fail;
13273 }
13274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13275 return resultobj;
13276 fail:
13277 return NULL;
13278 }
13279
13280
13281 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13282 PyObject *resultobj = 0;
13283 int arg1 ;
13284 int arg2 ;
13285 buffer arg3 ;
13286 int arg4 ;
13287 wxImage *result = 0 ;
13288 int val1 ;
13289 int ecode1 = 0 ;
13290 int val2 ;
13291 int ecode2 = 0 ;
13292 PyObject * obj0 = 0 ;
13293 PyObject * obj1 = 0 ;
13294 PyObject * obj2 = 0 ;
13295 char * kwnames[] = {
13296 (char *) "width",(char *) "height",(char *) "data", NULL
13297 };
13298
13299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13300 ecode1 = SWIG_AsVal_int(obj0, &val1);
13301 if (!SWIG_IsOK(ecode1)) {
13302 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13303 }
13304 arg1 = static_cast< int >(val1);
13305 ecode2 = SWIG_AsVal_int(obj1, &val2);
13306 if (!SWIG_IsOK(ecode2)) {
13307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13308 }
13309 arg2 = static_cast< int >(val2);
13310 {
13311 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13312 }
13313 {
13314 PyThreadState* __tstate = wxPyBeginAllowThreads();
13315 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13316 wxPyEndAllowThreads(__tstate);
13317 if (PyErr_Occurred()) SWIG_fail;
13318 }
13319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13320 return resultobj;
13321 fail:
13322 return NULL;
13323 }
13324
13325
13326 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13327 PyObject *resultobj = 0;
13328 int arg1 ;
13329 int arg2 ;
13330 buffer arg3 ;
13331 int arg4 ;
13332 buffer arg5 ;
13333 int arg6 ;
13334 wxImage *result = 0 ;
13335 int val1 ;
13336 int ecode1 = 0 ;
13337 int val2 ;
13338 int ecode2 = 0 ;
13339 PyObject * obj0 = 0 ;
13340 PyObject * obj1 = 0 ;
13341 PyObject * obj2 = 0 ;
13342 PyObject * obj3 = 0 ;
13343 char * kwnames[] = {
13344 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13345 };
13346
13347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13348 ecode1 = SWIG_AsVal_int(obj0, &val1);
13349 if (!SWIG_IsOK(ecode1)) {
13350 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13351 }
13352 arg1 = static_cast< int >(val1);
13353 ecode2 = SWIG_AsVal_int(obj1, &val2);
13354 if (!SWIG_IsOK(ecode2)) {
13355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13356 }
13357 arg2 = static_cast< int >(val2);
13358 {
13359 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13360 }
13361 {
13362 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13363 }
13364 {
13365 PyThreadState* __tstate = wxPyBeginAllowThreads();
13366 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13367 wxPyEndAllowThreads(__tstate);
13368 if (PyErr_Occurred()) SWIG_fail;
13369 }
13370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13371 return resultobj;
13372 fail:
13373 return NULL;
13374 }
13375
13376
13377 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13378 PyObject *resultobj = 0;
13379 wxImage *arg1 = (wxImage *) 0 ;
13380 int arg2 ;
13381 int arg3 ;
13382 bool arg4 = (bool) true ;
13383 void *argp1 = 0 ;
13384 int res1 = 0 ;
13385 int val2 ;
13386 int ecode2 = 0 ;
13387 int val3 ;
13388 int ecode3 = 0 ;
13389 bool val4 ;
13390 int ecode4 = 0 ;
13391 PyObject * obj0 = 0 ;
13392 PyObject * obj1 = 0 ;
13393 PyObject * obj2 = 0 ;
13394 PyObject * obj3 = 0 ;
13395 char * kwnames[] = {
13396 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13397 };
13398
13399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13401 if (!SWIG_IsOK(res1)) {
13402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13403 }
13404 arg1 = reinterpret_cast< wxImage * >(argp1);
13405 ecode2 = SWIG_AsVal_int(obj1, &val2);
13406 if (!SWIG_IsOK(ecode2)) {
13407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13408 }
13409 arg2 = static_cast< int >(val2);
13410 ecode3 = SWIG_AsVal_int(obj2, &val3);
13411 if (!SWIG_IsOK(ecode3)) {
13412 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13413 }
13414 arg3 = static_cast< int >(val3);
13415 if (obj3) {
13416 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13417 if (!SWIG_IsOK(ecode4)) {
13418 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13419 }
13420 arg4 = static_cast< bool >(val4);
13421 }
13422 {
13423 PyThreadState* __tstate = wxPyBeginAllowThreads();
13424 (arg1)->Create(arg2,arg3,arg4);
13425 wxPyEndAllowThreads(__tstate);
13426 if (PyErr_Occurred()) SWIG_fail;
13427 }
13428 resultobj = SWIG_Py_Void();
13429 return resultobj;
13430 fail:
13431 return NULL;
13432 }
13433
13434
13435 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13436 PyObject *resultobj = 0;
13437 wxImage *arg1 = (wxImage *) 0 ;
13438 void *argp1 = 0 ;
13439 int res1 = 0 ;
13440 PyObject *swig_obj[1] ;
13441
13442 if (!args) SWIG_fail;
13443 swig_obj[0] = args;
13444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13445 if (!SWIG_IsOK(res1)) {
13446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13447 }
13448 arg1 = reinterpret_cast< wxImage * >(argp1);
13449 {
13450 PyThreadState* __tstate = wxPyBeginAllowThreads();
13451 (arg1)->Destroy();
13452 wxPyEndAllowThreads(__tstate);
13453 if (PyErr_Occurred()) SWIG_fail;
13454 }
13455 resultobj = SWIG_Py_Void();
13456 return resultobj;
13457 fail:
13458 return NULL;
13459 }
13460
13461
13462 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13463 PyObject *resultobj = 0;
13464 wxImage *arg1 = (wxImage *) 0 ;
13465 int arg2 ;
13466 int arg3 ;
13467 SwigValueWrapper<wxImage > result;
13468 void *argp1 = 0 ;
13469 int res1 = 0 ;
13470 int val2 ;
13471 int ecode2 = 0 ;
13472 int val3 ;
13473 int ecode3 = 0 ;
13474 PyObject * obj0 = 0 ;
13475 PyObject * obj1 = 0 ;
13476 PyObject * obj2 = 0 ;
13477 char * kwnames[] = {
13478 (char *) "self",(char *) "width",(char *) "height", NULL
13479 };
13480
13481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13483 if (!SWIG_IsOK(res1)) {
13484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13485 }
13486 arg1 = reinterpret_cast< wxImage * >(argp1);
13487 ecode2 = SWIG_AsVal_int(obj1, &val2);
13488 if (!SWIG_IsOK(ecode2)) {
13489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13490 }
13491 arg2 = static_cast< int >(val2);
13492 ecode3 = SWIG_AsVal_int(obj2, &val3);
13493 if (!SWIG_IsOK(ecode3)) {
13494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13495 }
13496 arg3 = static_cast< int >(val3);
13497 {
13498 PyThreadState* __tstate = wxPyBeginAllowThreads();
13499 result = (arg1)->Scale(arg2,arg3);
13500 wxPyEndAllowThreads(__tstate);
13501 if (PyErr_Occurred()) SWIG_fail;
13502 }
13503 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13504 return resultobj;
13505 fail:
13506 return NULL;
13507 }
13508
13509
13510 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13511 PyObject *resultobj = 0;
13512 wxImage *arg1 = (wxImage *) 0 ;
13513 int arg2 ;
13514 int arg3 ;
13515 SwigValueWrapper<wxImage > result;
13516 void *argp1 = 0 ;
13517 int res1 = 0 ;
13518 int val2 ;
13519 int ecode2 = 0 ;
13520 int val3 ;
13521 int ecode3 = 0 ;
13522 PyObject * obj0 = 0 ;
13523 PyObject * obj1 = 0 ;
13524 PyObject * obj2 = 0 ;
13525 char * kwnames[] = {
13526 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13527 };
13528
13529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13531 if (!SWIG_IsOK(res1)) {
13532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13533 }
13534 arg1 = reinterpret_cast< wxImage * >(argp1);
13535 ecode2 = SWIG_AsVal_int(obj1, &val2);
13536 if (!SWIG_IsOK(ecode2)) {
13537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13538 }
13539 arg2 = static_cast< int >(val2);
13540 ecode3 = SWIG_AsVal_int(obj2, &val3);
13541 if (!SWIG_IsOK(ecode3)) {
13542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13543 }
13544 arg3 = static_cast< int >(val3);
13545 {
13546 PyThreadState* __tstate = wxPyBeginAllowThreads();
13547 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13548 wxPyEndAllowThreads(__tstate);
13549 if (PyErr_Occurred()) SWIG_fail;
13550 }
13551 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13552 return resultobj;
13553 fail:
13554 return NULL;
13555 }
13556
13557
13558 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13559 PyObject *resultobj = 0;
13560 wxImage *arg1 = (wxImage *) 0 ;
13561 int arg2 ;
13562 int arg3 ;
13563 wxImage *result = 0 ;
13564 void *argp1 = 0 ;
13565 int res1 = 0 ;
13566 int val2 ;
13567 int ecode2 = 0 ;
13568 int val3 ;
13569 int ecode3 = 0 ;
13570 PyObject * obj0 = 0 ;
13571 PyObject * obj1 = 0 ;
13572 PyObject * obj2 = 0 ;
13573 char * kwnames[] = {
13574 (char *) "self",(char *) "width",(char *) "height", NULL
13575 };
13576
13577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13579 if (!SWIG_IsOK(res1)) {
13580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13581 }
13582 arg1 = reinterpret_cast< wxImage * >(argp1);
13583 ecode2 = SWIG_AsVal_int(obj1, &val2);
13584 if (!SWIG_IsOK(ecode2)) {
13585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13586 }
13587 arg2 = static_cast< int >(val2);
13588 ecode3 = SWIG_AsVal_int(obj2, &val3);
13589 if (!SWIG_IsOK(ecode3)) {
13590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13591 }
13592 arg3 = static_cast< int >(val3);
13593 {
13594 PyThreadState* __tstate = wxPyBeginAllowThreads();
13595 {
13596 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13597 result = (wxImage *) &_result_ref;
13598 }
13599 wxPyEndAllowThreads(__tstate);
13600 if (PyErr_Occurred()) SWIG_fail;
13601 }
13602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13603 return resultobj;
13604 fail:
13605 return NULL;
13606 }
13607
13608
13609 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13610 PyObject *resultobj = 0;
13611 wxImage *arg1 = (wxImage *) 0 ;
13612 wxSize *arg2 = 0 ;
13613 wxPoint *arg3 = 0 ;
13614 int arg4 = (int) -1 ;
13615 int arg5 = (int) -1 ;
13616 int arg6 = (int) -1 ;
13617 wxImage *result = 0 ;
13618 void *argp1 = 0 ;
13619 int res1 = 0 ;
13620 wxSize temp2 ;
13621 wxPoint temp3 ;
13622 int val4 ;
13623 int ecode4 = 0 ;
13624 int val5 ;
13625 int ecode5 = 0 ;
13626 int val6 ;
13627 int ecode6 = 0 ;
13628 PyObject * obj0 = 0 ;
13629 PyObject * obj1 = 0 ;
13630 PyObject * obj2 = 0 ;
13631 PyObject * obj3 = 0 ;
13632 PyObject * obj4 = 0 ;
13633 PyObject * obj5 = 0 ;
13634 char * kwnames[] = {
13635 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13636 };
13637
13638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13640 if (!SWIG_IsOK(res1)) {
13641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13642 }
13643 arg1 = reinterpret_cast< wxImage * >(argp1);
13644 {
13645 arg2 = &temp2;
13646 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13647 }
13648 {
13649 arg3 = &temp3;
13650 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13651 }
13652 if (obj3) {
13653 ecode4 = SWIG_AsVal_int(obj3, &val4);
13654 if (!SWIG_IsOK(ecode4)) {
13655 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13656 }
13657 arg4 = static_cast< int >(val4);
13658 }
13659 if (obj4) {
13660 ecode5 = SWIG_AsVal_int(obj4, &val5);
13661 if (!SWIG_IsOK(ecode5)) {
13662 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13663 }
13664 arg5 = static_cast< int >(val5);
13665 }
13666 if (obj5) {
13667 ecode6 = SWIG_AsVal_int(obj5, &val6);
13668 if (!SWIG_IsOK(ecode6)) {
13669 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13670 }
13671 arg6 = static_cast< int >(val6);
13672 }
13673 {
13674 PyThreadState* __tstate = wxPyBeginAllowThreads();
13675 {
13676 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13677 result = (wxImage *) &_result_ref;
13678 }
13679 wxPyEndAllowThreads(__tstate);
13680 if (PyErr_Occurred()) SWIG_fail;
13681 }
13682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13683 return resultobj;
13684 fail:
13685 return NULL;
13686 }
13687
13688
13689 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13690 PyObject *resultobj = 0;
13691 wxImage *arg1 = (wxImage *) 0 ;
13692 int arg2 ;
13693 int arg3 ;
13694 byte arg4 ;
13695 byte arg5 ;
13696 byte arg6 ;
13697 void *argp1 = 0 ;
13698 int res1 = 0 ;
13699 int val2 ;
13700 int ecode2 = 0 ;
13701 int val3 ;
13702 int ecode3 = 0 ;
13703 unsigned char val4 ;
13704 int ecode4 = 0 ;
13705 unsigned char val5 ;
13706 int ecode5 = 0 ;
13707 unsigned char val6 ;
13708 int ecode6 = 0 ;
13709 PyObject * obj0 = 0 ;
13710 PyObject * obj1 = 0 ;
13711 PyObject * obj2 = 0 ;
13712 PyObject * obj3 = 0 ;
13713 PyObject * obj4 = 0 ;
13714 PyObject * obj5 = 0 ;
13715 char * kwnames[] = {
13716 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13717 };
13718
13719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13721 if (!SWIG_IsOK(res1)) {
13722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13723 }
13724 arg1 = reinterpret_cast< wxImage * >(argp1);
13725 ecode2 = SWIG_AsVal_int(obj1, &val2);
13726 if (!SWIG_IsOK(ecode2)) {
13727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13728 }
13729 arg2 = static_cast< int >(val2);
13730 ecode3 = SWIG_AsVal_int(obj2, &val3);
13731 if (!SWIG_IsOK(ecode3)) {
13732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13733 }
13734 arg3 = static_cast< int >(val3);
13735 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13736 if (!SWIG_IsOK(ecode4)) {
13737 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13738 }
13739 arg4 = static_cast< byte >(val4);
13740 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13741 if (!SWIG_IsOK(ecode5)) {
13742 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13743 }
13744 arg5 = static_cast< byte >(val5);
13745 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13746 if (!SWIG_IsOK(ecode6)) {
13747 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13748 }
13749 arg6 = static_cast< byte >(val6);
13750 {
13751 PyThreadState* __tstate = wxPyBeginAllowThreads();
13752 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13753 wxPyEndAllowThreads(__tstate);
13754 if (PyErr_Occurred()) SWIG_fail;
13755 }
13756 resultobj = SWIG_Py_Void();
13757 return resultobj;
13758 fail:
13759 return NULL;
13760 }
13761
13762
13763 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13764 PyObject *resultobj = 0;
13765 wxImage *arg1 = (wxImage *) 0 ;
13766 wxRect *arg2 = 0 ;
13767 byte arg3 ;
13768 byte arg4 ;
13769 byte arg5 ;
13770 void *argp1 = 0 ;
13771 int res1 = 0 ;
13772 wxRect temp2 ;
13773 unsigned char val3 ;
13774 int ecode3 = 0 ;
13775 unsigned char val4 ;
13776 int ecode4 = 0 ;
13777 unsigned char val5 ;
13778 int ecode5 = 0 ;
13779 PyObject * obj0 = 0 ;
13780 PyObject * obj1 = 0 ;
13781 PyObject * obj2 = 0 ;
13782 PyObject * obj3 = 0 ;
13783 PyObject * obj4 = 0 ;
13784 char * kwnames[] = {
13785 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13786 };
13787
13788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13790 if (!SWIG_IsOK(res1)) {
13791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13792 }
13793 arg1 = reinterpret_cast< wxImage * >(argp1);
13794 {
13795 arg2 = &temp2;
13796 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13797 }
13798 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13799 if (!SWIG_IsOK(ecode3)) {
13800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13801 }
13802 arg3 = static_cast< byte >(val3);
13803 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13804 if (!SWIG_IsOK(ecode4)) {
13805 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13806 }
13807 arg4 = static_cast< byte >(val4);
13808 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13809 if (!SWIG_IsOK(ecode5)) {
13810 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13811 }
13812 arg5 = static_cast< byte >(val5);
13813 {
13814 PyThreadState* __tstate = wxPyBeginAllowThreads();
13815 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13816 wxPyEndAllowThreads(__tstate);
13817 if (PyErr_Occurred()) SWIG_fail;
13818 }
13819 resultobj = SWIG_Py_Void();
13820 return resultobj;
13821 fail:
13822 return NULL;
13823 }
13824
13825
13826 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13827 PyObject *resultobj = 0;
13828 wxImage *arg1 = (wxImage *) 0 ;
13829 int arg2 ;
13830 int arg3 ;
13831 byte result;
13832 void *argp1 = 0 ;
13833 int res1 = 0 ;
13834 int val2 ;
13835 int ecode2 = 0 ;
13836 int val3 ;
13837 int ecode3 = 0 ;
13838 PyObject * obj0 = 0 ;
13839 PyObject * obj1 = 0 ;
13840 PyObject * obj2 = 0 ;
13841 char * kwnames[] = {
13842 (char *) "self",(char *) "x",(char *) "y", NULL
13843 };
13844
13845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13847 if (!SWIG_IsOK(res1)) {
13848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13849 }
13850 arg1 = reinterpret_cast< wxImage * >(argp1);
13851 ecode2 = SWIG_AsVal_int(obj1, &val2);
13852 if (!SWIG_IsOK(ecode2)) {
13853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13854 }
13855 arg2 = static_cast< int >(val2);
13856 ecode3 = SWIG_AsVal_int(obj2, &val3);
13857 if (!SWIG_IsOK(ecode3)) {
13858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13859 }
13860 arg3 = static_cast< int >(val3);
13861 {
13862 PyThreadState* __tstate = wxPyBeginAllowThreads();
13863 result = (byte)(arg1)->GetRed(arg2,arg3);
13864 wxPyEndAllowThreads(__tstate);
13865 if (PyErr_Occurred()) SWIG_fail;
13866 }
13867 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13868 return resultobj;
13869 fail:
13870 return NULL;
13871 }
13872
13873
13874 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13875 PyObject *resultobj = 0;
13876 wxImage *arg1 = (wxImage *) 0 ;
13877 int arg2 ;
13878 int arg3 ;
13879 byte result;
13880 void *argp1 = 0 ;
13881 int res1 = 0 ;
13882 int val2 ;
13883 int ecode2 = 0 ;
13884 int val3 ;
13885 int ecode3 = 0 ;
13886 PyObject * obj0 = 0 ;
13887 PyObject * obj1 = 0 ;
13888 PyObject * obj2 = 0 ;
13889 char * kwnames[] = {
13890 (char *) "self",(char *) "x",(char *) "y", NULL
13891 };
13892
13893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13895 if (!SWIG_IsOK(res1)) {
13896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13897 }
13898 arg1 = reinterpret_cast< wxImage * >(argp1);
13899 ecode2 = SWIG_AsVal_int(obj1, &val2);
13900 if (!SWIG_IsOK(ecode2)) {
13901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13902 }
13903 arg2 = static_cast< int >(val2);
13904 ecode3 = SWIG_AsVal_int(obj2, &val3);
13905 if (!SWIG_IsOK(ecode3)) {
13906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13907 }
13908 arg3 = static_cast< int >(val3);
13909 {
13910 PyThreadState* __tstate = wxPyBeginAllowThreads();
13911 result = (byte)(arg1)->GetGreen(arg2,arg3);
13912 wxPyEndAllowThreads(__tstate);
13913 if (PyErr_Occurred()) SWIG_fail;
13914 }
13915 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13916 return resultobj;
13917 fail:
13918 return NULL;
13919 }
13920
13921
13922 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13923 PyObject *resultobj = 0;
13924 wxImage *arg1 = (wxImage *) 0 ;
13925 int arg2 ;
13926 int arg3 ;
13927 byte result;
13928 void *argp1 = 0 ;
13929 int res1 = 0 ;
13930 int val2 ;
13931 int ecode2 = 0 ;
13932 int val3 ;
13933 int ecode3 = 0 ;
13934 PyObject * obj0 = 0 ;
13935 PyObject * obj1 = 0 ;
13936 PyObject * obj2 = 0 ;
13937 char * kwnames[] = {
13938 (char *) "self",(char *) "x",(char *) "y", NULL
13939 };
13940
13941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13943 if (!SWIG_IsOK(res1)) {
13944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13945 }
13946 arg1 = reinterpret_cast< wxImage * >(argp1);
13947 ecode2 = SWIG_AsVal_int(obj1, &val2);
13948 if (!SWIG_IsOK(ecode2)) {
13949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13950 }
13951 arg2 = static_cast< int >(val2);
13952 ecode3 = SWIG_AsVal_int(obj2, &val3);
13953 if (!SWIG_IsOK(ecode3)) {
13954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13955 }
13956 arg3 = static_cast< int >(val3);
13957 {
13958 PyThreadState* __tstate = wxPyBeginAllowThreads();
13959 result = (byte)(arg1)->GetBlue(arg2,arg3);
13960 wxPyEndAllowThreads(__tstate);
13961 if (PyErr_Occurred()) SWIG_fail;
13962 }
13963 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13964 return resultobj;
13965 fail:
13966 return NULL;
13967 }
13968
13969
13970 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13971 PyObject *resultobj = 0;
13972 wxImage *arg1 = (wxImage *) 0 ;
13973 int arg2 ;
13974 int arg3 ;
13975 byte arg4 ;
13976 void *argp1 = 0 ;
13977 int res1 = 0 ;
13978 int val2 ;
13979 int ecode2 = 0 ;
13980 int val3 ;
13981 int ecode3 = 0 ;
13982 unsigned char val4 ;
13983 int ecode4 = 0 ;
13984 PyObject * obj0 = 0 ;
13985 PyObject * obj1 = 0 ;
13986 PyObject * obj2 = 0 ;
13987 PyObject * obj3 = 0 ;
13988 char * kwnames[] = {
13989 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13990 };
13991
13992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13994 if (!SWIG_IsOK(res1)) {
13995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13996 }
13997 arg1 = reinterpret_cast< wxImage * >(argp1);
13998 ecode2 = SWIG_AsVal_int(obj1, &val2);
13999 if (!SWIG_IsOK(ecode2)) {
14000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14001 }
14002 arg2 = static_cast< int >(val2);
14003 ecode3 = SWIG_AsVal_int(obj2, &val3);
14004 if (!SWIG_IsOK(ecode3)) {
14005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14006 }
14007 arg3 = static_cast< int >(val3);
14008 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14009 if (!SWIG_IsOK(ecode4)) {
14010 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14011 }
14012 arg4 = static_cast< byte >(val4);
14013 {
14014 PyThreadState* __tstate = wxPyBeginAllowThreads();
14015 (arg1)->SetAlpha(arg2,arg3,arg4);
14016 wxPyEndAllowThreads(__tstate);
14017 if (PyErr_Occurred()) SWIG_fail;
14018 }
14019 resultobj = SWIG_Py_Void();
14020 return resultobj;
14021 fail:
14022 return NULL;
14023 }
14024
14025
14026 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14027 PyObject *resultobj = 0;
14028 wxImage *arg1 = (wxImage *) 0 ;
14029 int arg2 ;
14030 int arg3 ;
14031 byte result;
14032 void *argp1 = 0 ;
14033 int res1 = 0 ;
14034 int val2 ;
14035 int ecode2 = 0 ;
14036 int val3 ;
14037 int ecode3 = 0 ;
14038 PyObject * obj0 = 0 ;
14039 PyObject * obj1 = 0 ;
14040 PyObject * obj2 = 0 ;
14041 char * kwnames[] = {
14042 (char *) "self",(char *) "x",(char *) "y", NULL
14043 };
14044
14045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14047 if (!SWIG_IsOK(res1)) {
14048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14049 }
14050 arg1 = reinterpret_cast< wxImage * >(argp1);
14051 ecode2 = SWIG_AsVal_int(obj1, &val2);
14052 if (!SWIG_IsOK(ecode2)) {
14053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14054 }
14055 arg2 = static_cast< int >(val2);
14056 ecode3 = SWIG_AsVal_int(obj2, &val3);
14057 if (!SWIG_IsOK(ecode3)) {
14058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14059 }
14060 arg3 = static_cast< int >(val3);
14061 {
14062 PyThreadState* __tstate = wxPyBeginAllowThreads();
14063 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14064 wxPyEndAllowThreads(__tstate);
14065 if (PyErr_Occurred()) SWIG_fail;
14066 }
14067 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14068 return resultobj;
14069 fail:
14070 return NULL;
14071 }
14072
14073
14074 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14075 PyObject *resultobj = 0;
14076 wxImage *arg1 = (wxImage *) 0 ;
14077 bool result;
14078 void *argp1 = 0 ;
14079 int res1 = 0 ;
14080 PyObject *swig_obj[1] ;
14081
14082 if (!args) SWIG_fail;
14083 swig_obj[0] = args;
14084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14085 if (!SWIG_IsOK(res1)) {
14086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14087 }
14088 arg1 = reinterpret_cast< wxImage * >(argp1);
14089 {
14090 PyThreadState* __tstate = wxPyBeginAllowThreads();
14091 result = (bool)(arg1)->HasAlpha();
14092 wxPyEndAllowThreads(__tstate);
14093 if (PyErr_Occurred()) SWIG_fail;
14094 }
14095 {
14096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14097 }
14098 return resultobj;
14099 fail:
14100 return NULL;
14101 }
14102
14103
14104 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14105 PyObject *resultobj = 0;
14106 wxImage *arg1 = (wxImage *) 0 ;
14107 void *argp1 = 0 ;
14108 int res1 = 0 ;
14109 PyObject *swig_obj[1] ;
14110
14111 if (!args) SWIG_fail;
14112 swig_obj[0] = args;
14113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14114 if (!SWIG_IsOK(res1)) {
14115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14116 }
14117 arg1 = reinterpret_cast< wxImage * >(argp1);
14118 {
14119 PyThreadState* __tstate = wxPyBeginAllowThreads();
14120 (arg1)->InitAlpha();
14121 wxPyEndAllowThreads(__tstate);
14122 if (PyErr_Occurred()) SWIG_fail;
14123 }
14124 resultobj = SWIG_Py_Void();
14125 return resultobj;
14126 fail:
14127 return NULL;
14128 }
14129
14130
14131 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14132 PyObject *resultobj = 0;
14133 wxImage *arg1 = (wxImage *) 0 ;
14134 int arg2 ;
14135 int arg3 ;
14136 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14137 bool result;
14138 void *argp1 = 0 ;
14139 int res1 = 0 ;
14140 int val2 ;
14141 int ecode2 = 0 ;
14142 int val3 ;
14143 int ecode3 = 0 ;
14144 unsigned char val4 ;
14145 int ecode4 = 0 ;
14146 PyObject * obj0 = 0 ;
14147 PyObject * obj1 = 0 ;
14148 PyObject * obj2 = 0 ;
14149 PyObject * obj3 = 0 ;
14150 char * kwnames[] = {
14151 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14152 };
14153
14154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14156 if (!SWIG_IsOK(res1)) {
14157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14158 }
14159 arg1 = reinterpret_cast< wxImage * >(argp1);
14160 ecode2 = SWIG_AsVal_int(obj1, &val2);
14161 if (!SWIG_IsOK(ecode2)) {
14162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14163 }
14164 arg2 = static_cast< int >(val2);
14165 ecode3 = SWIG_AsVal_int(obj2, &val3);
14166 if (!SWIG_IsOK(ecode3)) {
14167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14168 }
14169 arg3 = static_cast< int >(val3);
14170 if (obj3) {
14171 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14172 if (!SWIG_IsOK(ecode4)) {
14173 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14174 }
14175 arg4 = static_cast< byte >(val4);
14176 }
14177 {
14178 PyThreadState* __tstate = wxPyBeginAllowThreads();
14179 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14180 wxPyEndAllowThreads(__tstate);
14181 if (PyErr_Occurred()) SWIG_fail;
14182 }
14183 {
14184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14185 }
14186 return resultobj;
14187 fail:
14188 return NULL;
14189 }
14190
14191
14192 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14193 PyObject *resultobj = 0;
14194 wxImage *arg1 = (wxImage *) 0 ;
14195 byte *arg2 = (byte *) 0 ;
14196 byte *arg3 = (byte *) 0 ;
14197 byte *arg4 = (byte *) 0 ;
14198 byte arg5 = (byte) 0 ;
14199 byte arg6 = (byte) 0 ;
14200 byte arg7 = (byte) 0 ;
14201 bool result;
14202 void *argp1 = 0 ;
14203 int res1 = 0 ;
14204 byte temp2 ;
14205 int res2 = SWIG_TMPOBJ ;
14206 byte temp3 ;
14207 int res3 = SWIG_TMPOBJ ;
14208 byte temp4 ;
14209 int res4 = SWIG_TMPOBJ ;
14210 unsigned char val5 ;
14211 int ecode5 = 0 ;
14212 unsigned char val6 ;
14213 int ecode6 = 0 ;
14214 unsigned char val7 ;
14215 int ecode7 = 0 ;
14216 PyObject * obj0 = 0 ;
14217 PyObject * obj1 = 0 ;
14218 PyObject * obj2 = 0 ;
14219 PyObject * obj3 = 0 ;
14220 char * kwnames[] = {
14221 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14222 };
14223
14224 arg2 = &temp2;
14225 arg3 = &temp3;
14226 arg4 = &temp4;
14227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14229 if (!SWIG_IsOK(res1)) {
14230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14231 }
14232 arg1 = reinterpret_cast< wxImage * >(argp1);
14233 if (obj1) {
14234 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14235 if (!SWIG_IsOK(ecode5)) {
14236 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14237 }
14238 arg5 = static_cast< byte >(val5);
14239 }
14240 if (obj2) {
14241 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14242 if (!SWIG_IsOK(ecode6)) {
14243 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14244 }
14245 arg6 = static_cast< byte >(val6);
14246 }
14247 if (obj3) {
14248 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14249 if (!SWIG_IsOK(ecode7)) {
14250 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14251 }
14252 arg7 = static_cast< byte >(val7);
14253 }
14254 {
14255 PyThreadState* __tstate = wxPyBeginAllowThreads();
14256 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14257 wxPyEndAllowThreads(__tstate);
14258 if (PyErr_Occurred()) SWIG_fail;
14259 }
14260 {
14261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14262 }
14263 if (SWIG_IsTmpObj(res2)) {
14264 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14265 } else {
14266 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14267 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14268 }
14269 if (SWIG_IsTmpObj(res3)) {
14270 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14271 } else {
14272 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14273 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14274 }
14275 if (SWIG_IsTmpObj(res4)) {
14276 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14277 } else {
14278 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14279 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14280 }
14281 return resultobj;
14282 fail:
14283 return NULL;
14284 }
14285
14286
14287 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14288 PyObject *resultobj = 0;
14289 wxImage *arg1 = (wxImage *) 0 ;
14290 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14291 bool result;
14292 void *argp1 = 0 ;
14293 int res1 = 0 ;
14294 unsigned char val2 ;
14295 int ecode2 = 0 ;
14296 PyObject * obj0 = 0 ;
14297 PyObject * obj1 = 0 ;
14298 char * kwnames[] = {
14299 (char *) "self",(char *) "threshold", NULL
14300 };
14301
14302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14304 if (!SWIG_IsOK(res1)) {
14305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14306 }
14307 arg1 = reinterpret_cast< wxImage * >(argp1);
14308 if (obj1) {
14309 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14310 if (!SWIG_IsOK(ecode2)) {
14311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14312 }
14313 arg2 = static_cast< byte >(val2);
14314 }
14315 {
14316 PyThreadState* __tstate = wxPyBeginAllowThreads();
14317 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14318 wxPyEndAllowThreads(__tstate);
14319 if (PyErr_Occurred()) SWIG_fail;
14320 }
14321 {
14322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14323 }
14324 return resultobj;
14325 fail:
14326 return NULL;
14327 }
14328
14329
14330 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14331 PyObject *resultobj = 0;
14332 wxImage *arg1 = (wxImage *) 0 ;
14333 byte arg2 ;
14334 byte arg3 ;
14335 byte arg4 ;
14336 bool result;
14337 void *argp1 = 0 ;
14338 int res1 = 0 ;
14339 unsigned char val2 ;
14340 int ecode2 = 0 ;
14341 unsigned char val3 ;
14342 int ecode3 = 0 ;
14343 unsigned char val4 ;
14344 int ecode4 = 0 ;
14345 PyObject * obj0 = 0 ;
14346 PyObject * obj1 = 0 ;
14347 PyObject * obj2 = 0 ;
14348 PyObject * obj3 = 0 ;
14349 char * kwnames[] = {
14350 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14351 };
14352
14353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14355 if (!SWIG_IsOK(res1)) {
14356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14357 }
14358 arg1 = reinterpret_cast< wxImage * >(argp1);
14359 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14360 if (!SWIG_IsOK(ecode2)) {
14361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14362 }
14363 arg2 = static_cast< byte >(val2);
14364 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14365 if (!SWIG_IsOK(ecode3)) {
14366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14367 }
14368 arg3 = static_cast< byte >(val3);
14369 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14370 if (!SWIG_IsOK(ecode4)) {
14371 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14372 }
14373 arg4 = static_cast< byte >(val4);
14374 {
14375 PyThreadState* __tstate = wxPyBeginAllowThreads();
14376 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14377 wxPyEndAllowThreads(__tstate);
14378 if (PyErr_Occurred()) SWIG_fail;
14379 }
14380 {
14381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14382 }
14383 return resultobj;
14384 fail:
14385 return NULL;
14386 }
14387
14388
14389 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14390 PyObject *resultobj = 0;
14391 wxImage *arg1 = (wxImage *) 0 ;
14392 wxImage *arg2 = 0 ;
14393 byte arg3 ;
14394 byte arg4 ;
14395 byte arg5 ;
14396 bool result;
14397 void *argp1 = 0 ;
14398 int res1 = 0 ;
14399 void *argp2 = 0 ;
14400 int res2 = 0 ;
14401 unsigned char val3 ;
14402 int ecode3 = 0 ;
14403 unsigned char val4 ;
14404 int ecode4 = 0 ;
14405 unsigned char val5 ;
14406 int ecode5 = 0 ;
14407 PyObject * obj0 = 0 ;
14408 PyObject * obj1 = 0 ;
14409 PyObject * obj2 = 0 ;
14410 PyObject * obj3 = 0 ;
14411 PyObject * obj4 = 0 ;
14412 char * kwnames[] = {
14413 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14414 };
14415
14416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14418 if (!SWIG_IsOK(res1)) {
14419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14420 }
14421 arg1 = reinterpret_cast< wxImage * >(argp1);
14422 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14423 if (!SWIG_IsOK(res2)) {
14424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14425 }
14426 if (!argp2) {
14427 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14428 }
14429 arg2 = reinterpret_cast< wxImage * >(argp2);
14430 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14431 if (!SWIG_IsOK(ecode3)) {
14432 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14433 }
14434 arg3 = static_cast< byte >(val3);
14435 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14436 if (!SWIG_IsOK(ecode4)) {
14437 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14438 }
14439 arg4 = static_cast< byte >(val4);
14440 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14441 if (!SWIG_IsOK(ecode5)) {
14442 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14443 }
14444 arg5 = static_cast< byte >(val5);
14445 {
14446 PyThreadState* __tstate = wxPyBeginAllowThreads();
14447 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14448 wxPyEndAllowThreads(__tstate);
14449 if (PyErr_Occurred()) SWIG_fail;
14450 }
14451 {
14452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14453 }
14454 return resultobj;
14455 fail:
14456 return NULL;
14457 }
14458
14459
14460 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14461 PyObject *resultobj = 0;
14462 wxString *arg1 = 0 ;
14463 bool result;
14464 bool temp1 = false ;
14465 PyObject * obj0 = 0 ;
14466 char * kwnames[] = {
14467 (char *) "filename", NULL
14468 };
14469
14470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14471 {
14472 arg1 = wxString_in_helper(obj0);
14473 if (arg1 == NULL) SWIG_fail;
14474 temp1 = true;
14475 }
14476 {
14477 PyThreadState* __tstate = wxPyBeginAllowThreads();
14478 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14479 wxPyEndAllowThreads(__tstate);
14480 if (PyErr_Occurred()) SWIG_fail;
14481 }
14482 {
14483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14484 }
14485 {
14486 if (temp1)
14487 delete arg1;
14488 }
14489 return resultobj;
14490 fail:
14491 {
14492 if (temp1)
14493 delete arg1;
14494 }
14495 return NULL;
14496 }
14497
14498
14499 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14500 PyObject *resultobj = 0;
14501 wxString *arg1 = 0 ;
14502 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14503 int result;
14504 bool temp1 = false ;
14505 long val2 ;
14506 int ecode2 = 0 ;
14507 PyObject * obj0 = 0 ;
14508 PyObject * obj1 = 0 ;
14509 char * kwnames[] = {
14510 (char *) "filename",(char *) "type", NULL
14511 };
14512
14513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14514 {
14515 arg1 = wxString_in_helper(obj0);
14516 if (arg1 == NULL) SWIG_fail;
14517 temp1 = true;
14518 }
14519 if (obj1) {
14520 ecode2 = SWIG_AsVal_long(obj1, &val2);
14521 if (!SWIG_IsOK(ecode2)) {
14522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14523 }
14524 arg2 = static_cast< long >(val2);
14525 }
14526 {
14527 PyThreadState* __tstate = wxPyBeginAllowThreads();
14528 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14529 wxPyEndAllowThreads(__tstate);
14530 if (PyErr_Occurred()) SWIG_fail;
14531 }
14532 resultobj = SWIG_From_int(static_cast< int >(result));
14533 {
14534 if (temp1)
14535 delete arg1;
14536 }
14537 return resultobj;
14538 fail:
14539 {
14540 if (temp1)
14541 delete arg1;
14542 }
14543 return NULL;
14544 }
14545
14546
14547 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14548 PyObject *resultobj = 0;
14549 wxImage *arg1 = (wxImage *) 0 ;
14550 wxString *arg2 = 0 ;
14551 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14552 int arg4 = (int) -1 ;
14553 bool result;
14554 void *argp1 = 0 ;
14555 int res1 = 0 ;
14556 bool temp2 = false ;
14557 long val3 ;
14558 int ecode3 = 0 ;
14559 int val4 ;
14560 int ecode4 = 0 ;
14561 PyObject * obj0 = 0 ;
14562 PyObject * obj1 = 0 ;
14563 PyObject * obj2 = 0 ;
14564 PyObject * obj3 = 0 ;
14565 char * kwnames[] = {
14566 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14567 };
14568
14569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14571 if (!SWIG_IsOK(res1)) {
14572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14573 }
14574 arg1 = reinterpret_cast< wxImage * >(argp1);
14575 {
14576 arg2 = wxString_in_helper(obj1);
14577 if (arg2 == NULL) SWIG_fail;
14578 temp2 = true;
14579 }
14580 if (obj2) {
14581 ecode3 = SWIG_AsVal_long(obj2, &val3);
14582 if (!SWIG_IsOK(ecode3)) {
14583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14584 }
14585 arg3 = static_cast< long >(val3);
14586 }
14587 if (obj3) {
14588 ecode4 = SWIG_AsVal_int(obj3, &val4);
14589 if (!SWIG_IsOK(ecode4)) {
14590 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14591 }
14592 arg4 = static_cast< int >(val4);
14593 }
14594 {
14595 PyThreadState* __tstate = wxPyBeginAllowThreads();
14596 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14597 wxPyEndAllowThreads(__tstate);
14598 if (PyErr_Occurred()) SWIG_fail;
14599 }
14600 {
14601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14602 }
14603 {
14604 if (temp2)
14605 delete arg2;
14606 }
14607 return resultobj;
14608 fail:
14609 {
14610 if (temp2)
14611 delete arg2;
14612 }
14613 return NULL;
14614 }
14615
14616
14617 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14618 PyObject *resultobj = 0;
14619 wxImage *arg1 = (wxImage *) 0 ;
14620 wxString *arg2 = 0 ;
14621 wxString *arg3 = 0 ;
14622 int arg4 = (int) -1 ;
14623 bool result;
14624 void *argp1 = 0 ;
14625 int res1 = 0 ;
14626 bool temp2 = false ;
14627 bool temp3 = false ;
14628 int val4 ;
14629 int ecode4 = 0 ;
14630 PyObject * obj0 = 0 ;
14631 PyObject * obj1 = 0 ;
14632 PyObject * obj2 = 0 ;
14633 PyObject * obj3 = 0 ;
14634 char * kwnames[] = {
14635 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14636 };
14637
14638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14640 if (!SWIG_IsOK(res1)) {
14641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14642 }
14643 arg1 = reinterpret_cast< wxImage * >(argp1);
14644 {
14645 arg2 = wxString_in_helper(obj1);
14646 if (arg2 == NULL) SWIG_fail;
14647 temp2 = true;
14648 }
14649 {
14650 arg3 = wxString_in_helper(obj2);
14651 if (arg3 == NULL) SWIG_fail;
14652 temp3 = true;
14653 }
14654 if (obj3) {
14655 ecode4 = SWIG_AsVal_int(obj3, &val4);
14656 if (!SWIG_IsOK(ecode4)) {
14657 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14658 }
14659 arg4 = static_cast< int >(val4);
14660 }
14661 {
14662 PyThreadState* __tstate = wxPyBeginAllowThreads();
14663 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14664 wxPyEndAllowThreads(__tstate);
14665 if (PyErr_Occurred()) SWIG_fail;
14666 }
14667 {
14668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14669 }
14670 {
14671 if (temp2)
14672 delete arg2;
14673 }
14674 {
14675 if (temp3)
14676 delete arg3;
14677 }
14678 return resultobj;
14679 fail:
14680 {
14681 if (temp2)
14682 delete arg2;
14683 }
14684 {
14685 if (temp3)
14686 delete arg3;
14687 }
14688 return NULL;
14689 }
14690
14691
14692 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14693 PyObject *resultobj = 0;
14694 wxImage *arg1 = (wxImage *) 0 ;
14695 wxString *arg2 = 0 ;
14696 int arg3 ;
14697 bool result;
14698 void *argp1 = 0 ;
14699 int res1 = 0 ;
14700 bool temp2 = false ;
14701 int val3 ;
14702 int ecode3 = 0 ;
14703 PyObject * obj0 = 0 ;
14704 PyObject * obj1 = 0 ;
14705 PyObject * obj2 = 0 ;
14706 char * kwnames[] = {
14707 (char *) "self",(char *) "name",(char *) "type", NULL
14708 };
14709
14710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14712 if (!SWIG_IsOK(res1)) {
14713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14714 }
14715 arg1 = reinterpret_cast< wxImage * >(argp1);
14716 {
14717 arg2 = wxString_in_helper(obj1);
14718 if (arg2 == NULL) SWIG_fail;
14719 temp2 = true;
14720 }
14721 ecode3 = SWIG_AsVal_int(obj2, &val3);
14722 if (!SWIG_IsOK(ecode3)) {
14723 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14724 }
14725 arg3 = static_cast< int >(val3);
14726 {
14727 PyThreadState* __tstate = wxPyBeginAllowThreads();
14728 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14729 wxPyEndAllowThreads(__tstate);
14730 if (PyErr_Occurred()) SWIG_fail;
14731 }
14732 {
14733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14734 }
14735 {
14736 if (temp2)
14737 delete arg2;
14738 }
14739 return resultobj;
14740 fail:
14741 {
14742 if (temp2)
14743 delete arg2;
14744 }
14745 return NULL;
14746 }
14747
14748
14749 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14750 PyObject *resultobj = 0;
14751 wxImage *arg1 = (wxImage *) 0 ;
14752 wxString *arg2 = 0 ;
14753 wxString *arg3 = 0 ;
14754 bool result;
14755 void *argp1 = 0 ;
14756 int res1 = 0 ;
14757 bool temp2 = false ;
14758 bool temp3 = false ;
14759 PyObject * obj0 = 0 ;
14760 PyObject * obj1 = 0 ;
14761 PyObject * obj2 = 0 ;
14762 char * kwnames[] = {
14763 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14764 };
14765
14766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14768 if (!SWIG_IsOK(res1)) {
14769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14770 }
14771 arg1 = reinterpret_cast< wxImage * >(argp1);
14772 {
14773 arg2 = wxString_in_helper(obj1);
14774 if (arg2 == NULL) SWIG_fail;
14775 temp2 = true;
14776 }
14777 {
14778 arg3 = wxString_in_helper(obj2);
14779 if (arg3 == NULL) SWIG_fail;
14780 temp3 = true;
14781 }
14782 {
14783 PyThreadState* __tstate = wxPyBeginAllowThreads();
14784 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14785 wxPyEndAllowThreads(__tstate);
14786 if (PyErr_Occurred()) SWIG_fail;
14787 }
14788 {
14789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14790 }
14791 {
14792 if (temp2)
14793 delete arg2;
14794 }
14795 {
14796 if (temp3)
14797 delete arg3;
14798 }
14799 return resultobj;
14800 fail:
14801 {
14802 if (temp2)
14803 delete arg2;
14804 }
14805 {
14806 if (temp3)
14807 delete arg3;
14808 }
14809 return NULL;
14810 }
14811
14812
14813 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14814 PyObject *resultobj = 0;
14815 wxInputStream *arg1 = 0 ;
14816 bool result;
14817 wxPyInputStream *temp1 ;
14818 bool created1 ;
14819 PyObject * obj0 = 0 ;
14820 char * kwnames[] = {
14821 (char *) "stream", NULL
14822 };
14823
14824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14825 {
14826 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14827 arg1 = temp1->m_wxis;
14828 created1 = false;
14829 } else {
14830 PyErr_Clear(); // clear the failure of the wxPyConvert above
14831 arg1 = wxPyCBInputStream_create(obj0, false);
14832 if (arg1 == NULL) {
14833 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14834 SWIG_fail;
14835 }
14836 created1 = true;
14837 }
14838 }
14839 {
14840 PyThreadState* __tstate = wxPyBeginAllowThreads();
14841 result = (bool)wxImage::CanRead(*arg1);
14842 wxPyEndAllowThreads(__tstate);
14843 if (PyErr_Occurred()) SWIG_fail;
14844 }
14845 {
14846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14847 }
14848 {
14849 if (created1) delete arg1;
14850 }
14851 return resultobj;
14852 fail:
14853 {
14854 if (created1) delete arg1;
14855 }
14856 return NULL;
14857 }
14858
14859
14860 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14861 PyObject *resultobj = 0;
14862 wxImage *arg1 = (wxImage *) 0 ;
14863 wxInputStream *arg2 = 0 ;
14864 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14865 int arg4 = (int) -1 ;
14866 bool result;
14867 void *argp1 = 0 ;
14868 int res1 = 0 ;
14869 wxPyInputStream *temp2 ;
14870 bool created2 ;
14871 long val3 ;
14872 int ecode3 = 0 ;
14873 int val4 ;
14874 int ecode4 = 0 ;
14875 PyObject * obj0 = 0 ;
14876 PyObject * obj1 = 0 ;
14877 PyObject * obj2 = 0 ;
14878 PyObject * obj3 = 0 ;
14879 char * kwnames[] = {
14880 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14881 };
14882
14883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14885 if (!SWIG_IsOK(res1)) {
14886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14887 }
14888 arg1 = reinterpret_cast< wxImage * >(argp1);
14889 {
14890 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14891 arg2 = temp2->m_wxis;
14892 created2 = false;
14893 } else {
14894 PyErr_Clear(); // clear the failure of the wxPyConvert above
14895 arg2 = wxPyCBInputStream_create(obj1, false);
14896 if (arg2 == NULL) {
14897 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14898 SWIG_fail;
14899 }
14900 created2 = true;
14901 }
14902 }
14903 if (obj2) {
14904 ecode3 = SWIG_AsVal_long(obj2, &val3);
14905 if (!SWIG_IsOK(ecode3)) {
14906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14907 }
14908 arg3 = static_cast< long >(val3);
14909 }
14910 if (obj3) {
14911 ecode4 = SWIG_AsVal_int(obj3, &val4);
14912 if (!SWIG_IsOK(ecode4)) {
14913 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14914 }
14915 arg4 = static_cast< int >(val4);
14916 }
14917 {
14918 PyThreadState* __tstate = wxPyBeginAllowThreads();
14919 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14920 wxPyEndAllowThreads(__tstate);
14921 if (PyErr_Occurred()) SWIG_fail;
14922 }
14923 {
14924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14925 }
14926 {
14927 if (created2) delete arg2;
14928 }
14929 return resultobj;
14930 fail:
14931 {
14932 if (created2) delete arg2;
14933 }
14934 return NULL;
14935 }
14936
14937
14938 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14939 PyObject *resultobj = 0;
14940 wxImage *arg1 = (wxImage *) 0 ;
14941 wxInputStream *arg2 = 0 ;
14942 wxString *arg3 = 0 ;
14943 int arg4 = (int) -1 ;
14944 bool result;
14945 void *argp1 = 0 ;
14946 int res1 = 0 ;
14947 wxPyInputStream *temp2 ;
14948 bool created2 ;
14949 bool temp3 = false ;
14950 int val4 ;
14951 int ecode4 = 0 ;
14952 PyObject * obj0 = 0 ;
14953 PyObject * obj1 = 0 ;
14954 PyObject * obj2 = 0 ;
14955 PyObject * obj3 = 0 ;
14956 char * kwnames[] = {
14957 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14958 };
14959
14960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14962 if (!SWIG_IsOK(res1)) {
14963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14964 }
14965 arg1 = reinterpret_cast< wxImage * >(argp1);
14966 {
14967 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14968 arg2 = temp2->m_wxis;
14969 created2 = false;
14970 } else {
14971 PyErr_Clear(); // clear the failure of the wxPyConvert above
14972 arg2 = wxPyCBInputStream_create(obj1, false);
14973 if (arg2 == NULL) {
14974 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14975 SWIG_fail;
14976 }
14977 created2 = true;
14978 }
14979 }
14980 {
14981 arg3 = wxString_in_helper(obj2);
14982 if (arg3 == NULL) SWIG_fail;
14983 temp3 = true;
14984 }
14985 if (obj3) {
14986 ecode4 = SWIG_AsVal_int(obj3, &val4);
14987 if (!SWIG_IsOK(ecode4)) {
14988 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14989 }
14990 arg4 = static_cast< int >(val4);
14991 }
14992 {
14993 PyThreadState* __tstate = wxPyBeginAllowThreads();
14994 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14995 wxPyEndAllowThreads(__tstate);
14996 if (PyErr_Occurred()) SWIG_fail;
14997 }
14998 {
14999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15000 }
15001 {
15002 if (created2) delete arg2;
15003 }
15004 {
15005 if (temp3)
15006 delete arg3;
15007 }
15008 return resultobj;
15009 fail:
15010 {
15011 if (created2) delete arg2;
15012 }
15013 {
15014 if (temp3)
15015 delete arg3;
15016 }
15017 return NULL;
15018 }
15019
15020
15021 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15022 PyObject *resultobj = 0;
15023 wxImage *arg1 = (wxImage *) 0 ;
15024 bool result;
15025 void *argp1 = 0 ;
15026 int res1 = 0 ;
15027 PyObject *swig_obj[1] ;
15028
15029 if (!args) SWIG_fail;
15030 swig_obj[0] = args;
15031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15032 if (!SWIG_IsOK(res1)) {
15033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15034 }
15035 arg1 = reinterpret_cast< wxImage * >(argp1);
15036 {
15037 PyThreadState* __tstate = wxPyBeginAllowThreads();
15038 result = (bool)(arg1)->Ok();
15039 wxPyEndAllowThreads(__tstate);
15040 if (PyErr_Occurred()) SWIG_fail;
15041 }
15042 {
15043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15044 }
15045 return resultobj;
15046 fail:
15047 return NULL;
15048 }
15049
15050
15051 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15052 PyObject *resultobj = 0;
15053 wxImage *arg1 = (wxImage *) 0 ;
15054 int result;
15055 void *argp1 = 0 ;
15056 int res1 = 0 ;
15057 PyObject *swig_obj[1] ;
15058
15059 if (!args) SWIG_fail;
15060 swig_obj[0] = args;
15061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15062 if (!SWIG_IsOK(res1)) {
15063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15064 }
15065 arg1 = reinterpret_cast< wxImage * >(argp1);
15066 {
15067 PyThreadState* __tstate = wxPyBeginAllowThreads();
15068 result = (int)(arg1)->GetWidth();
15069 wxPyEndAllowThreads(__tstate);
15070 if (PyErr_Occurred()) SWIG_fail;
15071 }
15072 resultobj = SWIG_From_int(static_cast< int >(result));
15073 return resultobj;
15074 fail:
15075 return NULL;
15076 }
15077
15078
15079 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15080 PyObject *resultobj = 0;
15081 wxImage *arg1 = (wxImage *) 0 ;
15082 int result;
15083 void *argp1 = 0 ;
15084 int res1 = 0 ;
15085 PyObject *swig_obj[1] ;
15086
15087 if (!args) SWIG_fail;
15088 swig_obj[0] = args;
15089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15090 if (!SWIG_IsOK(res1)) {
15091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15092 }
15093 arg1 = reinterpret_cast< wxImage * >(argp1);
15094 {
15095 PyThreadState* __tstate = wxPyBeginAllowThreads();
15096 result = (int)(arg1)->GetHeight();
15097 wxPyEndAllowThreads(__tstate);
15098 if (PyErr_Occurred()) SWIG_fail;
15099 }
15100 resultobj = SWIG_From_int(static_cast< int >(result));
15101 return resultobj;
15102 fail:
15103 return NULL;
15104 }
15105
15106
15107 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15108 PyObject *resultobj = 0;
15109 wxImage *arg1 = (wxImage *) 0 ;
15110 wxSize result;
15111 void *argp1 = 0 ;
15112 int res1 = 0 ;
15113 PyObject *swig_obj[1] ;
15114
15115 if (!args) SWIG_fail;
15116 swig_obj[0] = args;
15117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15118 if (!SWIG_IsOK(res1)) {
15119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15120 }
15121 arg1 = reinterpret_cast< wxImage * >(argp1);
15122 {
15123 PyThreadState* __tstate = wxPyBeginAllowThreads();
15124 result = wxImage_GetSize(arg1);
15125 wxPyEndAllowThreads(__tstate);
15126 if (PyErr_Occurred()) SWIG_fail;
15127 }
15128 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15129 return resultobj;
15130 fail:
15131 return NULL;
15132 }
15133
15134
15135 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15136 PyObject *resultobj = 0;
15137 wxImage *arg1 = (wxImage *) 0 ;
15138 wxRect *arg2 = 0 ;
15139 SwigValueWrapper<wxImage > result;
15140 void *argp1 = 0 ;
15141 int res1 = 0 ;
15142 wxRect temp2 ;
15143 PyObject * obj0 = 0 ;
15144 PyObject * obj1 = 0 ;
15145 char * kwnames[] = {
15146 (char *) "self",(char *) "rect", NULL
15147 };
15148
15149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15151 if (!SWIG_IsOK(res1)) {
15152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15153 }
15154 arg1 = reinterpret_cast< wxImage * >(argp1);
15155 {
15156 arg2 = &temp2;
15157 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15158 }
15159 {
15160 PyThreadState* __tstate = wxPyBeginAllowThreads();
15161 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15162 wxPyEndAllowThreads(__tstate);
15163 if (PyErr_Occurred()) SWIG_fail;
15164 }
15165 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15166 return resultobj;
15167 fail:
15168 return NULL;
15169 }
15170
15171
15172 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15173 PyObject *resultobj = 0;
15174 wxImage *arg1 = (wxImage *) 0 ;
15175 wxSize *arg2 = 0 ;
15176 wxPoint *arg3 = 0 ;
15177 int arg4 = (int) -1 ;
15178 int arg5 = (int) -1 ;
15179 int arg6 = (int) -1 ;
15180 SwigValueWrapper<wxImage > result;
15181 void *argp1 = 0 ;
15182 int res1 = 0 ;
15183 wxSize temp2 ;
15184 wxPoint temp3 ;
15185 int val4 ;
15186 int ecode4 = 0 ;
15187 int val5 ;
15188 int ecode5 = 0 ;
15189 int val6 ;
15190 int ecode6 = 0 ;
15191 PyObject * obj0 = 0 ;
15192 PyObject * obj1 = 0 ;
15193 PyObject * obj2 = 0 ;
15194 PyObject * obj3 = 0 ;
15195 PyObject * obj4 = 0 ;
15196 PyObject * obj5 = 0 ;
15197 char * kwnames[] = {
15198 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15199 };
15200
15201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15203 if (!SWIG_IsOK(res1)) {
15204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15205 }
15206 arg1 = reinterpret_cast< wxImage * >(argp1);
15207 {
15208 arg2 = &temp2;
15209 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15210 }
15211 {
15212 arg3 = &temp3;
15213 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15214 }
15215 if (obj3) {
15216 ecode4 = SWIG_AsVal_int(obj3, &val4);
15217 if (!SWIG_IsOK(ecode4)) {
15218 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15219 }
15220 arg4 = static_cast< int >(val4);
15221 }
15222 if (obj4) {
15223 ecode5 = SWIG_AsVal_int(obj4, &val5);
15224 if (!SWIG_IsOK(ecode5)) {
15225 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15226 }
15227 arg5 = static_cast< int >(val5);
15228 }
15229 if (obj5) {
15230 ecode6 = SWIG_AsVal_int(obj5, &val6);
15231 if (!SWIG_IsOK(ecode6)) {
15232 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15233 }
15234 arg6 = static_cast< int >(val6);
15235 }
15236 {
15237 PyThreadState* __tstate = wxPyBeginAllowThreads();
15238 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15239 wxPyEndAllowThreads(__tstate);
15240 if (PyErr_Occurred()) SWIG_fail;
15241 }
15242 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15243 return resultobj;
15244 fail:
15245 return NULL;
15246 }
15247
15248
15249 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15250 PyObject *resultobj = 0;
15251 wxImage *arg1 = (wxImage *) 0 ;
15252 SwigValueWrapper<wxImage > result;
15253 void *argp1 = 0 ;
15254 int res1 = 0 ;
15255 PyObject *swig_obj[1] ;
15256
15257 if (!args) SWIG_fail;
15258 swig_obj[0] = args;
15259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15260 if (!SWIG_IsOK(res1)) {
15261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15262 }
15263 arg1 = reinterpret_cast< wxImage * >(argp1);
15264 {
15265 PyThreadState* __tstate = wxPyBeginAllowThreads();
15266 result = (arg1)->Copy();
15267 wxPyEndAllowThreads(__tstate);
15268 if (PyErr_Occurred()) SWIG_fail;
15269 }
15270 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15271 return resultobj;
15272 fail:
15273 return NULL;
15274 }
15275
15276
15277 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15278 PyObject *resultobj = 0;
15279 wxImage *arg1 = (wxImage *) 0 ;
15280 wxImage *arg2 = 0 ;
15281 int arg3 ;
15282 int arg4 ;
15283 void *argp1 = 0 ;
15284 int res1 = 0 ;
15285 void *argp2 = 0 ;
15286 int res2 = 0 ;
15287 int val3 ;
15288 int ecode3 = 0 ;
15289 int val4 ;
15290 int ecode4 = 0 ;
15291 PyObject * obj0 = 0 ;
15292 PyObject * obj1 = 0 ;
15293 PyObject * obj2 = 0 ;
15294 PyObject * obj3 = 0 ;
15295 char * kwnames[] = {
15296 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15297 };
15298
15299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15301 if (!SWIG_IsOK(res1)) {
15302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15303 }
15304 arg1 = reinterpret_cast< wxImage * >(argp1);
15305 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15306 if (!SWIG_IsOK(res2)) {
15307 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15308 }
15309 if (!argp2) {
15310 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15311 }
15312 arg2 = reinterpret_cast< wxImage * >(argp2);
15313 ecode3 = SWIG_AsVal_int(obj2, &val3);
15314 if (!SWIG_IsOK(ecode3)) {
15315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15316 }
15317 arg3 = static_cast< int >(val3);
15318 ecode4 = SWIG_AsVal_int(obj3, &val4);
15319 if (!SWIG_IsOK(ecode4)) {
15320 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15321 }
15322 arg4 = static_cast< int >(val4);
15323 {
15324 PyThreadState* __tstate = wxPyBeginAllowThreads();
15325 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15326 wxPyEndAllowThreads(__tstate);
15327 if (PyErr_Occurred()) SWIG_fail;
15328 }
15329 resultobj = SWIG_Py_Void();
15330 return resultobj;
15331 fail:
15332 return NULL;
15333 }
15334
15335
15336 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15337 PyObject *resultobj = 0;
15338 wxImage *arg1 = (wxImage *) 0 ;
15339 PyObject *result = 0 ;
15340 void *argp1 = 0 ;
15341 int res1 = 0 ;
15342 PyObject *swig_obj[1] ;
15343
15344 if (!args) SWIG_fail;
15345 swig_obj[0] = args;
15346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15347 if (!SWIG_IsOK(res1)) {
15348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15349 }
15350 arg1 = reinterpret_cast< wxImage * >(argp1);
15351 {
15352 PyThreadState* __tstate = wxPyBeginAllowThreads();
15353 result = (PyObject *)wxImage_GetData(arg1);
15354 wxPyEndAllowThreads(__tstate);
15355 if (PyErr_Occurred()) SWIG_fail;
15356 }
15357 resultobj = result;
15358 return resultobj;
15359 fail:
15360 return NULL;
15361 }
15362
15363
15364 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15365 PyObject *resultobj = 0;
15366 wxImage *arg1 = (wxImage *) 0 ;
15367 buffer arg2 ;
15368 int arg3 ;
15369 void *argp1 = 0 ;
15370 int res1 = 0 ;
15371 PyObject * obj0 = 0 ;
15372 PyObject * obj1 = 0 ;
15373 char * kwnames[] = {
15374 (char *) "self",(char *) "data", NULL
15375 };
15376
15377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15379 if (!SWIG_IsOK(res1)) {
15380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15381 }
15382 arg1 = reinterpret_cast< wxImage * >(argp1);
15383 {
15384 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15385 }
15386 {
15387 PyThreadState* __tstate = wxPyBeginAllowThreads();
15388 wxImage_SetData(arg1,arg2,arg3);
15389 wxPyEndAllowThreads(__tstate);
15390 if (PyErr_Occurred()) SWIG_fail;
15391 }
15392 resultobj = SWIG_Py_Void();
15393 return resultobj;
15394 fail:
15395 return NULL;
15396 }
15397
15398
15399 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15400 PyObject *resultobj = 0;
15401 wxImage *arg1 = (wxImage *) 0 ;
15402 PyObject *result = 0 ;
15403 void *argp1 = 0 ;
15404 int res1 = 0 ;
15405 PyObject *swig_obj[1] ;
15406
15407 if (!args) SWIG_fail;
15408 swig_obj[0] = args;
15409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15410 if (!SWIG_IsOK(res1)) {
15411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15412 }
15413 arg1 = reinterpret_cast< wxImage * >(argp1);
15414 {
15415 PyThreadState* __tstate = wxPyBeginAllowThreads();
15416 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15417 wxPyEndAllowThreads(__tstate);
15418 if (PyErr_Occurred()) SWIG_fail;
15419 }
15420 resultobj = result;
15421 return resultobj;
15422 fail:
15423 return NULL;
15424 }
15425
15426
15427 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15428 PyObject *resultobj = 0;
15429 wxImage *arg1 = (wxImage *) 0 ;
15430 buffer arg2 ;
15431 int arg3 ;
15432 void *argp1 = 0 ;
15433 int res1 = 0 ;
15434 PyObject * obj0 = 0 ;
15435 PyObject * obj1 = 0 ;
15436 char * kwnames[] = {
15437 (char *) "self",(char *) "data", NULL
15438 };
15439
15440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15442 if (!SWIG_IsOK(res1)) {
15443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15444 }
15445 arg1 = reinterpret_cast< wxImage * >(argp1);
15446 {
15447 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15448 }
15449 {
15450 PyThreadState* __tstate = wxPyBeginAllowThreads();
15451 wxImage_SetDataBuffer(arg1,arg2,arg3);
15452 wxPyEndAllowThreads(__tstate);
15453 if (PyErr_Occurred()) SWIG_fail;
15454 }
15455 resultobj = SWIG_Py_Void();
15456 return resultobj;
15457 fail:
15458 return NULL;
15459 }
15460
15461
15462 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15463 PyObject *resultobj = 0;
15464 wxImage *arg1 = (wxImage *) 0 ;
15465 PyObject *result = 0 ;
15466 void *argp1 = 0 ;
15467 int res1 = 0 ;
15468 PyObject *swig_obj[1] ;
15469
15470 if (!args) SWIG_fail;
15471 swig_obj[0] = args;
15472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15473 if (!SWIG_IsOK(res1)) {
15474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15475 }
15476 arg1 = reinterpret_cast< wxImage * >(argp1);
15477 {
15478 PyThreadState* __tstate = wxPyBeginAllowThreads();
15479 result = (PyObject *)wxImage_GetAlphaData(arg1);
15480 wxPyEndAllowThreads(__tstate);
15481 if (PyErr_Occurred()) SWIG_fail;
15482 }
15483 resultobj = result;
15484 return resultobj;
15485 fail:
15486 return NULL;
15487 }
15488
15489
15490 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15491 PyObject *resultobj = 0;
15492 wxImage *arg1 = (wxImage *) 0 ;
15493 buffer arg2 ;
15494 int arg3 ;
15495 void *argp1 = 0 ;
15496 int res1 = 0 ;
15497 PyObject * obj0 = 0 ;
15498 PyObject * obj1 = 0 ;
15499 char * kwnames[] = {
15500 (char *) "self",(char *) "alpha", NULL
15501 };
15502
15503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15505 if (!SWIG_IsOK(res1)) {
15506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15507 }
15508 arg1 = reinterpret_cast< wxImage * >(argp1);
15509 {
15510 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15511 }
15512 {
15513 PyThreadState* __tstate = wxPyBeginAllowThreads();
15514 wxImage_SetAlphaData(arg1,arg2,arg3);
15515 wxPyEndAllowThreads(__tstate);
15516 if (PyErr_Occurred()) SWIG_fail;
15517 }
15518 resultobj = SWIG_Py_Void();
15519 return resultobj;
15520 fail:
15521 return NULL;
15522 }
15523
15524
15525 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15526 PyObject *resultobj = 0;
15527 wxImage *arg1 = (wxImage *) 0 ;
15528 PyObject *result = 0 ;
15529 void *argp1 = 0 ;
15530 int res1 = 0 ;
15531 PyObject *swig_obj[1] ;
15532
15533 if (!args) SWIG_fail;
15534 swig_obj[0] = args;
15535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15536 if (!SWIG_IsOK(res1)) {
15537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15538 }
15539 arg1 = reinterpret_cast< wxImage * >(argp1);
15540 {
15541 PyThreadState* __tstate = wxPyBeginAllowThreads();
15542 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15543 wxPyEndAllowThreads(__tstate);
15544 if (PyErr_Occurred()) SWIG_fail;
15545 }
15546 resultobj = result;
15547 return resultobj;
15548 fail:
15549 return NULL;
15550 }
15551
15552
15553 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15554 PyObject *resultobj = 0;
15555 wxImage *arg1 = (wxImage *) 0 ;
15556 buffer arg2 ;
15557 int arg3 ;
15558 void *argp1 = 0 ;
15559 int res1 = 0 ;
15560 PyObject * obj0 = 0 ;
15561 PyObject * obj1 = 0 ;
15562 char * kwnames[] = {
15563 (char *) "self",(char *) "alpha", NULL
15564 };
15565
15566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15568 if (!SWIG_IsOK(res1)) {
15569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15570 }
15571 arg1 = reinterpret_cast< wxImage * >(argp1);
15572 {
15573 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15574 }
15575 {
15576 PyThreadState* __tstate = wxPyBeginAllowThreads();
15577 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 resultobj = SWIG_Py_Void();
15582 return resultobj;
15583 fail:
15584 return NULL;
15585 }
15586
15587
15588 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15589 PyObject *resultobj = 0;
15590 wxImage *arg1 = (wxImage *) 0 ;
15591 byte arg2 ;
15592 byte arg3 ;
15593 byte arg4 ;
15594 void *argp1 = 0 ;
15595 int res1 = 0 ;
15596 unsigned char val2 ;
15597 int ecode2 = 0 ;
15598 unsigned char val3 ;
15599 int ecode3 = 0 ;
15600 unsigned char val4 ;
15601 int ecode4 = 0 ;
15602 PyObject * obj0 = 0 ;
15603 PyObject * obj1 = 0 ;
15604 PyObject * obj2 = 0 ;
15605 PyObject * obj3 = 0 ;
15606 char * kwnames[] = {
15607 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15608 };
15609
15610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15612 if (!SWIG_IsOK(res1)) {
15613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15614 }
15615 arg1 = reinterpret_cast< wxImage * >(argp1);
15616 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15617 if (!SWIG_IsOK(ecode2)) {
15618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15619 }
15620 arg2 = static_cast< byte >(val2);
15621 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15622 if (!SWIG_IsOK(ecode3)) {
15623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15624 }
15625 arg3 = static_cast< byte >(val3);
15626 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15627 if (!SWIG_IsOK(ecode4)) {
15628 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15629 }
15630 arg4 = static_cast< byte >(val4);
15631 {
15632 PyThreadState* __tstate = wxPyBeginAllowThreads();
15633 (arg1)->SetMaskColour(arg2,arg3,arg4);
15634 wxPyEndAllowThreads(__tstate);
15635 if (PyErr_Occurred()) SWIG_fail;
15636 }
15637 resultobj = SWIG_Py_Void();
15638 return resultobj;
15639 fail:
15640 return NULL;
15641 }
15642
15643
15644 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15645 PyObject *resultobj = 0;
15646 wxImage *arg1 = (wxImage *) 0 ;
15647 byte *arg2 = (byte *) 0 ;
15648 byte *arg3 = (byte *) 0 ;
15649 byte *arg4 = (byte *) 0 ;
15650 void *argp1 = 0 ;
15651 int res1 = 0 ;
15652 byte temp2 ;
15653 int res2 = SWIG_TMPOBJ ;
15654 byte temp3 ;
15655 int res3 = SWIG_TMPOBJ ;
15656 byte temp4 ;
15657 int res4 = SWIG_TMPOBJ ;
15658 PyObject *swig_obj[1] ;
15659
15660 arg2 = &temp2;
15661 arg3 = &temp3;
15662 arg4 = &temp4;
15663 if (!args) SWIG_fail;
15664 swig_obj[0] = args;
15665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15666 if (!SWIG_IsOK(res1)) {
15667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15668 }
15669 arg1 = reinterpret_cast< wxImage * >(argp1);
15670 {
15671 PyThreadState* __tstate = wxPyBeginAllowThreads();
15672 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15673 wxPyEndAllowThreads(__tstate);
15674 if (PyErr_Occurred()) SWIG_fail;
15675 }
15676 resultobj = SWIG_Py_Void();
15677 if (SWIG_IsTmpObj(res2)) {
15678 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15679 } else {
15680 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15681 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15682 }
15683 if (SWIG_IsTmpObj(res3)) {
15684 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15685 } else {
15686 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15687 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15688 }
15689 if (SWIG_IsTmpObj(res4)) {
15690 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15691 } else {
15692 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15693 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15694 }
15695 return resultobj;
15696 fail:
15697 return NULL;
15698 }
15699
15700
15701 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15702 PyObject *resultobj = 0;
15703 wxImage *arg1 = (wxImage *) 0 ;
15704 byte result;
15705 void *argp1 = 0 ;
15706 int res1 = 0 ;
15707 PyObject *swig_obj[1] ;
15708
15709 if (!args) SWIG_fail;
15710 swig_obj[0] = args;
15711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15712 if (!SWIG_IsOK(res1)) {
15713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15714 }
15715 arg1 = reinterpret_cast< wxImage * >(argp1);
15716 {
15717 PyThreadState* __tstate = wxPyBeginAllowThreads();
15718 result = (byte)(arg1)->GetMaskRed();
15719 wxPyEndAllowThreads(__tstate);
15720 if (PyErr_Occurred()) SWIG_fail;
15721 }
15722 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15723 return resultobj;
15724 fail:
15725 return NULL;
15726 }
15727
15728
15729 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15730 PyObject *resultobj = 0;
15731 wxImage *arg1 = (wxImage *) 0 ;
15732 byte result;
15733 void *argp1 = 0 ;
15734 int res1 = 0 ;
15735 PyObject *swig_obj[1] ;
15736
15737 if (!args) SWIG_fail;
15738 swig_obj[0] = args;
15739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15740 if (!SWIG_IsOK(res1)) {
15741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15742 }
15743 arg1 = reinterpret_cast< wxImage * >(argp1);
15744 {
15745 PyThreadState* __tstate = wxPyBeginAllowThreads();
15746 result = (byte)(arg1)->GetMaskGreen();
15747 wxPyEndAllowThreads(__tstate);
15748 if (PyErr_Occurred()) SWIG_fail;
15749 }
15750 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15751 return resultobj;
15752 fail:
15753 return NULL;
15754 }
15755
15756
15757 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15758 PyObject *resultobj = 0;
15759 wxImage *arg1 = (wxImage *) 0 ;
15760 byte result;
15761 void *argp1 = 0 ;
15762 int res1 = 0 ;
15763 PyObject *swig_obj[1] ;
15764
15765 if (!args) SWIG_fail;
15766 swig_obj[0] = args;
15767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15768 if (!SWIG_IsOK(res1)) {
15769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15770 }
15771 arg1 = reinterpret_cast< wxImage * >(argp1);
15772 {
15773 PyThreadState* __tstate = wxPyBeginAllowThreads();
15774 result = (byte)(arg1)->GetMaskBlue();
15775 wxPyEndAllowThreads(__tstate);
15776 if (PyErr_Occurred()) SWIG_fail;
15777 }
15778 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15779 return resultobj;
15780 fail:
15781 return NULL;
15782 }
15783
15784
15785 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15786 PyObject *resultobj = 0;
15787 wxImage *arg1 = (wxImage *) 0 ;
15788 bool arg2 = (bool) true ;
15789 void *argp1 = 0 ;
15790 int res1 = 0 ;
15791 bool val2 ;
15792 int ecode2 = 0 ;
15793 PyObject * obj0 = 0 ;
15794 PyObject * obj1 = 0 ;
15795 char * kwnames[] = {
15796 (char *) "self",(char *) "mask", NULL
15797 };
15798
15799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15801 if (!SWIG_IsOK(res1)) {
15802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15803 }
15804 arg1 = reinterpret_cast< wxImage * >(argp1);
15805 if (obj1) {
15806 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15807 if (!SWIG_IsOK(ecode2)) {
15808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15809 }
15810 arg2 = static_cast< bool >(val2);
15811 }
15812 {
15813 PyThreadState* __tstate = wxPyBeginAllowThreads();
15814 (arg1)->SetMask(arg2);
15815 wxPyEndAllowThreads(__tstate);
15816 if (PyErr_Occurred()) SWIG_fail;
15817 }
15818 resultobj = SWIG_Py_Void();
15819 return resultobj;
15820 fail:
15821 return NULL;
15822 }
15823
15824
15825 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15826 PyObject *resultobj = 0;
15827 wxImage *arg1 = (wxImage *) 0 ;
15828 bool result;
15829 void *argp1 = 0 ;
15830 int res1 = 0 ;
15831 PyObject *swig_obj[1] ;
15832
15833 if (!args) SWIG_fail;
15834 swig_obj[0] = args;
15835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15836 if (!SWIG_IsOK(res1)) {
15837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15838 }
15839 arg1 = reinterpret_cast< wxImage * >(argp1);
15840 {
15841 PyThreadState* __tstate = wxPyBeginAllowThreads();
15842 result = (bool)(arg1)->HasMask();
15843 wxPyEndAllowThreads(__tstate);
15844 if (PyErr_Occurred()) SWIG_fail;
15845 }
15846 {
15847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15848 }
15849 return resultobj;
15850 fail:
15851 return NULL;
15852 }
15853
15854
15855 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15856 PyObject *resultobj = 0;
15857 wxImage *arg1 = (wxImage *) 0 ;
15858 double arg2 ;
15859 wxPoint *arg3 = 0 ;
15860 bool arg4 = (bool) true ;
15861 wxPoint *arg5 = (wxPoint *) NULL ;
15862 SwigValueWrapper<wxImage > result;
15863 void *argp1 = 0 ;
15864 int res1 = 0 ;
15865 double val2 ;
15866 int ecode2 = 0 ;
15867 wxPoint temp3 ;
15868 bool val4 ;
15869 int ecode4 = 0 ;
15870 void *argp5 = 0 ;
15871 int res5 = 0 ;
15872 PyObject * obj0 = 0 ;
15873 PyObject * obj1 = 0 ;
15874 PyObject * obj2 = 0 ;
15875 PyObject * obj3 = 0 ;
15876 PyObject * obj4 = 0 ;
15877 char * kwnames[] = {
15878 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15879 };
15880
15881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15883 if (!SWIG_IsOK(res1)) {
15884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15885 }
15886 arg1 = reinterpret_cast< wxImage * >(argp1);
15887 ecode2 = SWIG_AsVal_double(obj1, &val2);
15888 if (!SWIG_IsOK(ecode2)) {
15889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15890 }
15891 arg2 = static_cast< double >(val2);
15892 {
15893 arg3 = &temp3;
15894 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15895 }
15896 if (obj3) {
15897 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15898 if (!SWIG_IsOK(ecode4)) {
15899 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15900 }
15901 arg4 = static_cast< bool >(val4);
15902 }
15903 if (obj4) {
15904 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15905 if (!SWIG_IsOK(res5)) {
15906 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15907 }
15908 arg5 = reinterpret_cast< wxPoint * >(argp5);
15909 }
15910 {
15911 PyThreadState* __tstate = wxPyBeginAllowThreads();
15912 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15913 wxPyEndAllowThreads(__tstate);
15914 if (PyErr_Occurred()) SWIG_fail;
15915 }
15916 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15917 return resultobj;
15918 fail:
15919 return NULL;
15920 }
15921
15922
15923 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15924 PyObject *resultobj = 0;
15925 wxImage *arg1 = (wxImage *) 0 ;
15926 bool arg2 = (bool) true ;
15927 SwigValueWrapper<wxImage > result;
15928 void *argp1 = 0 ;
15929 int res1 = 0 ;
15930 bool val2 ;
15931 int ecode2 = 0 ;
15932 PyObject * obj0 = 0 ;
15933 PyObject * obj1 = 0 ;
15934 char * kwnames[] = {
15935 (char *) "self",(char *) "clockwise", NULL
15936 };
15937
15938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15940 if (!SWIG_IsOK(res1)) {
15941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15942 }
15943 arg1 = reinterpret_cast< wxImage * >(argp1);
15944 if (obj1) {
15945 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15946 if (!SWIG_IsOK(ecode2)) {
15947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15948 }
15949 arg2 = static_cast< bool >(val2);
15950 }
15951 {
15952 PyThreadState* __tstate = wxPyBeginAllowThreads();
15953 result = (arg1)->Rotate90(arg2);
15954 wxPyEndAllowThreads(__tstate);
15955 if (PyErr_Occurred()) SWIG_fail;
15956 }
15957 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15958 return resultobj;
15959 fail:
15960 return NULL;
15961 }
15962
15963
15964 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15965 PyObject *resultobj = 0;
15966 wxImage *arg1 = (wxImage *) 0 ;
15967 bool arg2 = (bool) true ;
15968 SwigValueWrapper<wxImage > result;
15969 void *argp1 = 0 ;
15970 int res1 = 0 ;
15971 bool val2 ;
15972 int ecode2 = 0 ;
15973 PyObject * obj0 = 0 ;
15974 PyObject * obj1 = 0 ;
15975 char * kwnames[] = {
15976 (char *) "self",(char *) "horizontally", NULL
15977 };
15978
15979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15981 if (!SWIG_IsOK(res1)) {
15982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15983 }
15984 arg1 = reinterpret_cast< wxImage * >(argp1);
15985 if (obj1) {
15986 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15987 if (!SWIG_IsOK(ecode2)) {
15988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15989 }
15990 arg2 = static_cast< bool >(val2);
15991 }
15992 {
15993 PyThreadState* __tstate = wxPyBeginAllowThreads();
15994 result = (arg1)->Mirror(arg2);
15995 wxPyEndAllowThreads(__tstate);
15996 if (PyErr_Occurred()) SWIG_fail;
15997 }
15998 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15999 return resultobj;
16000 fail:
16001 return NULL;
16002 }
16003
16004
16005 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16006 PyObject *resultobj = 0;
16007 wxImage *arg1 = (wxImage *) 0 ;
16008 byte arg2 ;
16009 byte arg3 ;
16010 byte arg4 ;
16011 byte arg5 ;
16012 byte arg6 ;
16013 byte arg7 ;
16014 void *argp1 = 0 ;
16015 int res1 = 0 ;
16016 unsigned char val2 ;
16017 int ecode2 = 0 ;
16018 unsigned char val3 ;
16019 int ecode3 = 0 ;
16020 unsigned char val4 ;
16021 int ecode4 = 0 ;
16022 unsigned char val5 ;
16023 int ecode5 = 0 ;
16024 unsigned char val6 ;
16025 int ecode6 = 0 ;
16026 unsigned char val7 ;
16027 int ecode7 = 0 ;
16028 PyObject * obj0 = 0 ;
16029 PyObject * obj1 = 0 ;
16030 PyObject * obj2 = 0 ;
16031 PyObject * obj3 = 0 ;
16032 PyObject * obj4 = 0 ;
16033 PyObject * obj5 = 0 ;
16034 PyObject * obj6 = 0 ;
16035 char * kwnames[] = {
16036 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16037 };
16038
16039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16041 if (!SWIG_IsOK(res1)) {
16042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16043 }
16044 arg1 = reinterpret_cast< wxImage * >(argp1);
16045 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16046 if (!SWIG_IsOK(ecode2)) {
16047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16048 }
16049 arg2 = static_cast< byte >(val2);
16050 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16051 if (!SWIG_IsOK(ecode3)) {
16052 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16053 }
16054 arg3 = static_cast< byte >(val3);
16055 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16056 if (!SWIG_IsOK(ecode4)) {
16057 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16058 }
16059 arg4 = static_cast< byte >(val4);
16060 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16061 if (!SWIG_IsOK(ecode5)) {
16062 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16063 }
16064 arg5 = static_cast< byte >(val5);
16065 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16066 if (!SWIG_IsOK(ecode6)) {
16067 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16068 }
16069 arg6 = static_cast< byte >(val6);
16070 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16071 if (!SWIG_IsOK(ecode7)) {
16072 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16073 }
16074 arg7 = static_cast< byte >(val7);
16075 {
16076 PyThreadState* __tstate = wxPyBeginAllowThreads();
16077 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16078 wxPyEndAllowThreads(__tstate);
16079 if (PyErr_Occurred()) SWIG_fail;
16080 }
16081 resultobj = SWIG_Py_Void();
16082 return resultobj;
16083 fail:
16084 return NULL;
16085 }
16086
16087
16088 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16089 PyObject *resultobj = 0;
16090 wxImage *arg1 = (wxImage *) 0 ;
16091 double arg2 = (double) 0.299 ;
16092 double arg3 = (double) 0.587 ;
16093 double arg4 = (double) 0.114 ;
16094 SwigValueWrapper<wxImage > result;
16095 void *argp1 = 0 ;
16096 int res1 = 0 ;
16097 double val2 ;
16098 int ecode2 = 0 ;
16099 double val3 ;
16100 int ecode3 = 0 ;
16101 double val4 ;
16102 int ecode4 = 0 ;
16103 PyObject * obj0 = 0 ;
16104 PyObject * obj1 = 0 ;
16105 PyObject * obj2 = 0 ;
16106 PyObject * obj3 = 0 ;
16107 char * kwnames[] = {
16108 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16109 };
16110
16111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16113 if (!SWIG_IsOK(res1)) {
16114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16115 }
16116 arg1 = reinterpret_cast< wxImage * >(argp1);
16117 if (obj1) {
16118 ecode2 = SWIG_AsVal_double(obj1, &val2);
16119 if (!SWIG_IsOK(ecode2)) {
16120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16121 }
16122 arg2 = static_cast< double >(val2);
16123 }
16124 if (obj2) {
16125 ecode3 = SWIG_AsVal_double(obj2, &val3);
16126 if (!SWIG_IsOK(ecode3)) {
16127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16128 }
16129 arg3 = static_cast< double >(val3);
16130 }
16131 if (obj3) {
16132 ecode4 = SWIG_AsVal_double(obj3, &val4);
16133 if (!SWIG_IsOK(ecode4)) {
16134 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16135 }
16136 arg4 = static_cast< double >(val4);
16137 }
16138 {
16139 PyThreadState* __tstate = wxPyBeginAllowThreads();
16140 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16141 wxPyEndAllowThreads(__tstate);
16142 if (PyErr_Occurred()) SWIG_fail;
16143 }
16144 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16145 return resultobj;
16146 fail:
16147 return NULL;
16148 }
16149
16150
16151 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16152 PyObject *resultobj = 0;
16153 wxImage *arg1 = (wxImage *) 0 ;
16154 byte arg2 ;
16155 byte arg3 ;
16156 byte arg4 ;
16157 SwigValueWrapper<wxImage > result;
16158 void *argp1 = 0 ;
16159 int res1 = 0 ;
16160 unsigned char val2 ;
16161 int ecode2 = 0 ;
16162 unsigned char val3 ;
16163 int ecode3 = 0 ;
16164 unsigned char val4 ;
16165 int ecode4 = 0 ;
16166 PyObject * obj0 = 0 ;
16167 PyObject * obj1 = 0 ;
16168 PyObject * obj2 = 0 ;
16169 PyObject * obj3 = 0 ;
16170 char * kwnames[] = {
16171 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16172 };
16173
16174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16176 if (!SWIG_IsOK(res1)) {
16177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16178 }
16179 arg1 = reinterpret_cast< wxImage * >(argp1);
16180 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16181 if (!SWIG_IsOK(ecode2)) {
16182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16183 }
16184 arg2 = static_cast< byte >(val2);
16185 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16186 if (!SWIG_IsOK(ecode3)) {
16187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16188 }
16189 arg3 = static_cast< byte >(val3);
16190 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16191 if (!SWIG_IsOK(ecode4)) {
16192 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16193 }
16194 arg4 = static_cast< byte >(val4);
16195 {
16196 PyThreadState* __tstate = wxPyBeginAllowThreads();
16197 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16198 wxPyEndAllowThreads(__tstate);
16199 if (PyErr_Occurred()) SWIG_fail;
16200 }
16201 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16202 return resultobj;
16203 fail:
16204 return NULL;
16205 }
16206
16207
16208 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16209 PyObject *resultobj = 0;
16210 wxImage *arg1 = (wxImage *) 0 ;
16211 wxString *arg2 = 0 ;
16212 wxString *arg3 = 0 ;
16213 void *argp1 = 0 ;
16214 int res1 = 0 ;
16215 bool temp2 = false ;
16216 bool temp3 = false ;
16217 PyObject * obj0 = 0 ;
16218 PyObject * obj1 = 0 ;
16219 PyObject * obj2 = 0 ;
16220 char * kwnames[] = {
16221 (char *) "self",(char *) "name",(char *) "value", NULL
16222 };
16223
16224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16226 if (!SWIG_IsOK(res1)) {
16227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16228 }
16229 arg1 = reinterpret_cast< wxImage * >(argp1);
16230 {
16231 arg2 = wxString_in_helper(obj1);
16232 if (arg2 == NULL) SWIG_fail;
16233 temp2 = true;
16234 }
16235 {
16236 arg3 = wxString_in_helper(obj2);
16237 if (arg3 == NULL) SWIG_fail;
16238 temp3 = true;
16239 }
16240 {
16241 PyThreadState* __tstate = wxPyBeginAllowThreads();
16242 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16243 wxPyEndAllowThreads(__tstate);
16244 if (PyErr_Occurred()) SWIG_fail;
16245 }
16246 resultobj = SWIG_Py_Void();
16247 {
16248 if (temp2)
16249 delete arg2;
16250 }
16251 {
16252 if (temp3)
16253 delete arg3;
16254 }
16255 return resultobj;
16256 fail:
16257 {
16258 if (temp2)
16259 delete arg2;
16260 }
16261 {
16262 if (temp3)
16263 delete arg3;
16264 }
16265 return NULL;
16266 }
16267
16268
16269 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16270 PyObject *resultobj = 0;
16271 wxImage *arg1 = (wxImage *) 0 ;
16272 wxString *arg2 = 0 ;
16273 int arg3 ;
16274 void *argp1 = 0 ;
16275 int res1 = 0 ;
16276 bool temp2 = false ;
16277 int val3 ;
16278 int ecode3 = 0 ;
16279 PyObject * obj0 = 0 ;
16280 PyObject * obj1 = 0 ;
16281 PyObject * obj2 = 0 ;
16282 char * kwnames[] = {
16283 (char *) "self",(char *) "name",(char *) "value", NULL
16284 };
16285
16286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16288 if (!SWIG_IsOK(res1)) {
16289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16290 }
16291 arg1 = reinterpret_cast< wxImage * >(argp1);
16292 {
16293 arg2 = wxString_in_helper(obj1);
16294 if (arg2 == NULL) SWIG_fail;
16295 temp2 = true;
16296 }
16297 ecode3 = SWIG_AsVal_int(obj2, &val3);
16298 if (!SWIG_IsOK(ecode3)) {
16299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16300 }
16301 arg3 = static_cast< int >(val3);
16302 {
16303 PyThreadState* __tstate = wxPyBeginAllowThreads();
16304 (arg1)->SetOption((wxString const &)*arg2,arg3);
16305 wxPyEndAllowThreads(__tstate);
16306 if (PyErr_Occurred()) SWIG_fail;
16307 }
16308 resultobj = SWIG_Py_Void();
16309 {
16310 if (temp2)
16311 delete arg2;
16312 }
16313 return resultobj;
16314 fail:
16315 {
16316 if (temp2)
16317 delete arg2;
16318 }
16319 return NULL;
16320 }
16321
16322
16323 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16324 PyObject *resultobj = 0;
16325 wxImage *arg1 = (wxImage *) 0 ;
16326 wxString *arg2 = 0 ;
16327 wxString result;
16328 void *argp1 = 0 ;
16329 int res1 = 0 ;
16330 bool temp2 = false ;
16331 PyObject * obj0 = 0 ;
16332 PyObject * obj1 = 0 ;
16333 char * kwnames[] = {
16334 (char *) "self",(char *) "name", NULL
16335 };
16336
16337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16339 if (!SWIG_IsOK(res1)) {
16340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16341 }
16342 arg1 = reinterpret_cast< wxImage * >(argp1);
16343 {
16344 arg2 = wxString_in_helper(obj1);
16345 if (arg2 == NULL) SWIG_fail;
16346 temp2 = true;
16347 }
16348 {
16349 PyThreadState* __tstate = wxPyBeginAllowThreads();
16350 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16351 wxPyEndAllowThreads(__tstate);
16352 if (PyErr_Occurred()) SWIG_fail;
16353 }
16354 {
16355 #if wxUSE_UNICODE
16356 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16357 #else
16358 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16359 #endif
16360 }
16361 {
16362 if (temp2)
16363 delete arg2;
16364 }
16365 return resultobj;
16366 fail:
16367 {
16368 if (temp2)
16369 delete arg2;
16370 }
16371 return NULL;
16372 }
16373
16374
16375 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16376 PyObject *resultobj = 0;
16377 wxImage *arg1 = (wxImage *) 0 ;
16378 wxString *arg2 = 0 ;
16379 int result;
16380 void *argp1 = 0 ;
16381 int res1 = 0 ;
16382 bool temp2 = false ;
16383 PyObject * obj0 = 0 ;
16384 PyObject * obj1 = 0 ;
16385 char * kwnames[] = {
16386 (char *) "self",(char *) "name", NULL
16387 };
16388
16389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16391 if (!SWIG_IsOK(res1)) {
16392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16393 }
16394 arg1 = reinterpret_cast< wxImage * >(argp1);
16395 {
16396 arg2 = wxString_in_helper(obj1);
16397 if (arg2 == NULL) SWIG_fail;
16398 temp2 = true;
16399 }
16400 {
16401 PyThreadState* __tstate = wxPyBeginAllowThreads();
16402 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16403 wxPyEndAllowThreads(__tstate);
16404 if (PyErr_Occurred()) SWIG_fail;
16405 }
16406 resultobj = SWIG_From_int(static_cast< int >(result));
16407 {
16408 if (temp2)
16409 delete arg2;
16410 }
16411 return resultobj;
16412 fail:
16413 {
16414 if (temp2)
16415 delete arg2;
16416 }
16417 return NULL;
16418 }
16419
16420
16421 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16422 PyObject *resultobj = 0;
16423 wxImage *arg1 = (wxImage *) 0 ;
16424 wxString *arg2 = 0 ;
16425 bool result;
16426 void *argp1 = 0 ;
16427 int res1 = 0 ;
16428 bool temp2 = false ;
16429 PyObject * obj0 = 0 ;
16430 PyObject * obj1 = 0 ;
16431 char * kwnames[] = {
16432 (char *) "self",(char *) "name", NULL
16433 };
16434
16435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16437 if (!SWIG_IsOK(res1)) {
16438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16439 }
16440 arg1 = reinterpret_cast< wxImage * >(argp1);
16441 {
16442 arg2 = wxString_in_helper(obj1);
16443 if (arg2 == NULL) SWIG_fail;
16444 temp2 = true;
16445 }
16446 {
16447 PyThreadState* __tstate = wxPyBeginAllowThreads();
16448 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16449 wxPyEndAllowThreads(__tstate);
16450 if (PyErr_Occurred()) SWIG_fail;
16451 }
16452 {
16453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16454 }
16455 {
16456 if (temp2)
16457 delete arg2;
16458 }
16459 return resultobj;
16460 fail:
16461 {
16462 if (temp2)
16463 delete arg2;
16464 }
16465 return NULL;
16466 }
16467
16468
16469 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16470 PyObject *resultobj = 0;
16471 wxImage *arg1 = (wxImage *) 0 ;
16472 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16473 unsigned long result;
16474 void *argp1 = 0 ;
16475 int res1 = 0 ;
16476 unsigned long val2 ;
16477 int ecode2 = 0 ;
16478 PyObject * obj0 = 0 ;
16479 PyObject * obj1 = 0 ;
16480 char * kwnames[] = {
16481 (char *) "self",(char *) "stopafter", NULL
16482 };
16483
16484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16486 if (!SWIG_IsOK(res1)) {
16487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16488 }
16489 arg1 = reinterpret_cast< wxImage * >(argp1);
16490 if (obj1) {
16491 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16492 if (!SWIG_IsOK(ecode2)) {
16493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16494 }
16495 arg2 = static_cast< unsigned long >(val2);
16496 }
16497 {
16498 PyThreadState* __tstate = wxPyBeginAllowThreads();
16499 result = (unsigned long)(arg1)->CountColours(arg2);
16500 wxPyEndAllowThreads(__tstate);
16501 if (PyErr_Occurred()) SWIG_fail;
16502 }
16503 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16504 return resultobj;
16505 fail:
16506 return NULL;
16507 }
16508
16509
16510 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16511 PyObject *resultobj = 0;
16512 wxImage *arg1 = (wxImage *) 0 ;
16513 wxImageHistogram *arg2 = 0 ;
16514 unsigned long result;
16515 void *argp1 = 0 ;
16516 int res1 = 0 ;
16517 void *argp2 = 0 ;
16518 int res2 = 0 ;
16519 PyObject * obj0 = 0 ;
16520 PyObject * obj1 = 0 ;
16521 char * kwnames[] = {
16522 (char *) "self",(char *) "h", NULL
16523 };
16524
16525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16527 if (!SWIG_IsOK(res1)) {
16528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16529 }
16530 arg1 = reinterpret_cast< wxImage * >(argp1);
16531 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16532 if (!SWIG_IsOK(res2)) {
16533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16534 }
16535 if (!argp2) {
16536 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16537 }
16538 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16539 {
16540 PyThreadState* __tstate = wxPyBeginAllowThreads();
16541 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16542 wxPyEndAllowThreads(__tstate);
16543 if (PyErr_Occurred()) SWIG_fail;
16544 }
16545 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16546 return resultobj;
16547 fail:
16548 return NULL;
16549 }
16550
16551
16552 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16553 PyObject *resultobj = 0;
16554 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16555 void *argp1 = 0 ;
16556 int res1 = 0 ;
16557 PyObject * obj0 = 0 ;
16558 char * kwnames[] = {
16559 (char *) "handler", NULL
16560 };
16561
16562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16564 if (!SWIG_IsOK(res1)) {
16565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16566 }
16567 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16568 {
16569 PyThreadState* __tstate = wxPyBeginAllowThreads();
16570 wxImage::AddHandler(arg1);
16571 wxPyEndAllowThreads(__tstate);
16572 if (PyErr_Occurred()) SWIG_fail;
16573 }
16574 resultobj = SWIG_Py_Void();
16575 return resultobj;
16576 fail:
16577 return NULL;
16578 }
16579
16580
16581 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16582 PyObject *resultobj = 0;
16583 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16584 void *argp1 = 0 ;
16585 int res1 = 0 ;
16586 PyObject * obj0 = 0 ;
16587 char * kwnames[] = {
16588 (char *) "handler", NULL
16589 };
16590
16591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16593 if (!SWIG_IsOK(res1)) {
16594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16595 }
16596 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16597 {
16598 PyThreadState* __tstate = wxPyBeginAllowThreads();
16599 wxImage::InsertHandler(arg1);
16600 wxPyEndAllowThreads(__tstate);
16601 if (PyErr_Occurred()) SWIG_fail;
16602 }
16603 resultobj = SWIG_Py_Void();
16604 return resultobj;
16605 fail:
16606 return NULL;
16607 }
16608
16609
16610 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16611 PyObject *resultobj = 0;
16612 wxString *arg1 = 0 ;
16613 bool result;
16614 bool temp1 = false ;
16615 PyObject * obj0 = 0 ;
16616 char * kwnames[] = {
16617 (char *) "name", NULL
16618 };
16619
16620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16621 {
16622 arg1 = wxString_in_helper(obj0);
16623 if (arg1 == NULL) SWIG_fail;
16624 temp1 = true;
16625 }
16626 {
16627 PyThreadState* __tstate = wxPyBeginAllowThreads();
16628 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16629 wxPyEndAllowThreads(__tstate);
16630 if (PyErr_Occurred()) SWIG_fail;
16631 }
16632 {
16633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16634 }
16635 {
16636 if (temp1)
16637 delete arg1;
16638 }
16639 return resultobj;
16640 fail:
16641 {
16642 if (temp1)
16643 delete arg1;
16644 }
16645 return NULL;
16646 }
16647
16648
16649 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16650 PyObject *resultobj = 0;
16651 PyObject *result = 0 ;
16652
16653 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16654 {
16655 PyThreadState* __tstate = wxPyBeginAllowThreads();
16656 result = (PyObject *)wxImage_GetHandlers();
16657 wxPyEndAllowThreads(__tstate);
16658 if (PyErr_Occurred()) SWIG_fail;
16659 }
16660 resultobj = result;
16661 return resultobj;
16662 fail:
16663 return NULL;
16664 }
16665
16666
16667 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16668 PyObject *resultobj = 0;
16669 wxString result;
16670
16671 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16672 {
16673 PyThreadState* __tstate = wxPyBeginAllowThreads();
16674 result = wxImage::GetImageExtWildcard();
16675 wxPyEndAllowThreads(__tstate);
16676 if (PyErr_Occurred()) SWIG_fail;
16677 }
16678 {
16679 #if wxUSE_UNICODE
16680 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16681 #else
16682 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16683 #endif
16684 }
16685 return resultobj;
16686 fail:
16687 return NULL;
16688 }
16689
16690
16691 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16692 PyObject *resultobj = 0;
16693 wxImage *arg1 = (wxImage *) 0 ;
16694 int arg2 = (int) -1 ;
16695 wxBitmap result;
16696 void *argp1 = 0 ;
16697 int res1 = 0 ;
16698 int val2 ;
16699 int ecode2 = 0 ;
16700 PyObject * obj0 = 0 ;
16701 PyObject * obj1 = 0 ;
16702 char * kwnames[] = {
16703 (char *) "self",(char *) "depth", NULL
16704 };
16705
16706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16708 if (!SWIG_IsOK(res1)) {
16709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16710 }
16711 arg1 = reinterpret_cast< wxImage * >(argp1);
16712 if (obj1) {
16713 ecode2 = SWIG_AsVal_int(obj1, &val2);
16714 if (!SWIG_IsOK(ecode2)) {
16715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16716 }
16717 arg2 = static_cast< int >(val2);
16718 }
16719 {
16720 if (!wxPyCheckForApp()) SWIG_fail;
16721 PyThreadState* __tstate = wxPyBeginAllowThreads();
16722 result = wxImage_ConvertToBitmap(arg1,arg2);
16723 wxPyEndAllowThreads(__tstate);
16724 if (PyErr_Occurred()) SWIG_fail;
16725 }
16726 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16727 return resultobj;
16728 fail:
16729 return NULL;
16730 }
16731
16732
16733 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16734 PyObject *resultobj = 0;
16735 wxImage *arg1 = (wxImage *) 0 ;
16736 byte arg2 ;
16737 byte arg3 ;
16738 byte arg4 ;
16739 wxBitmap result;
16740 void *argp1 = 0 ;
16741 int res1 = 0 ;
16742 unsigned char val2 ;
16743 int ecode2 = 0 ;
16744 unsigned char val3 ;
16745 int ecode3 = 0 ;
16746 unsigned char val4 ;
16747 int ecode4 = 0 ;
16748 PyObject * obj0 = 0 ;
16749 PyObject * obj1 = 0 ;
16750 PyObject * obj2 = 0 ;
16751 PyObject * obj3 = 0 ;
16752 char * kwnames[] = {
16753 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16754 };
16755
16756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16758 if (!SWIG_IsOK(res1)) {
16759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16760 }
16761 arg1 = reinterpret_cast< wxImage * >(argp1);
16762 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16763 if (!SWIG_IsOK(ecode2)) {
16764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16765 }
16766 arg2 = static_cast< byte >(val2);
16767 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16768 if (!SWIG_IsOK(ecode3)) {
16769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16770 }
16771 arg3 = static_cast< byte >(val3);
16772 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16773 if (!SWIG_IsOK(ecode4)) {
16774 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16775 }
16776 arg4 = static_cast< byte >(val4);
16777 {
16778 if (!wxPyCheckForApp()) SWIG_fail;
16779 PyThreadState* __tstate = wxPyBeginAllowThreads();
16780 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16781 wxPyEndAllowThreads(__tstate);
16782 if (PyErr_Occurred()) SWIG_fail;
16783 }
16784 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16785 return resultobj;
16786 fail:
16787 return NULL;
16788 }
16789
16790
16791 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16792 PyObject *resultobj = 0;
16793 wxImage *arg1 = (wxImage *) 0 ;
16794 double arg2 ;
16795 void *argp1 = 0 ;
16796 int res1 = 0 ;
16797 double val2 ;
16798 int ecode2 = 0 ;
16799 PyObject * obj0 = 0 ;
16800 PyObject * obj1 = 0 ;
16801 char * kwnames[] = {
16802 (char *) "self",(char *) "angle", NULL
16803 };
16804
16805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16807 if (!SWIG_IsOK(res1)) {
16808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16809 }
16810 arg1 = reinterpret_cast< wxImage * >(argp1);
16811 ecode2 = SWIG_AsVal_double(obj1, &val2);
16812 if (!SWIG_IsOK(ecode2)) {
16813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16814 }
16815 arg2 = static_cast< double >(val2);
16816 {
16817 PyThreadState* __tstate = wxPyBeginAllowThreads();
16818 (arg1)->RotateHue(arg2);
16819 wxPyEndAllowThreads(__tstate);
16820 if (PyErr_Occurred()) SWIG_fail;
16821 }
16822 resultobj = SWIG_Py_Void();
16823 return resultobj;
16824 fail:
16825 return NULL;
16826 }
16827
16828
16829 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16830 PyObject *resultobj = 0;
16831 wxImage_RGBValue arg1 ;
16832 wxImage_HSVValue result;
16833 void *argp1 ;
16834 int res1 = 0 ;
16835 PyObject * obj0 = 0 ;
16836 char * kwnames[] = {
16837 (char *) "rgb", NULL
16838 };
16839
16840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16841 {
16842 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16843 if (!SWIG_IsOK(res1)) {
16844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16845 }
16846 if (!argp1) {
16847 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16848 } else {
16849 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16850 arg1 = *temp;
16851 if (SWIG_IsNewObj(res1)) delete temp;
16852 }
16853 }
16854 {
16855 PyThreadState* __tstate = wxPyBeginAllowThreads();
16856 result = wxImage::RGBtoHSV(arg1);
16857 wxPyEndAllowThreads(__tstate);
16858 if (PyErr_Occurred()) SWIG_fail;
16859 }
16860 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16861 return resultobj;
16862 fail:
16863 return NULL;
16864 }
16865
16866
16867 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16868 PyObject *resultobj = 0;
16869 wxImage_HSVValue arg1 ;
16870 wxImage_RGBValue result;
16871 void *argp1 ;
16872 int res1 = 0 ;
16873 PyObject * obj0 = 0 ;
16874 char * kwnames[] = {
16875 (char *) "hsv", NULL
16876 };
16877
16878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16879 {
16880 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16881 if (!SWIG_IsOK(res1)) {
16882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16883 }
16884 if (!argp1) {
16885 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16886 } else {
16887 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16888 arg1 = *temp;
16889 if (SWIG_IsNewObj(res1)) delete temp;
16890 }
16891 }
16892 {
16893 PyThreadState* __tstate = wxPyBeginAllowThreads();
16894 result = wxImage::HSVtoRGB(arg1);
16895 wxPyEndAllowThreads(__tstate);
16896 if (PyErr_Occurred()) SWIG_fail;
16897 }
16898 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16899 return resultobj;
16900 fail:
16901 return NULL;
16902 }
16903
16904
16905 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16906 PyObject *obj;
16907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16908 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16909 return SWIG_Py_Void();
16910 }
16911
16912 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16913 return SWIG_Python_InitShadowInstance(args);
16914 }
16915
16916 SWIGINTERN int NullImage_set(PyObject *) {
16917 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16918 return 1;
16919 }
16920
16921
16922 SWIGINTERN PyObject *NullImage_get(void) {
16923 PyObject *pyobj = 0;
16924
16925 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16926 return pyobj;
16927 }
16928
16929
16930 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16931 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16932 return 1;
16933 }
16934
16935
16936 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16937 PyObject *pyobj = 0;
16938
16939 {
16940 #if wxUSE_UNICODE
16941 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16942 #else
16943 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16944 #endif
16945 }
16946 return pyobj;
16947 }
16948
16949
16950 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16951 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16952 return 1;
16953 }
16954
16955
16956 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16957 PyObject *pyobj = 0;
16958
16959 {
16960 #if wxUSE_UNICODE
16961 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16962 #else
16963 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16964 #endif
16965 }
16966 return pyobj;
16967 }
16968
16969
16970 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16971 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16972 return 1;
16973 }
16974
16975
16976 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16977 PyObject *pyobj = 0;
16978
16979 {
16980 #if wxUSE_UNICODE
16981 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16982 #else
16983 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16984 #endif
16985 }
16986 return pyobj;
16987 }
16988
16989
16990 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16991 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16992 return 1;
16993 }
16994
16995
16996 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16997 PyObject *pyobj = 0;
16998
16999 {
17000 #if wxUSE_UNICODE
17001 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17002 #else
17003 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17004 #endif
17005 }
17006 return pyobj;
17007 }
17008
17009
17010 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17011 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17012 return 1;
17013 }
17014
17015
17016 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17017 PyObject *pyobj = 0;
17018
17019 {
17020 #if wxUSE_UNICODE
17021 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17022 #else
17023 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17024 #endif
17025 }
17026 return pyobj;
17027 }
17028
17029
17030 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17031 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17032 return 1;
17033 }
17034
17035
17036 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17037 PyObject *pyobj = 0;
17038
17039 {
17040 #if wxUSE_UNICODE
17041 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17042 #else
17043 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17044 #endif
17045 }
17046 return pyobj;
17047 }
17048
17049
17050 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17051 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17052 return 1;
17053 }
17054
17055
17056 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17057 PyObject *pyobj = 0;
17058
17059 {
17060 #if wxUSE_UNICODE
17061 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17062 #else
17063 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17064 #endif
17065 }
17066 return pyobj;
17067 }
17068
17069
17070 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17071 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17072 return 1;
17073 }
17074
17075
17076 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17077 PyObject *pyobj = 0;
17078
17079 {
17080 #if wxUSE_UNICODE
17081 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17082 #else
17083 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17084 #endif
17085 }
17086 return pyobj;
17087 }
17088
17089
17090 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17091 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17092 return 1;
17093 }
17094
17095
17096 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17097 PyObject *pyobj = 0;
17098
17099 {
17100 #if wxUSE_UNICODE
17101 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17102 #else
17103 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17104 #endif
17105 }
17106 return pyobj;
17107 }
17108
17109
17110 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17111 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17112 return 1;
17113 }
17114
17115
17116 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17117 PyObject *pyobj = 0;
17118
17119 {
17120 #if wxUSE_UNICODE
17121 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17122 #else
17123 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17124 #endif
17125 }
17126 return pyobj;
17127 }
17128
17129
17130 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17131 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17132 return 1;
17133 }
17134
17135
17136 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17137 PyObject *pyobj = 0;
17138
17139 {
17140 #if wxUSE_UNICODE
17141 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17142 #else
17143 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17144 #endif
17145 }
17146 return pyobj;
17147 }
17148
17149
17150 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17151 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17152 return 1;
17153 }
17154
17155
17156 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17157 PyObject *pyobj = 0;
17158
17159 {
17160 #if wxUSE_UNICODE
17161 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17162 #else
17163 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17164 #endif
17165 }
17166 return pyobj;
17167 }
17168
17169
17170 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17171 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17172 return 1;
17173 }
17174
17175
17176 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17177 PyObject *pyobj = 0;
17178
17179 {
17180 #if wxUSE_UNICODE
17181 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17182 #else
17183 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17184 #endif
17185 }
17186 return pyobj;
17187 }
17188
17189
17190 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17191 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17192 return 1;
17193 }
17194
17195
17196 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17197 PyObject *pyobj = 0;
17198
17199 {
17200 #if wxUSE_UNICODE
17201 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17202 #else
17203 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17204 #endif
17205 }
17206 return pyobj;
17207 }
17208
17209
17210 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17211 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17212 return 1;
17213 }
17214
17215
17216 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17217 PyObject *pyobj = 0;
17218
17219 {
17220 #if wxUSE_UNICODE
17221 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17222 #else
17223 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17224 #endif
17225 }
17226 return pyobj;
17227 }
17228
17229
17230 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17231 PyObject *resultobj = 0;
17232 wxBMPHandler *result = 0 ;
17233
17234 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17235 {
17236 PyThreadState* __tstate = wxPyBeginAllowThreads();
17237 result = (wxBMPHandler *)new wxBMPHandler();
17238 wxPyEndAllowThreads(__tstate);
17239 if (PyErr_Occurred()) SWIG_fail;
17240 }
17241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17242 return resultobj;
17243 fail:
17244 return NULL;
17245 }
17246
17247
17248 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17249 PyObject *obj;
17250 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17251 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17252 return SWIG_Py_Void();
17253 }
17254
17255 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17256 return SWIG_Python_InitShadowInstance(args);
17257 }
17258
17259 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17260 PyObject *resultobj = 0;
17261 wxICOHandler *result = 0 ;
17262
17263 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17264 {
17265 PyThreadState* __tstate = wxPyBeginAllowThreads();
17266 result = (wxICOHandler *)new wxICOHandler();
17267 wxPyEndAllowThreads(__tstate);
17268 if (PyErr_Occurred()) SWIG_fail;
17269 }
17270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17271 return resultobj;
17272 fail:
17273 return NULL;
17274 }
17275
17276
17277 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17278 PyObject *obj;
17279 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17280 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17281 return SWIG_Py_Void();
17282 }
17283
17284 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17285 return SWIG_Python_InitShadowInstance(args);
17286 }
17287
17288 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17289 PyObject *resultobj = 0;
17290 wxCURHandler *result = 0 ;
17291
17292 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17293 {
17294 PyThreadState* __tstate = wxPyBeginAllowThreads();
17295 result = (wxCURHandler *)new wxCURHandler();
17296 wxPyEndAllowThreads(__tstate);
17297 if (PyErr_Occurred()) SWIG_fail;
17298 }
17299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17300 return resultobj;
17301 fail:
17302 return NULL;
17303 }
17304
17305
17306 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17307 PyObject *obj;
17308 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17309 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17310 return SWIG_Py_Void();
17311 }
17312
17313 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17314 return SWIG_Python_InitShadowInstance(args);
17315 }
17316
17317 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17318 PyObject *resultobj = 0;
17319 wxANIHandler *result = 0 ;
17320
17321 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17322 {
17323 PyThreadState* __tstate = wxPyBeginAllowThreads();
17324 result = (wxANIHandler *)new wxANIHandler();
17325 wxPyEndAllowThreads(__tstate);
17326 if (PyErr_Occurred()) SWIG_fail;
17327 }
17328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17329 return resultobj;
17330 fail:
17331 return NULL;
17332 }
17333
17334
17335 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17336 PyObject *obj;
17337 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17338 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17339 return SWIG_Py_Void();
17340 }
17341
17342 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17343 return SWIG_Python_InitShadowInstance(args);
17344 }
17345
17346 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17347 PyObject *resultobj = 0;
17348 wxPNGHandler *result = 0 ;
17349
17350 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17351 {
17352 PyThreadState* __tstate = wxPyBeginAllowThreads();
17353 result = (wxPNGHandler *)new wxPNGHandler();
17354 wxPyEndAllowThreads(__tstate);
17355 if (PyErr_Occurred()) SWIG_fail;
17356 }
17357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17358 return resultobj;
17359 fail:
17360 return NULL;
17361 }
17362
17363
17364 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17365 PyObject *obj;
17366 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17367 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17368 return SWIG_Py_Void();
17369 }
17370
17371 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17372 return SWIG_Python_InitShadowInstance(args);
17373 }
17374
17375 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17376 PyObject *resultobj = 0;
17377 wxGIFHandler *result = 0 ;
17378
17379 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17380 {
17381 PyThreadState* __tstate = wxPyBeginAllowThreads();
17382 result = (wxGIFHandler *)new wxGIFHandler();
17383 wxPyEndAllowThreads(__tstate);
17384 if (PyErr_Occurred()) SWIG_fail;
17385 }
17386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17387 return resultobj;
17388 fail:
17389 return NULL;
17390 }
17391
17392
17393 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17394 PyObject *obj;
17395 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17396 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17397 return SWIG_Py_Void();
17398 }
17399
17400 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17401 return SWIG_Python_InitShadowInstance(args);
17402 }
17403
17404 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17405 PyObject *resultobj = 0;
17406 wxPCXHandler *result = 0 ;
17407
17408 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17409 {
17410 PyThreadState* __tstate = wxPyBeginAllowThreads();
17411 result = (wxPCXHandler *)new wxPCXHandler();
17412 wxPyEndAllowThreads(__tstate);
17413 if (PyErr_Occurred()) SWIG_fail;
17414 }
17415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17416 return resultobj;
17417 fail:
17418 return NULL;
17419 }
17420
17421
17422 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17423 PyObject *obj;
17424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17425 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17426 return SWIG_Py_Void();
17427 }
17428
17429 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17430 return SWIG_Python_InitShadowInstance(args);
17431 }
17432
17433 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17434 PyObject *resultobj = 0;
17435 wxJPEGHandler *result = 0 ;
17436
17437 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17438 {
17439 PyThreadState* __tstate = wxPyBeginAllowThreads();
17440 result = (wxJPEGHandler *)new wxJPEGHandler();
17441 wxPyEndAllowThreads(__tstate);
17442 if (PyErr_Occurred()) SWIG_fail;
17443 }
17444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17445 return resultobj;
17446 fail:
17447 return NULL;
17448 }
17449
17450
17451 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17452 PyObject *obj;
17453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17454 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17455 return SWIG_Py_Void();
17456 }
17457
17458 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17459 return SWIG_Python_InitShadowInstance(args);
17460 }
17461
17462 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17463 PyObject *resultobj = 0;
17464 wxPNMHandler *result = 0 ;
17465
17466 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17467 {
17468 PyThreadState* __tstate = wxPyBeginAllowThreads();
17469 result = (wxPNMHandler *)new wxPNMHandler();
17470 wxPyEndAllowThreads(__tstate);
17471 if (PyErr_Occurred()) SWIG_fail;
17472 }
17473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17474 return resultobj;
17475 fail:
17476 return NULL;
17477 }
17478
17479
17480 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17481 PyObject *obj;
17482 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17483 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17484 return SWIG_Py_Void();
17485 }
17486
17487 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17488 return SWIG_Python_InitShadowInstance(args);
17489 }
17490
17491 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17492 PyObject *resultobj = 0;
17493 wxXPMHandler *result = 0 ;
17494
17495 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17496 {
17497 PyThreadState* __tstate = wxPyBeginAllowThreads();
17498 result = (wxXPMHandler *)new wxXPMHandler();
17499 wxPyEndAllowThreads(__tstate);
17500 if (PyErr_Occurred()) SWIG_fail;
17501 }
17502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17503 return resultobj;
17504 fail:
17505 return NULL;
17506 }
17507
17508
17509 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17510 PyObject *obj;
17511 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17512 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17513 return SWIG_Py_Void();
17514 }
17515
17516 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17517 return SWIG_Python_InitShadowInstance(args);
17518 }
17519
17520 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17521 PyObject *resultobj = 0;
17522 wxTIFFHandler *result = 0 ;
17523
17524 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17525 {
17526 PyThreadState* __tstate = wxPyBeginAllowThreads();
17527 result = (wxTIFFHandler *)new wxTIFFHandler();
17528 wxPyEndAllowThreads(__tstate);
17529 if (PyErr_Occurred()) SWIG_fail;
17530 }
17531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17532 return resultobj;
17533 fail:
17534 return NULL;
17535 }
17536
17537
17538 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17539 PyObject *obj;
17540 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17541 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17542 return SWIG_Py_Void();
17543 }
17544
17545 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17546 return SWIG_Python_InitShadowInstance(args);
17547 }
17548
17549 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17550 PyObject *resultobj = 0;
17551 wxImage *arg1 = 0 ;
17552 wxImage *arg2 = 0 ;
17553 int arg3 = (int) 236 ;
17554 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17555 bool result;
17556 void *argp1 = 0 ;
17557 int res1 = 0 ;
17558 void *argp2 = 0 ;
17559 int res2 = 0 ;
17560 int val3 ;
17561 int ecode3 = 0 ;
17562 int val4 ;
17563 int ecode4 = 0 ;
17564 PyObject * obj0 = 0 ;
17565 PyObject * obj1 = 0 ;
17566 PyObject * obj2 = 0 ;
17567 PyObject * obj3 = 0 ;
17568 char * kwnames[] = {
17569 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17570 };
17571
17572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17573 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17574 if (!SWIG_IsOK(res1)) {
17575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17576 }
17577 if (!argp1) {
17578 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17579 }
17580 arg1 = reinterpret_cast< wxImage * >(argp1);
17581 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17582 if (!SWIG_IsOK(res2)) {
17583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17584 }
17585 if (!argp2) {
17586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17587 }
17588 arg2 = reinterpret_cast< wxImage * >(argp2);
17589 if (obj2) {
17590 ecode3 = SWIG_AsVal_int(obj2, &val3);
17591 if (!SWIG_IsOK(ecode3)) {
17592 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17593 }
17594 arg3 = static_cast< int >(val3);
17595 }
17596 if (obj3) {
17597 ecode4 = SWIG_AsVal_int(obj3, &val4);
17598 if (!SWIG_IsOK(ecode4)) {
17599 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17600 }
17601 arg4 = static_cast< int >(val4);
17602 }
17603 {
17604 PyThreadState* __tstate = wxPyBeginAllowThreads();
17605 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17606 wxPyEndAllowThreads(__tstate);
17607 if (PyErr_Occurred()) SWIG_fail;
17608 }
17609 {
17610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17611 }
17612 return resultobj;
17613 fail:
17614 return NULL;
17615 }
17616
17617
17618 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17619 PyObject *obj;
17620 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17621 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17622 return SWIG_Py_Void();
17623 }
17624
17625 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17626 PyObject *resultobj = 0;
17627 wxEvtHandler *result = 0 ;
17628
17629 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17630 {
17631 PyThreadState* __tstate = wxPyBeginAllowThreads();
17632 result = (wxEvtHandler *)new wxEvtHandler();
17633 wxPyEndAllowThreads(__tstate);
17634 if (PyErr_Occurred()) SWIG_fail;
17635 }
17636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17637 return resultobj;
17638 fail:
17639 return NULL;
17640 }
17641
17642
17643 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17644 PyObject *resultobj = 0;
17645 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17646 wxEvtHandler *result = 0 ;
17647 void *argp1 = 0 ;
17648 int res1 = 0 ;
17649 PyObject *swig_obj[1] ;
17650
17651 if (!args) SWIG_fail;
17652 swig_obj[0] = args;
17653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17654 if (!SWIG_IsOK(res1)) {
17655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17656 }
17657 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17658 {
17659 PyThreadState* __tstate = wxPyBeginAllowThreads();
17660 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17661 wxPyEndAllowThreads(__tstate);
17662 if (PyErr_Occurred()) SWIG_fail;
17663 }
17664 {
17665 resultobj = wxPyMake_wxObject(result, 0);
17666 }
17667 return resultobj;
17668 fail:
17669 return NULL;
17670 }
17671
17672
17673 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17674 PyObject *resultobj = 0;
17675 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17676 wxEvtHandler *result = 0 ;
17677 void *argp1 = 0 ;
17678 int res1 = 0 ;
17679 PyObject *swig_obj[1] ;
17680
17681 if (!args) SWIG_fail;
17682 swig_obj[0] = args;
17683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17684 if (!SWIG_IsOK(res1)) {
17685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17686 }
17687 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17688 {
17689 PyThreadState* __tstate = wxPyBeginAllowThreads();
17690 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17691 wxPyEndAllowThreads(__tstate);
17692 if (PyErr_Occurred()) SWIG_fail;
17693 }
17694 {
17695 resultobj = wxPyMake_wxObject(result, 0);
17696 }
17697 return resultobj;
17698 fail:
17699 return NULL;
17700 }
17701
17702
17703 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17704 PyObject *resultobj = 0;
17705 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17706 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17707 void *argp1 = 0 ;
17708 int res1 = 0 ;
17709 void *argp2 = 0 ;
17710 int res2 = 0 ;
17711 PyObject * obj0 = 0 ;
17712 PyObject * obj1 = 0 ;
17713 char * kwnames[] = {
17714 (char *) "self",(char *) "handler", NULL
17715 };
17716
17717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17719 if (!SWIG_IsOK(res1)) {
17720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17721 }
17722 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17723 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17724 if (!SWIG_IsOK(res2)) {
17725 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17726 }
17727 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17728 {
17729 PyThreadState* __tstate = wxPyBeginAllowThreads();
17730 (arg1)->SetNextHandler(arg2);
17731 wxPyEndAllowThreads(__tstate);
17732 if (PyErr_Occurred()) SWIG_fail;
17733 }
17734 resultobj = SWIG_Py_Void();
17735 return resultobj;
17736 fail:
17737 return NULL;
17738 }
17739
17740
17741 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17742 PyObject *resultobj = 0;
17743 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17744 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17745 void *argp1 = 0 ;
17746 int res1 = 0 ;
17747 void *argp2 = 0 ;
17748 int res2 = 0 ;
17749 PyObject * obj0 = 0 ;
17750 PyObject * obj1 = 0 ;
17751 char * kwnames[] = {
17752 (char *) "self",(char *) "handler", NULL
17753 };
17754
17755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17757 if (!SWIG_IsOK(res1)) {
17758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17759 }
17760 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17761 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17762 if (!SWIG_IsOK(res2)) {
17763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17764 }
17765 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17766 {
17767 PyThreadState* __tstate = wxPyBeginAllowThreads();
17768 (arg1)->SetPreviousHandler(arg2);
17769 wxPyEndAllowThreads(__tstate);
17770 if (PyErr_Occurred()) SWIG_fail;
17771 }
17772 resultobj = SWIG_Py_Void();
17773 return resultobj;
17774 fail:
17775 return NULL;
17776 }
17777
17778
17779 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17780 PyObject *resultobj = 0;
17781 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17782 bool result;
17783 void *argp1 = 0 ;
17784 int res1 = 0 ;
17785 PyObject *swig_obj[1] ;
17786
17787 if (!args) SWIG_fail;
17788 swig_obj[0] = args;
17789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17790 if (!SWIG_IsOK(res1)) {
17791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17792 }
17793 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17794 {
17795 PyThreadState* __tstate = wxPyBeginAllowThreads();
17796 result = (bool)(arg1)->GetEvtHandlerEnabled();
17797 wxPyEndAllowThreads(__tstate);
17798 if (PyErr_Occurred()) SWIG_fail;
17799 }
17800 {
17801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17802 }
17803 return resultobj;
17804 fail:
17805 return NULL;
17806 }
17807
17808
17809 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17810 PyObject *resultobj = 0;
17811 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17812 bool arg2 ;
17813 void *argp1 = 0 ;
17814 int res1 = 0 ;
17815 bool val2 ;
17816 int ecode2 = 0 ;
17817 PyObject * obj0 = 0 ;
17818 PyObject * obj1 = 0 ;
17819 char * kwnames[] = {
17820 (char *) "self",(char *) "enabled", NULL
17821 };
17822
17823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17825 if (!SWIG_IsOK(res1)) {
17826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17827 }
17828 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17829 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17830 if (!SWIG_IsOK(ecode2)) {
17831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17832 }
17833 arg2 = static_cast< bool >(val2);
17834 {
17835 PyThreadState* __tstate = wxPyBeginAllowThreads();
17836 (arg1)->SetEvtHandlerEnabled(arg2);
17837 wxPyEndAllowThreads(__tstate);
17838 if (PyErr_Occurred()) SWIG_fail;
17839 }
17840 resultobj = SWIG_Py_Void();
17841 return resultobj;
17842 fail:
17843 return NULL;
17844 }
17845
17846
17847 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17848 PyObject *resultobj = 0;
17849 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17850 wxEvent *arg2 = 0 ;
17851 bool result;
17852 void *argp1 = 0 ;
17853 int res1 = 0 ;
17854 void *argp2 = 0 ;
17855 int res2 = 0 ;
17856 PyObject * obj0 = 0 ;
17857 PyObject * obj1 = 0 ;
17858 char * kwnames[] = {
17859 (char *) "self",(char *) "event", NULL
17860 };
17861
17862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17864 if (!SWIG_IsOK(res1)) {
17865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17866 }
17867 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17868 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17869 if (!SWIG_IsOK(res2)) {
17870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17871 }
17872 if (!argp2) {
17873 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17874 }
17875 arg2 = reinterpret_cast< wxEvent * >(argp2);
17876 {
17877 PyThreadState* __tstate = wxPyBeginAllowThreads();
17878 result = (bool)(arg1)->ProcessEvent(*arg2);
17879 wxPyEndAllowThreads(__tstate);
17880 if (PyErr_Occurred()) SWIG_fail;
17881 }
17882 {
17883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17884 }
17885 return resultobj;
17886 fail:
17887 return NULL;
17888 }
17889
17890
17891 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17892 PyObject *resultobj = 0;
17893 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17894 wxEvent *arg2 = 0 ;
17895 void *argp1 = 0 ;
17896 int res1 = 0 ;
17897 void *argp2 = 0 ;
17898 int res2 = 0 ;
17899 PyObject * obj0 = 0 ;
17900 PyObject * obj1 = 0 ;
17901 char * kwnames[] = {
17902 (char *) "self",(char *) "event", NULL
17903 };
17904
17905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17907 if (!SWIG_IsOK(res1)) {
17908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17909 }
17910 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17911 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17912 if (!SWIG_IsOK(res2)) {
17913 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17914 }
17915 if (!argp2) {
17916 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17917 }
17918 arg2 = reinterpret_cast< wxEvent * >(argp2);
17919 {
17920 PyThreadState* __tstate = wxPyBeginAllowThreads();
17921 (arg1)->AddPendingEvent(*arg2);
17922 wxPyEndAllowThreads(__tstate);
17923 if (PyErr_Occurred()) SWIG_fail;
17924 }
17925 resultobj = SWIG_Py_Void();
17926 return resultobj;
17927 fail:
17928 return NULL;
17929 }
17930
17931
17932 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17933 PyObject *resultobj = 0;
17934 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17935 void *argp1 = 0 ;
17936 int res1 = 0 ;
17937 PyObject *swig_obj[1] ;
17938
17939 if (!args) SWIG_fail;
17940 swig_obj[0] = args;
17941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17942 if (!SWIG_IsOK(res1)) {
17943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17944 }
17945 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17946 {
17947 PyThreadState* __tstate = wxPyBeginAllowThreads();
17948 (arg1)->ProcessPendingEvents();
17949 wxPyEndAllowThreads(__tstate);
17950 if (PyErr_Occurred()) SWIG_fail;
17951 }
17952 resultobj = SWIG_Py_Void();
17953 return resultobj;
17954 fail:
17955 return NULL;
17956 }
17957
17958
17959 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17960 PyObject *resultobj = 0;
17961 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17962 int arg2 ;
17963 int arg3 ;
17964 int arg4 ;
17965 PyObject *arg5 = (PyObject *) 0 ;
17966 void *argp1 = 0 ;
17967 int res1 = 0 ;
17968 int val2 ;
17969 int ecode2 = 0 ;
17970 int val3 ;
17971 int ecode3 = 0 ;
17972 int val4 ;
17973 int ecode4 = 0 ;
17974 PyObject * obj0 = 0 ;
17975 PyObject * obj1 = 0 ;
17976 PyObject * obj2 = 0 ;
17977 PyObject * obj3 = 0 ;
17978 PyObject * obj4 = 0 ;
17979 char * kwnames[] = {
17980 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17981 };
17982
17983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17985 if (!SWIG_IsOK(res1)) {
17986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17987 }
17988 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17989 ecode2 = SWIG_AsVal_int(obj1, &val2);
17990 if (!SWIG_IsOK(ecode2)) {
17991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17992 }
17993 arg2 = static_cast< int >(val2);
17994 ecode3 = SWIG_AsVal_int(obj2, &val3);
17995 if (!SWIG_IsOK(ecode3)) {
17996 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17997 }
17998 arg3 = static_cast< int >(val3);
17999 ecode4 = SWIG_AsVal_int(obj3, &val4);
18000 if (!SWIG_IsOK(ecode4)) {
18001 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18002 }
18003 arg4 = static_cast< int >(val4);
18004 arg5 = obj4;
18005 {
18006 PyThreadState* __tstate = wxPyBeginAllowThreads();
18007 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18008 wxPyEndAllowThreads(__tstate);
18009 if (PyErr_Occurred()) SWIG_fail;
18010 }
18011 resultobj = SWIG_Py_Void();
18012 return resultobj;
18013 fail:
18014 return NULL;
18015 }
18016
18017
18018 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18019 PyObject *resultobj = 0;
18020 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18021 int arg2 ;
18022 int arg3 = (int) -1 ;
18023 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18024 bool result;
18025 void *argp1 = 0 ;
18026 int res1 = 0 ;
18027 int val2 ;
18028 int ecode2 = 0 ;
18029 int val3 ;
18030 int ecode3 = 0 ;
18031 int val4 ;
18032 int ecode4 = 0 ;
18033 PyObject * obj0 = 0 ;
18034 PyObject * obj1 = 0 ;
18035 PyObject * obj2 = 0 ;
18036 PyObject * obj3 = 0 ;
18037 char * kwnames[] = {
18038 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18039 };
18040
18041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18043 if (!SWIG_IsOK(res1)) {
18044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18045 }
18046 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18047 ecode2 = SWIG_AsVal_int(obj1, &val2);
18048 if (!SWIG_IsOK(ecode2)) {
18049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18050 }
18051 arg2 = static_cast< int >(val2);
18052 if (obj2) {
18053 ecode3 = SWIG_AsVal_int(obj2, &val3);
18054 if (!SWIG_IsOK(ecode3)) {
18055 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18056 }
18057 arg3 = static_cast< int >(val3);
18058 }
18059 if (obj3) {
18060 ecode4 = SWIG_AsVal_int(obj3, &val4);
18061 if (!SWIG_IsOK(ecode4)) {
18062 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18063 }
18064 arg4 = static_cast< wxEventType >(val4);
18065 }
18066 {
18067 PyThreadState* __tstate = wxPyBeginAllowThreads();
18068 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18069 wxPyEndAllowThreads(__tstate);
18070 if (PyErr_Occurred()) SWIG_fail;
18071 }
18072 {
18073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18074 }
18075 return resultobj;
18076 fail:
18077 return NULL;
18078 }
18079
18080
18081 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18082 PyObject *resultobj = 0;
18083 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18084 PyObject *arg2 = (PyObject *) 0 ;
18085 bool arg3 = (bool) true ;
18086 void *argp1 = 0 ;
18087 int res1 = 0 ;
18088 bool val3 ;
18089 int ecode3 = 0 ;
18090 PyObject * obj0 = 0 ;
18091 PyObject * obj1 = 0 ;
18092 PyObject * obj2 = 0 ;
18093 char * kwnames[] = {
18094 (char *) "self",(char *) "_self",(char *) "incref", NULL
18095 };
18096
18097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18099 if (!SWIG_IsOK(res1)) {
18100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18101 }
18102 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18103 arg2 = obj1;
18104 if (obj2) {
18105 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18106 if (!SWIG_IsOK(ecode3)) {
18107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18108 }
18109 arg3 = static_cast< bool >(val3);
18110 }
18111 {
18112 PyThreadState* __tstate = wxPyBeginAllowThreads();
18113 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18114 wxPyEndAllowThreads(__tstate);
18115 if (PyErr_Occurred()) SWIG_fail;
18116 }
18117 resultobj = SWIG_Py_Void();
18118 return resultobj;
18119 fail:
18120 return NULL;
18121 }
18122
18123
18124 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18125 PyObject *obj;
18126 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18127 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18128 return SWIG_Py_Void();
18129 }
18130
18131 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18132 return SWIG_Python_InitShadowInstance(args);
18133 }
18134
18135 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18136 PyObject *resultobj = 0;
18137 wxEventType result;
18138
18139 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18140 {
18141 PyThreadState* __tstate = wxPyBeginAllowThreads();
18142 result = (wxEventType)wxNewEventType();
18143 wxPyEndAllowThreads(__tstate);
18144 if (PyErr_Occurred()) SWIG_fail;
18145 }
18146 resultobj = SWIG_From_int(static_cast< int >(result));
18147 return resultobj;
18148 fail:
18149 return NULL;
18150 }
18151
18152
18153 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18154 PyObject *resultobj = 0;
18155 wxEvent *arg1 = (wxEvent *) 0 ;
18156 void *argp1 = 0 ;
18157 int res1 = 0 ;
18158 PyObject *swig_obj[1] ;
18159
18160 if (!args) SWIG_fail;
18161 swig_obj[0] = args;
18162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18163 if (!SWIG_IsOK(res1)) {
18164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18165 }
18166 arg1 = reinterpret_cast< wxEvent * >(argp1);
18167 {
18168 PyThreadState* __tstate = wxPyBeginAllowThreads();
18169 delete arg1;
18170
18171 wxPyEndAllowThreads(__tstate);
18172 if (PyErr_Occurred()) SWIG_fail;
18173 }
18174 resultobj = SWIG_Py_Void();
18175 return resultobj;
18176 fail:
18177 return NULL;
18178 }
18179
18180
18181 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18182 PyObject *resultobj = 0;
18183 wxEvent *arg1 = (wxEvent *) 0 ;
18184 wxEventType arg2 ;
18185 void *argp1 = 0 ;
18186 int res1 = 0 ;
18187 int val2 ;
18188 int ecode2 = 0 ;
18189 PyObject * obj0 = 0 ;
18190 PyObject * obj1 = 0 ;
18191 char * kwnames[] = {
18192 (char *) "self",(char *) "typ", NULL
18193 };
18194
18195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18197 if (!SWIG_IsOK(res1)) {
18198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18199 }
18200 arg1 = reinterpret_cast< wxEvent * >(argp1);
18201 ecode2 = SWIG_AsVal_int(obj1, &val2);
18202 if (!SWIG_IsOK(ecode2)) {
18203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18204 }
18205 arg2 = static_cast< wxEventType >(val2);
18206 {
18207 PyThreadState* __tstate = wxPyBeginAllowThreads();
18208 (arg1)->SetEventType(arg2);
18209 wxPyEndAllowThreads(__tstate);
18210 if (PyErr_Occurred()) SWIG_fail;
18211 }
18212 resultobj = SWIG_Py_Void();
18213 return resultobj;
18214 fail:
18215 return NULL;
18216 }
18217
18218
18219 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18220 PyObject *resultobj = 0;
18221 wxEvent *arg1 = (wxEvent *) 0 ;
18222 wxEventType result;
18223 void *argp1 = 0 ;
18224 int res1 = 0 ;
18225 PyObject *swig_obj[1] ;
18226
18227 if (!args) SWIG_fail;
18228 swig_obj[0] = args;
18229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18230 if (!SWIG_IsOK(res1)) {
18231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18232 }
18233 arg1 = reinterpret_cast< wxEvent * >(argp1);
18234 {
18235 PyThreadState* __tstate = wxPyBeginAllowThreads();
18236 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18237 wxPyEndAllowThreads(__tstate);
18238 if (PyErr_Occurred()) SWIG_fail;
18239 }
18240 resultobj = SWIG_From_int(static_cast< int >(result));
18241 return resultobj;
18242 fail:
18243 return NULL;
18244 }
18245
18246
18247 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18248 PyObject *resultobj = 0;
18249 wxEvent *arg1 = (wxEvent *) 0 ;
18250 wxObject *result = 0 ;
18251 void *argp1 = 0 ;
18252 int res1 = 0 ;
18253 PyObject *swig_obj[1] ;
18254
18255 if (!args) SWIG_fail;
18256 swig_obj[0] = args;
18257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18258 if (!SWIG_IsOK(res1)) {
18259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18260 }
18261 arg1 = reinterpret_cast< wxEvent * >(argp1);
18262 {
18263 PyThreadState* __tstate = wxPyBeginAllowThreads();
18264 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18265 wxPyEndAllowThreads(__tstate);
18266 if (PyErr_Occurred()) SWIG_fail;
18267 }
18268 {
18269 resultobj = wxPyMake_wxObject(result, (bool)0);
18270 }
18271 return resultobj;
18272 fail:
18273 return NULL;
18274 }
18275
18276
18277 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18278 PyObject *resultobj = 0;
18279 wxEvent *arg1 = (wxEvent *) 0 ;
18280 wxObject *arg2 = (wxObject *) 0 ;
18281 void *argp1 = 0 ;
18282 int res1 = 0 ;
18283 void *argp2 = 0 ;
18284 int res2 = 0 ;
18285 PyObject * obj0 = 0 ;
18286 PyObject * obj1 = 0 ;
18287 char * kwnames[] = {
18288 (char *) "self",(char *) "obj", NULL
18289 };
18290
18291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18293 if (!SWIG_IsOK(res1)) {
18294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18295 }
18296 arg1 = reinterpret_cast< wxEvent * >(argp1);
18297 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18298 if (!SWIG_IsOK(res2)) {
18299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18300 }
18301 arg2 = reinterpret_cast< wxObject * >(argp2);
18302 {
18303 PyThreadState* __tstate = wxPyBeginAllowThreads();
18304 (arg1)->SetEventObject(arg2);
18305 wxPyEndAllowThreads(__tstate);
18306 if (PyErr_Occurred()) SWIG_fail;
18307 }
18308 resultobj = SWIG_Py_Void();
18309 return resultobj;
18310 fail:
18311 return NULL;
18312 }
18313
18314
18315 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18316 PyObject *resultobj = 0;
18317 wxEvent *arg1 = (wxEvent *) 0 ;
18318 long result;
18319 void *argp1 = 0 ;
18320 int res1 = 0 ;
18321 PyObject *swig_obj[1] ;
18322
18323 if (!args) SWIG_fail;
18324 swig_obj[0] = args;
18325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18326 if (!SWIG_IsOK(res1)) {
18327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18328 }
18329 arg1 = reinterpret_cast< wxEvent * >(argp1);
18330 {
18331 PyThreadState* __tstate = wxPyBeginAllowThreads();
18332 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18333 wxPyEndAllowThreads(__tstate);
18334 if (PyErr_Occurred()) SWIG_fail;
18335 }
18336 resultobj = SWIG_From_long(static_cast< long >(result));
18337 return resultobj;
18338 fail:
18339 return NULL;
18340 }
18341
18342
18343 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18344 PyObject *resultobj = 0;
18345 wxEvent *arg1 = (wxEvent *) 0 ;
18346 long arg2 = (long) 0 ;
18347 void *argp1 = 0 ;
18348 int res1 = 0 ;
18349 long val2 ;
18350 int ecode2 = 0 ;
18351 PyObject * obj0 = 0 ;
18352 PyObject * obj1 = 0 ;
18353 char * kwnames[] = {
18354 (char *) "self",(char *) "ts", NULL
18355 };
18356
18357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18359 if (!SWIG_IsOK(res1)) {
18360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18361 }
18362 arg1 = reinterpret_cast< wxEvent * >(argp1);
18363 if (obj1) {
18364 ecode2 = SWIG_AsVal_long(obj1, &val2);
18365 if (!SWIG_IsOK(ecode2)) {
18366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18367 }
18368 arg2 = static_cast< long >(val2);
18369 }
18370 {
18371 PyThreadState* __tstate = wxPyBeginAllowThreads();
18372 (arg1)->SetTimestamp(arg2);
18373 wxPyEndAllowThreads(__tstate);
18374 if (PyErr_Occurred()) SWIG_fail;
18375 }
18376 resultobj = SWIG_Py_Void();
18377 return resultobj;
18378 fail:
18379 return NULL;
18380 }
18381
18382
18383 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18384 PyObject *resultobj = 0;
18385 wxEvent *arg1 = (wxEvent *) 0 ;
18386 int result;
18387 void *argp1 = 0 ;
18388 int res1 = 0 ;
18389 PyObject *swig_obj[1] ;
18390
18391 if (!args) SWIG_fail;
18392 swig_obj[0] = args;
18393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18394 if (!SWIG_IsOK(res1)) {
18395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18396 }
18397 arg1 = reinterpret_cast< wxEvent * >(argp1);
18398 {
18399 PyThreadState* __tstate = wxPyBeginAllowThreads();
18400 result = (int)((wxEvent const *)arg1)->GetId();
18401 wxPyEndAllowThreads(__tstate);
18402 if (PyErr_Occurred()) SWIG_fail;
18403 }
18404 resultobj = SWIG_From_int(static_cast< int >(result));
18405 return resultobj;
18406 fail:
18407 return NULL;
18408 }
18409
18410
18411 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18412 PyObject *resultobj = 0;
18413 wxEvent *arg1 = (wxEvent *) 0 ;
18414 int arg2 ;
18415 void *argp1 = 0 ;
18416 int res1 = 0 ;
18417 int val2 ;
18418 int ecode2 = 0 ;
18419 PyObject * obj0 = 0 ;
18420 PyObject * obj1 = 0 ;
18421 char * kwnames[] = {
18422 (char *) "self",(char *) "Id", NULL
18423 };
18424
18425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18427 if (!SWIG_IsOK(res1)) {
18428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18429 }
18430 arg1 = reinterpret_cast< wxEvent * >(argp1);
18431 ecode2 = SWIG_AsVal_int(obj1, &val2);
18432 if (!SWIG_IsOK(ecode2)) {
18433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18434 }
18435 arg2 = static_cast< int >(val2);
18436 {
18437 PyThreadState* __tstate = wxPyBeginAllowThreads();
18438 (arg1)->SetId(arg2);
18439 wxPyEndAllowThreads(__tstate);
18440 if (PyErr_Occurred()) SWIG_fail;
18441 }
18442 resultobj = SWIG_Py_Void();
18443 return resultobj;
18444 fail:
18445 return NULL;
18446 }
18447
18448
18449 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18450 PyObject *resultobj = 0;
18451 wxEvent *arg1 = (wxEvent *) 0 ;
18452 bool result;
18453 void *argp1 = 0 ;
18454 int res1 = 0 ;
18455 PyObject *swig_obj[1] ;
18456
18457 if (!args) SWIG_fail;
18458 swig_obj[0] = args;
18459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18460 if (!SWIG_IsOK(res1)) {
18461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18462 }
18463 arg1 = reinterpret_cast< wxEvent * >(argp1);
18464 {
18465 PyThreadState* __tstate = wxPyBeginAllowThreads();
18466 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18467 wxPyEndAllowThreads(__tstate);
18468 if (PyErr_Occurred()) SWIG_fail;
18469 }
18470 {
18471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18472 }
18473 return resultobj;
18474 fail:
18475 return NULL;
18476 }
18477
18478
18479 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18480 PyObject *resultobj = 0;
18481 wxEvent *arg1 = (wxEvent *) 0 ;
18482 bool arg2 = (bool) true ;
18483 void *argp1 = 0 ;
18484 int res1 = 0 ;
18485 bool val2 ;
18486 int ecode2 = 0 ;
18487 PyObject * obj0 = 0 ;
18488 PyObject * obj1 = 0 ;
18489 char * kwnames[] = {
18490 (char *) "self",(char *) "skip", NULL
18491 };
18492
18493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18495 if (!SWIG_IsOK(res1)) {
18496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18497 }
18498 arg1 = reinterpret_cast< wxEvent * >(argp1);
18499 if (obj1) {
18500 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18501 if (!SWIG_IsOK(ecode2)) {
18502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18503 }
18504 arg2 = static_cast< bool >(val2);
18505 }
18506 {
18507 PyThreadState* __tstate = wxPyBeginAllowThreads();
18508 (arg1)->Skip(arg2);
18509 wxPyEndAllowThreads(__tstate);
18510 if (PyErr_Occurred()) SWIG_fail;
18511 }
18512 resultobj = SWIG_Py_Void();
18513 return resultobj;
18514 fail:
18515 return NULL;
18516 }
18517
18518
18519 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18520 PyObject *resultobj = 0;
18521 wxEvent *arg1 = (wxEvent *) 0 ;
18522 bool result;
18523 void *argp1 = 0 ;
18524 int res1 = 0 ;
18525 PyObject *swig_obj[1] ;
18526
18527 if (!args) SWIG_fail;
18528 swig_obj[0] = args;
18529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18530 if (!SWIG_IsOK(res1)) {
18531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18532 }
18533 arg1 = reinterpret_cast< wxEvent * >(argp1);
18534 {
18535 PyThreadState* __tstate = wxPyBeginAllowThreads();
18536 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18537 wxPyEndAllowThreads(__tstate);
18538 if (PyErr_Occurred()) SWIG_fail;
18539 }
18540 {
18541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18542 }
18543 return resultobj;
18544 fail:
18545 return NULL;
18546 }
18547
18548
18549 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18550 PyObject *resultobj = 0;
18551 wxEvent *arg1 = (wxEvent *) 0 ;
18552 bool result;
18553 void *argp1 = 0 ;
18554 int res1 = 0 ;
18555 PyObject *swig_obj[1] ;
18556
18557 if (!args) SWIG_fail;
18558 swig_obj[0] = args;
18559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18560 if (!SWIG_IsOK(res1)) {
18561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18562 }
18563 arg1 = reinterpret_cast< wxEvent * >(argp1);
18564 {
18565 PyThreadState* __tstate = wxPyBeginAllowThreads();
18566 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18567 wxPyEndAllowThreads(__tstate);
18568 if (PyErr_Occurred()) SWIG_fail;
18569 }
18570 {
18571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18572 }
18573 return resultobj;
18574 fail:
18575 return NULL;
18576 }
18577
18578
18579 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18580 PyObject *resultobj = 0;
18581 wxEvent *arg1 = (wxEvent *) 0 ;
18582 int result;
18583 void *argp1 = 0 ;
18584 int res1 = 0 ;
18585 PyObject *swig_obj[1] ;
18586
18587 if (!args) SWIG_fail;
18588 swig_obj[0] = args;
18589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18590 if (!SWIG_IsOK(res1)) {
18591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18592 }
18593 arg1 = reinterpret_cast< wxEvent * >(argp1);
18594 {
18595 PyThreadState* __tstate = wxPyBeginAllowThreads();
18596 result = (int)(arg1)->StopPropagation();
18597 wxPyEndAllowThreads(__tstate);
18598 if (PyErr_Occurred()) SWIG_fail;
18599 }
18600 resultobj = SWIG_From_int(static_cast< int >(result));
18601 return resultobj;
18602 fail:
18603 return NULL;
18604 }
18605
18606
18607 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18608 PyObject *resultobj = 0;
18609 wxEvent *arg1 = (wxEvent *) 0 ;
18610 int arg2 ;
18611 void *argp1 = 0 ;
18612 int res1 = 0 ;
18613 int val2 ;
18614 int ecode2 = 0 ;
18615 PyObject * obj0 = 0 ;
18616 PyObject * obj1 = 0 ;
18617 char * kwnames[] = {
18618 (char *) "self",(char *) "propagationLevel", NULL
18619 };
18620
18621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18623 if (!SWIG_IsOK(res1)) {
18624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18625 }
18626 arg1 = reinterpret_cast< wxEvent * >(argp1);
18627 ecode2 = SWIG_AsVal_int(obj1, &val2);
18628 if (!SWIG_IsOK(ecode2)) {
18629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18630 }
18631 arg2 = static_cast< int >(val2);
18632 {
18633 PyThreadState* __tstate = wxPyBeginAllowThreads();
18634 (arg1)->ResumePropagation(arg2);
18635 wxPyEndAllowThreads(__tstate);
18636 if (PyErr_Occurred()) SWIG_fail;
18637 }
18638 resultobj = SWIG_Py_Void();
18639 return resultobj;
18640 fail:
18641 return NULL;
18642 }
18643
18644
18645 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18646 PyObject *resultobj = 0;
18647 wxEvent *arg1 = (wxEvent *) 0 ;
18648 wxEvent *result = 0 ;
18649 void *argp1 = 0 ;
18650 int res1 = 0 ;
18651 PyObject *swig_obj[1] ;
18652
18653 if (!args) SWIG_fail;
18654 swig_obj[0] = args;
18655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18656 if (!SWIG_IsOK(res1)) {
18657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18658 }
18659 arg1 = reinterpret_cast< wxEvent * >(argp1);
18660 {
18661 PyThreadState* __tstate = wxPyBeginAllowThreads();
18662 result = (wxEvent *)(arg1)->Clone();
18663 wxPyEndAllowThreads(__tstate);
18664 if (PyErr_Occurred()) SWIG_fail;
18665 }
18666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18667 return resultobj;
18668 fail:
18669 return NULL;
18670 }
18671
18672
18673 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18674 PyObject *obj;
18675 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18676 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18677 return SWIG_Py_Void();
18678 }
18679
18680 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18681 PyObject *resultobj = 0;
18682 wxEvent *arg1 = 0 ;
18683 wxPropagationDisabler *result = 0 ;
18684 void *argp1 = 0 ;
18685 int res1 = 0 ;
18686 PyObject * obj0 = 0 ;
18687 char * kwnames[] = {
18688 (char *) "event", NULL
18689 };
18690
18691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18692 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18693 if (!SWIG_IsOK(res1)) {
18694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18695 }
18696 if (!argp1) {
18697 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18698 }
18699 arg1 = reinterpret_cast< wxEvent * >(argp1);
18700 {
18701 PyThreadState* __tstate = wxPyBeginAllowThreads();
18702 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18703 wxPyEndAllowThreads(__tstate);
18704 if (PyErr_Occurred()) SWIG_fail;
18705 }
18706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18707 return resultobj;
18708 fail:
18709 return NULL;
18710 }
18711
18712
18713 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18714 PyObject *resultobj = 0;
18715 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18716 void *argp1 = 0 ;
18717 int res1 = 0 ;
18718 PyObject *swig_obj[1] ;
18719
18720 if (!args) SWIG_fail;
18721 swig_obj[0] = args;
18722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18723 if (!SWIG_IsOK(res1)) {
18724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18725 }
18726 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18727 {
18728 PyThreadState* __tstate = wxPyBeginAllowThreads();
18729 delete arg1;
18730
18731 wxPyEndAllowThreads(__tstate);
18732 if (PyErr_Occurred()) SWIG_fail;
18733 }
18734 resultobj = SWIG_Py_Void();
18735 return resultobj;
18736 fail:
18737 return NULL;
18738 }
18739
18740
18741 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18742 PyObject *obj;
18743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18744 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18745 return SWIG_Py_Void();
18746 }
18747
18748 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18749 return SWIG_Python_InitShadowInstance(args);
18750 }
18751
18752 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18753 PyObject *resultobj = 0;
18754 wxEvent *arg1 = 0 ;
18755 wxPropagateOnce *result = 0 ;
18756 void *argp1 = 0 ;
18757 int res1 = 0 ;
18758 PyObject * obj0 = 0 ;
18759 char * kwnames[] = {
18760 (char *) "event", NULL
18761 };
18762
18763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18764 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18765 if (!SWIG_IsOK(res1)) {
18766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18767 }
18768 if (!argp1) {
18769 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18770 }
18771 arg1 = reinterpret_cast< wxEvent * >(argp1);
18772 {
18773 PyThreadState* __tstate = wxPyBeginAllowThreads();
18774 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18775 wxPyEndAllowThreads(__tstate);
18776 if (PyErr_Occurred()) SWIG_fail;
18777 }
18778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18779 return resultobj;
18780 fail:
18781 return NULL;
18782 }
18783
18784
18785 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18786 PyObject *resultobj = 0;
18787 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18788 void *argp1 = 0 ;
18789 int res1 = 0 ;
18790 PyObject *swig_obj[1] ;
18791
18792 if (!args) SWIG_fail;
18793 swig_obj[0] = args;
18794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18795 if (!SWIG_IsOK(res1)) {
18796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18797 }
18798 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18799 {
18800 PyThreadState* __tstate = wxPyBeginAllowThreads();
18801 delete arg1;
18802
18803 wxPyEndAllowThreads(__tstate);
18804 if (PyErr_Occurred()) SWIG_fail;
18805 }
18806 resultobj = SWIG_Py_Void();
18807 return resultobj;
18808 fail:
18809 return NULL;
18810 }
18811
18812
18813 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18814 PyObject *obj;
18815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18816 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18817 return SWIG_Py_Void();
18818 }
18819
18820 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18821 return SWIG_Python_InitShadowInstance(args);
18822 }
18823
18824 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18825 PyObject *resultobj = 0;
18826 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18827 int arg2 = (int) 0 ;
18828 wxCommandEvent *result = 0 ;
18829 int val1 ;
18830 int ecode1 = 0 ;
18831 int val2 ;
18832 int ecode2 = 0 ;
18833 PyObject * obj0 = 0 ;
18834 PyObject * obj1 = 0 ;
18835 char * kwnames[] = {
18836 (char *) "commandType",(char *) "winid", NULL
18837 };
18838
18839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18840 if (obj0) {
18841 ecode1 = SWIG_AsVal_int(obj0, &val1);
18842 if (!SWIG_IsOK(ecode1)) {
18843 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18844 }
18845 arg1 = static_cast< wxEventType >(val1);
18846 }
18847 if (obj1) {
18848 ecode2 = SWIG_AsVal_int(obj1, &val2);
18849 if (!SWIG_IsOK(ecode2)) {
18850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18851 }
18852 arg2 = static_cast< int >(val2);
18853 }
18854 {
18855 PyThreadState* __tstate = wxPyBeginAllowThreads();
18856 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18857 wxPyEndAllowThreads(__tstate);
18858 if (PyErr_Occurred()) SWIG_fail;
18859 }
18860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18861 return resultobj;
18862 fail:
18863 return NULL;
18864 }
18865
18866
18867 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18868 PyObject *resultobj = 0;
18869 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18870 int result;
18871 void *argp1 = 0 ;
18872 int res1 = 0 ;
18873 PyObject *swig_obj[1] ;
18874
18875 if (!args) SWIG_fail;
18876 swig_obj[0] = args;
18877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18878 if (!SWIG_IsOK(res1)) {
18879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18880 }
18881 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18882 {
18883 PyThreadState* __tstate = wxPyBeginAllowThreads();
18884 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18885 wxPyEndAllowThreads(__tstate);
18886 if (PyErr_Occurred()) SWIG_fail;
18887 }
18888 resultobj = SWIG_From_int(static_cast< int >(result));
18889 return resultobj;
18890 fail:
18891 return NULL;
18892 }
18893
18894
18895 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18896 PyObject *resultobj = 0;
18897 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18898 wxString *arg2 = 0 ;
18899 void *argp1 = 0 ;
18900 int res1 = 0 ;
18901 bool temp2 = false ;
18902 PyObject * obj0 = 0 ;
18903 PyObject * obj1 = 0 ;
18904 char * kwnames[] = {
18905 (char *) "self",(char *) "s", NULL
18906 };
18907
18908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18910 if (!SWIG_IsOK(res1)) {
18911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18912 }
18913 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18914 {
18915 arg2 = wxString_in_helper(obj1);
18916 if (arg2 == NULL) SWIG_fail;
18917 temp2 = true;
18918 }
18919 {
18920 PyThreadState* __tstate = wxPyBeginAllowThreads();
18921 (arg1)->SetString((wxString const &)*arg2);
18922 wxPyEndAllowThreads(__tstate);
18923 if (PyErr_Occurred()) SWIG_fail;
18924 }
18925 resultobj = SWIG_Py_Void();
18926 {
18927 if (temp2)
18928 delete arg2;
18929 }
18930 return resultobj;
18931 fail:
18932 {
18933 if (temp2)
18934 delete arg2;
18935 }
18936 return NULL;
18937 }
18938
18939
18940 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18941 PyObject *resultobj = 0;
18942 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18943 wxString result;
18944 void *argp1 = 0 ;
18945 int res1 = 0 ;
18946 PyObject *swig_obj[1] ;
18947
18948 if (!args) SWIG_fail;
18949 swig_obj[0] = args;
18950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18951 if (!SWIG_IsOK(res1)) {
18952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18953 }
18954 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18955 {
18956 PyThreadState* __tstate = wxPyBeginAllowThreads();
18957 result = ((wxCommandEvent const *)arg1)->GetString();
18958 wxPyEndAllowThreads(__tstate);
18959 if (PyErr_Occurred()) SWIG_fail;
18960 }
18961 {
18962 #if wxUSE_UNICODE
18963 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18964 #else
18965 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18966 #endif
18967 }
18968 return resultobj;
18969 fail:
18970 return NULL;
18971 }
18972
18973
18974 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18975 PyObject *resultobj = 0;
18976 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18977 bool result;
18978 void *argp1 = 0 ;
18979 int res1 = 0 ;
18980 PyObject *swig_obj[1] ;
18981
18982 if (!args) SWIG_fail;
18983 swig_obj[0] = args;
18984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18985 if (!SWIG_IsOK(res1)) {
18986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18987 }
18988 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18989 {
18990 PyThreadState* __tstate = wxPyBeginAllowThreads();
18991 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18992 wxPyEndAllowThreads(__tstate);
18993 if (PyErr_Occurred()) SWIG_fail;
18994 }
18995 {
18996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18997 }
18998 return resultobj;
18999 fail:
19000 return NULL;
19001 }
19002
19003
19004 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19005 PyObject *resultobj = 0;
19006 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19007 bool result;
19008 void *argp1 = 0 ;
19009 int res1 = 0 ;
19010 PyObject *swig_obj[1] ;
19011
19012 if (!args) SWIG_fail;
19013 swig_obj[0] = args;
19014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19015 if (!SWIG_IsOK(res1)) {
19016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19017 }
19018 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19019 {
19020 PyThreadState* __tstate = wxPyBeginAllowThreads();
19021 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19022 wxPyEndAllowThreads(__tstate);
19023 if (PyErr_Occurred()) SWIG_fail;
19024 }
19025 {
19026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19027 }
19028 return resultobj;
19029 fail:
19030 return NULL;
19031 }
19032
19033
19034 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19035 PyObject *resultobj = 0;
19036 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19037 long arg2 ;
19038 void *argp1 = 0 ;
19039 int res1 = 0 ;
19040 long val2 ;
19041 int ecode2 = 0 ;
19042 PyObject * obj0 = 0 ;
19043 PyObject * obj1 = 0 ;
19044 char * kwnames[] = {
19045 (char *) "self",(char *) "extraLong", NULL
19046 };
19047
19048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19050 if (!SWIG_IsOK(res1)) {
19051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19052 }
19053 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19054 ecode2 = SWIG_AsVal_long(obj1, &val2);
19055 if (!SWIG_IsOK(ecode2)) {
19056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19057 }
19058 arg2 = static_cast< long >(val2);
19059 {
19060 PyThreadState* __tstate = wxPyBeginAllowThreads();
19061 (arg1)->SetExtraLong(arg2);
19062 wxPyEndAllowThreads(__tstate);
19063 if (PyErr_Occurred()) SWIG_fail;
19064 }
19065 resultobj = SWIG_Py_Void();
19066 return resultobj;
19067 fail:
19068 return NULL;
19069 }
19070
19071
19072 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19073 PyObject *resultobj = 0;
19074 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19075 long result;
19076 void *argp1 = 0 ;
19077 int res1 = 0 ;
19078 PyObject *swig_obj[1] ;
19079
19080 if (!args) SWIG_fail;
19081 swig_obj[0] = args;
19082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19083 if (!SWIG_IsOK(res1)) {
19084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19085 }
19086 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19087 {
19088 PyThreadState* __tstate = wxPyBeginAllowThreads();
19089 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19090 wxPyEndAllowThreads(__tstate);
19091 if (PyErr_Occurred()) SWIG_fail;
19092 }
19093 resultobj = SWIG_From_long(static_cast< long >(result));
19094 return resultobj;
19095 fail:
19096 return NULL;
19097 }
19098
19099
19100 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19101 PyObject *resultobj = 0;
19102 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19103 int arg2 ;
19104 void *argp1 = 0 ;
19105 int res1 = 0 ;
19106 int val2 ;
19107 int ecode2 = 0 ;
19108 PyObject * obj0 = 0 ;
19109 PyObject * obj1 = 0 ;
19110 char * kwnames[] = {
19111 (char *) "self",(char *) "i", NULL
19112 };
19113
19114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19116 if (!SWIG_IsOK(res1)) {
19117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19118 }
19119 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19120 ecode2 = SWIG_AsVal_int(obj1, &val2);
19121 if (!SWIG_IsOK(ecode2)) {
19122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19123 }
19124 arg2 = static_cast< int >(val2);
19125 {
19126 PyThreadState* __tstate = wxPyBeginAllowThreads();
19127 (arg1)->SetInt(arg2);
19128 wxPyEndAllowThreads(__tstate);
19129 if (PyErr_Occurred()) SWIG_fail;
19130 }
19131 resultobj = SWIG_Py_Void();
19132 return resultobj;
19133 fail:
19134 return NULL;
19135 }
19136
19137
19138 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19139 PyObject *resultobj = 0;
19140 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19141 int result;
19142 void *argp1 = 0 ;
19143 int res1 = 0 ;
19144 PyObject *swig_obj[1] ;
19145
19146 if (!args) SWIG_fail;
19147 swig_obj[0] = args;
19148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19149 if (!SWIG_IsOK(res1)) {
19150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19151 }
19152 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19153 {
19154 PyThreadState* __tstate = wxPyBeginAllowThreads();
19155 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19156 wxPyEndAllowThreads(__tstate);
19157 if (PyErr_Occurred()) SWIG_fail;
19158 }
19159 resultobj = SWIG_From_int(static_cast< int >(result));
19160 return resultobj;
19161 fail:
19162 return NULL;
19163 }
19164
19165
19166 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19167 PyObject *resultobj = 0;
19168 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19169 PyObject *result = 0 ;
19170 void *argp1 = 0 ;
19171 int res1 = 0 ;
19172 PyObject *swig_obj[1] ;
19173
19174 if (!args) SWIG_fail;
19175 swig_obj[0] = args;
19176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19177 if (!SWIG_IsOK(res1)) {
19178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19179 }
19180 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19181 {
19182 PyThreadState* __tstate = wxPyBeginAllowThreads();
19183 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19184 wxPyEndAllowThreads(__tstate);
19185 if (PyErr_Occurred()) SWIG_fail;
19186 }
19187 resultobj = result;
19188 return resultobj;
19189 fail:
19190 return NULL;
19191 }
19192
19193
19194 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19195 PyObject *resultobj = 0;
19196 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19197 PyObject *arg2 = (PyObject *) 0 ;
19198 void *argp1 = 0 ;
19199 int res1 = 0 ;
19200 PyObject * obj0 = 0 ;
19201 PyObject * obj1 = 0 ;
19202 char * kwnames[] = {
19203 (char *) "self",(char *) "clientData", NULL
19204 };
19205
19206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19208 if (!SWIG_IsOK(res1)) {
19209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19210 }
19211 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19212 arg2 = obj1;
19213 {
19214 PyThreadState* __tstate = wxPyBeginAllowThreads();
19215 wxCommandEvent_SetClientData(arg1,arg2);
19216 wxPyEndAllowThreads(__tstate);
19217 if (PyErr_Occurred()) SWIG_fail;
19218 }
19219 resultobj = SWIG_Py_Void();
19220 return resultobj;
19221 fail:
19222 return NULL;
19223 }
19224
19225
19226 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19227 PyObject *resultobj = 0;
19228 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19229 wxEvent *result = 0 ;
19230 void *argp1 = 0 ;
19231 int res1 = 0 ;
19232 PyObject *swig_obj[1] ;
19233
19234 if (!args) SWIG_fail;
19235 swig_obj[0] = args;
19236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19237 if (!SWIG_IsOK(res1)) {
19238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19239 }
19240 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19241 {
19242 PyThreadState* __tstate = wxPyBeginAllowThreads();
19243 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19244 wxPyEndAllowThreads(__tstate);
19245 if (PyErr_Occurred()) SWIG_fail;
19246 }
19247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19248 return resultobj;
19249 fail:
19250 return NULL;
19251 }
19252
19253
19254 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19255 PyObject *obj;
19256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19257 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19258 return SWIG_Py_Void();
19259 }
19260
19261 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19262 return SWIG_Python_InitShadowInstance(args);
19263 }
19264
19265 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19266 PyObject *resultobj = 0;
19267 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19268 int arg2 = (int) 0 ;
19269 wxNotifyEvent *result = 0 ;
19270 int val1 ;
19271 int ecode1 = 0 ;
19272 int val2 ;
19273 int ecode2 = 0 ;
19274 PyObject * obj0 = 0 ;
19275 PyObject * obj1 = 0 ;
19276 char * kwnames[] = {
19277 (char *) "commandType",(char *) "winid", NULL
19278 };
19279
19280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19281 if (obj0) {
19282 ecode1 = SWIG_AsVal_int(obj0, &val1);
19283 if (!SWIG_IsOK(ecode1)) {
19284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19285 }
19286 arg1 = static_cast< wxEventType >(val1);
19287 }
19288 if (obj1) {
19289 ecode2 = SWIG_AsVal_int(obj1, &val2);
19290 if (!SWIG_IsOK(ecode2)) {
19291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19292 }
19293 arg2 = static_cast< int >(val2);
19294 }
19295 {
19296 PyThreadState* __tstate = wxPyBeginAllowThreads();
19297 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19298 wxPyEndAllowThreads(__tstate);
19299 if (PyErr_Occurred()) SWIG_fail;
19300 }
19301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19302 return resultobj;
19303 fail:
19304 return NULL;
19305 }
19306
19307
19308 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19309 PyObject *resultobj = 0;
19310 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19311 void *argp1 = 0 ;
19312 int res1 = 0 ;
19313 PyObject *swig_obj[1] ;
19314
19315 if (!args) SWIG_fail;
19316 swig_obj[0] = args;
19317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19318 if (!SWIG_IsOK(res1)) {
19319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19320 }
19321 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19322 {
19323 PyThreadState* __tstate = wxPyBeginAllowThreads();
19324 (arg1)->Veto();
19325 wxPyEndAllowThreads(__tstate);
19326 if (PyErr_Occurred()) SWIG_fail;
19327 }
19328 resultobj = SWIG_Py_Void();
19329 return resultobj;
19330 fail:
19331 return NULL;
19332 }
19333
19334
19335 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19336 PyObject *resultobj = 0;
19337 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19338 void *argp1 = 0 ;
19339 int res1 = 0 ;
19340 PyObject *swig_obj[1] ;
19341
19342 if (!args) SWIG_fail;
19343 swig_obj[0] = args;
19344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19345 if (!SWIG_IsOK(res1)) {
19346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19347 }
19348 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19349 {
19350 PyThreadState* __tstate = wxPyBeginAllowThreads();
19351 (arg1)->Allow();
19352 wxPyEndAllowThreads(__tstate);
19353 if (PyErr_Occurred()) SWIG_fail;
19354 }
19355 resultobj = SWIG_Py_Void();
19356 return resultobj;
19357 fail:
19358 return NULL;
19359 }
19360
19361
19362 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19363 PyObject *resultobj = 0;
19364 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19365 bool result;
19366 void *argp1 = 0 ;
19367 int res1 = 0 ;
19368 PyObject *swig_obj[1] ;
19369
19370 if (!args) SWIG_fail;
19371 swig_obj[0] = args;
19372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19373 if (!SWIG_IsOK(res1)) {
19374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19375 }
19376 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19377 {
19378 PyThreadState* __tstate = wxPyBeginAllowThreads();
19379 result = (bool)(arg1)->IsAllowed();
19380 wxPyEndAllowThreads(__tstate);
19381 if (PyErr_Occurred()) SWIG_fail;
19382 }
19383 {
19384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19385 }
19386 return resultobj;
19387 fail:
19388 return NULL;
19389 }
19390
19391
19392 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19393 PyObject *obj;
19394 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19395 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19396 return SWIG_Py_Void();
19397 }
19398
19399 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19400 return SWIG_Python_InitShadowInstance(args);
19401 }
19402
19403 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19404 PyObject *resultobj = 0;
19405 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19406 int arg2 = (int) 0 ;
19407 int arg3 = (int) 0 ;
19408 int arg4 = (int) 0 ;
19409 wxScrollEvent *result = 0 ;
19410 int val1 ;
19411 int ecode1 = 0 ;
19412 int val2 ;
19413 int ecode2 = 0 ;
19414 int val3 ;
19415 int ecode3 = 0 ;
19416 int val4 ;
19417 int ecode4 = 0 ;
19418 PyObject * obj0 = 0 ;
19419 PyObject * obj1 = 0 ;
19420 PyObject * obj2 = 0 ;
19421 PyObject * obj3 = 0 ;
19422 char * kwnames[] = {
19423 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19424 };
19425
19426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19427 if (obj0) {
19428 ecode1 = SWIG_AsVal_int(obj0, &val1);
19429 if (!SWIG_IsOK(ecode1)) {
19430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19431 }
19432 arg1 = static_cast< wxEventType >(val1);
19433 }
19434 if (obj1) {
19435 ecode2 = SWIG_AsVal_int(obj1, &val2);
19436 if (!SWIG_IsOK(ecode2)) {
19437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19438 }
19439 arg2 = static_cast< int >(val2);
19440 }
19441 if (obj2) {
19442 ecode3 = SWIG_AsVal_int(obj2, &val3);
19443 if (!SWIG_IsOK(ecode3)) {
19444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19445 }
19446 arg3 = static_cast< int >(val3);
19447 }
19448 if (obj3) {
19449 ecode4 = SWIG_AsVal_int(obj3, &val4);
19450 if (!SWIG_IsOK(ecode4)) {
19451 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19452 }
19453 arg4 = static_cast< int >(val4);
19454 }
19455 {
19456 PyThreadState* __tstate = wxPyBeginAllowThreads();
19457 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19458 wxPyEndAllowThreads(__tstate);
19459 if (PyErr_Occurred()) SWIG_fail;
19460 }
19461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19462 return resultobj;
19463 fail:
19464 return NULL;
19465 }
19466
19467
19468 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19469 PyObject *resultobj = 0;
19470 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19471 int result;
19472 void *argp1 = 0 ;
19473 int res1 = 0 ;
19474 PyObject *swig_obj[1] ;
19475
19476 if (!args) SWIG_fail;
19477 swig_obj[0] = args;
19478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19479 if (!SWIG_IsOK(res1)) {
19480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19481 }
19482 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19483 {
19484 PyThreadState* __tstate = wxPyBeginAllowThreads();
19485 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19486 wxPyEndAllowThreads(__tstate);
19487 if (PyErr_Occurred()) SWIG_fail;
19488 }
19489 resultobj = SWIG_From_int(static_cast< int >(result));
19490 return resultobj;
19491 fail:
19492 return NULL;
19493 }
19494
19495
19496 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19497 PyObject *resultobj = 0;
19498 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19499 int result;
19500 void *argp1 = 0 ;
19501 int res1 = 0 ;
19502 PyObject *swig_obj[1] ;
19503
19504 if (!args) SWIG_fail;
19505 swig_obj[0] = args;
19506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19507 if (!SWIG_IsOK(res1)) {
19508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19509 }
19510 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19511 {
19512 PyThreadState* __tstate = wxPyBeginAllowThreads();
19513 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19514 wxPyEndAllowThreads(__tstate);
19515 if (PyErr_Occurred()) SWIG_fail;
19516 }
19517 resultobj = SWIG_From_int(static_cast< int >(result));
19518 return resultobj;
19519 fail:
19520 return NULL;
19521 }
19522
19523
19524 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19525 PyObject *resultobj = 0;
19526 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19527 int arg2 ;
19528 void *argp1 = 0 ;
19529 int res1 = 0 ;
19530 int val2 ;
19531 int ecode2 = 0 ;
19532 PyObject * obj0 = 0 ;
19533 PyObject * obj1 = 0 ;
19534 char * kwnames[] = {
19535 (char *) "self",(char *) "orient", NULL
19536 };
19537
19538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19540 if (!SWIG_IsOK(res1)) {
19541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19542 }
19543 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19544 ecode2 = SWIG_AsVal_int(obj1, &val2);
19545 if (!SWIG_IsOK(ecode2)) {
19546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19547 }
19548 arg2 = static_cast< int >(val2);
19549 {
19550 PyThreadState* __tstate = wxPyBeginAllowThreads();
19551 (arg1)->SetOrientation(arg2);
19552 wxPyEndAllowThreads(__tstate);
19553 if (PyErr_Occurred()) SWIG_fail;
19554 }
19555 resultobj = SWIG_Py_Void();
19556 return resultobj;
19557 fail:
19558 return NULL;
19559 }
19560
19561
19562 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19563 PyObject *resultobj = 0;
19564 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19565 int arg2 ;
19566 void *argp1 = 0 ;
19567 int res1 = 0 ;
19568 int val2 ;
19569 int ecode2 = 0 ;
19570 PyObject * obj0 = 0 ;
19571 PyObject * obj1 = 0 ;
19572 char * kwnames[] = {
19573 (char *) "self",(char *) "pos", NULL
19574 };
19575
19576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19578 if (!SWIG_IsOK(res1)) {
19579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19580 }
19581 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19582 ecode2 = SWIG_AsVal_int(obj1, &val2);
19583 if (!SWIG_IsOK(ecode2)) {
19584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19585 }
19586 arg2 = static_cast< int >(val2);
19587 {
19588 PyThreadState* __tstate = wxPyBeginAllowThreads();
19589 (arg1)->SetPosition(arg2);
19590 wxPyEndAllowThreads(__tstate);
19591 if (PyErr_Occurred()) SWIG_fail;
19592 }
19593 resultobj = SWIG_Py_Void();
19594 return resultobj;
19595 fail:
19596 return NULL;
19597 }
19598
19599
19600 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19601 PyObject *obj;
19602 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19603 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19604 return SWIG_Py_Void();
19605 }
19606
19607 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19608 return SWIG_Python_InitShadowInstance(args);
19609 }
19610
19611 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19612 PyObject *resultobj = 0;
19613 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19614 int arg2 = (int) 0 ;
19615 int arg3 = (int) 0 ;
19616 wxScrollWinEvent *result = 0 ;
19617 int val1 ;
19618 int ecode1 = 0 ;
19619 int val2 ;
19620 int ecode2 = 0 ;
19621 int val3 ;
19622 int ecode3 = 0 ;
19623 PyObject * obj0 = 0 ;
19624 PyObject * obj1 = 0 ;
19625 PyObject * obj2 = 0 ;
19626 char * kwnames[] = {
19627 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19628 };
19629
19630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19631 if (obj0) {
19632 ecode1 = SWIG_AsVal_int(obj0, &val1);
19633 if (!SWIG_IsOK(ecode1)) {
19634 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19635 }
19636 arg1 = static_cast< wxEventType >(val1);
19637 }
19638 if (obj1) {
19639 ecode2 = SWIG_AsVal_int(obj1, &val2);
19640 if (!SWIG_IsOK(ecode2)) {
19641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19642 }
19643 arg2 = static_cast< int >(val2);
19644 }
19645 if (obj2) {
19646 ecode3 = SWIG_AsVal_int(obj2, &val3);
19647 if (!SWIG_IsOK(ecode3)) {
19648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19649 }
19650 arg3 = static_cast< int >(val3);
19651 }
19652 {
19653 PyThreadState* __tstate = wxPyBeginAllowThreads();
19654 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19655 wxPyEndAllowThreads(__tstate);
19656 if (PyErr_Occurred()) SWIG_fail;
19657 }
19658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19659 return resultobj;
19660 fail:
19661 return NULL;
19662 }
19663
19664
19665 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19666 PyObject *resultobj = 0;
19667 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19668 int result;
19669 void *argp1 = 0 ;
19670 int res1 = 0 ;
19671 PyObject *swig_obj[1] ;
19672
19673 if (!args) SWIG_fail;
19674 swig_obj[0] = args;
19675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19676 if (!SWIG_IsOK(res1)) {
19677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19678 }
19679 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19680 {
19681 PyThreadState* __tstate = wxPyBeginAllowThreads();
19682 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19683 wxPyEndAllowThreads(__tstate);
19684 if (PyErr_Occurred()) SWIG_fail;
19685 }
19686 resultobj = SWIG_From_int(static_cast< int >(result));
19687 return resultobj;
19688 fail:
19689 return NULL;
19690 }
19691
19692
19693 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19694 PyObject *resultobj = 0;
19695 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19696 int result;
19697 void *argp1 = 0 ;
19698 int res1 = 0 ;
19699 PyObject *swig_obj[1] ;
19700
19701 if (!args) SWIG_fail;
19702 swig_obj[0] = args;
19703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19704 if (!SWIG_IsOK(res1)) {
19705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19706 }
19707 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19708 {
19709 PyThreadState* __tstate = wxPyBeginAllowThreads();
19710 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19711 wxPyEndAllowThreads(__tstate);
19712 if (PyErr_Occurred()) SWIG_fail;
19713 }
19714 resultobj = SWIG_From_int(static_cast< int >(result));
19715 return resultobj;
19716 fail:
19717 return NULL;
19718 }
19719
19720
19721 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19722 PyObject *resultobj = 0;
19723 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19724 int arg2 ;
19725 void *argp1 = 0 ;
19726 int res1 = 0 ;
19727 int val2 ;
19728 int ecode2 = 0 ;
19729 PyObject * obj0 = 0 ;
19730 PyObject * obj1 = 0 ;
19731 char * kwnames[] = {
19732 (char *) "self",(char *) "orient", NULL
19733 };
19734
19735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19737 if (!SWIG_IsOK(res1)) {
19738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19739 }
19740 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19741 ecode2 = SWIG_AsVal_int(obj1, &val2);
19742 if (!SWIG_IsOK(ecode2)) {
19743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19744 }
19745 arg2 = static_cast< int >(val2);
19746 {
19747 PyThreadState* __tstate = wxPyBeginAllowThreads();
19748 (arg1)->SetOrientation(arg2);
19749 wxPyEndAllowThreads(__tstate);
19750 if (PyErr_Occurred()) SWIG_fail;
19751 }
19752 resultobj = SWIG_Py_Void();
19753 return resultobj;
19754 fail:
19755 return NULL;
19756 }
19757
19758
19759 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19760 PyObject *resultobj = 0;
19761 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19762 int arg2 ;
19763 void *argp1 = 0 ;
19764 int res1 = 0 ;
19765 int val2 ;
19766 int ecode2 = 0 ;
19767 PyObject * obj0 = 0 ;
19768 PyObject * obj1 = 0 ;
19769 char * kwnames[] = {
19770 (char *) "self",(char *) "pos", NULL
19771 };
19772
19773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19775 if (!SWIG_IsOK(res1)) {
19776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19777 }
19778 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19779 ecode2 = SWIG_AsVal_int(obj1, &val2);
19780 if (!SWIG_IsOK(ecode2)) {
19781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19782 }
19783 arg2 = static_cast< int >(val2);
19784 {
19785 PyThreadState* __tstate = wxPyBeginAllowThreads();
19786 (arg1)->SetPosition(arg2);
19787 wxPyEndAllowThreads(__tstate);
19788 if (PyErr_Occurred()) SWIG_fail;
19789 }
19790 resultobj = SWIG_Py_Void();
19791 return resultobj;
19792 fail:
19793 return NULL;
19794 }
19795
19796
19797 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19798 PyObject *obj;
19799 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19800 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19801 return SWIG_Py_Void();
19802 }
19803
19804 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19805 return SWIG_Python_InitShadowInstance(args);
19806 }
19807
19808 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19809 PyObject *resultobj = 0;
19810 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19811 wxMouseEvent *result = 0 ;
19812 int val1 ;
19813 int ecode1 = 0 ;
19814 PyObject * obj0 = 0 ;
19815 char * kwnames[] = {
19816 (char *) "mouseType", NULL
19817 };
19818
19819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19820 if (obj0) {
19821 ecode1 = SWIG_AsVal_int(obj0, &val1);
19822 if (!SWIG_IsOK(ecode1)) {
19823 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19824 }
19825 arg1 = static_cast< wxEventType >(val1);
19826 }
19827 {
19828 PyThreadState* __tstate = wxPyBeginAllowThreads();
19829 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19830 wxPyEndAllowThreads(__tstate);
19831 if (PyErr_Occurred()) SWIG_fail;
19832 }
19833 {
19834 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19835 }
19836 return resultobj;
19837 fail:
19838 return NULL;
19839 }
19840
19841
19842 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19843 PyObject *resultobj = 0;
19844 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19845 bool result;
19846 void *argp1 = 0 ;
19847 int res1 = 0 ;
19848 PyObject *swig_obj[1] ;
19849
19850 if (!args) SWIG_fail;
19851 swig_obj[0] = args;
19852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19853 if (!SWIG_IsOK(res1)) {
19854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19855 }
19856 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19857 {
19858 PyThreadState* __tstate = wxPyBeginAllowThreads();
19859 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19860 wxPyEndAllowThreads(__tstate);
19861 if (PyErr_Occurred()) SWIG_fail;
19862 }
19863 {
19864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19865 }
19866 return resultobj;
19867 fail:
19868 return NULL;
19869 }
19870
19871
19872 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19873 PyObject *resultobj = 0;
19874 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19875 int arg2 = (int) wxMOUSE_BTN_ANY ;
19876 bool result;
19877 void *argp1 = 0 ;
19878 int res1 = 0 ;
19879 int val2 ;
19880 int ecode2 = 0 ;
19881 PyObject * obj0 = 0 ;
19882 PyObject * obj1 = 0 ;
19883 char * kwnames[] = {
19884 (char *) "self",(char *) "but", NULL
19885 };
19886
19887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19889 if (!SWIG_IsOK(res1)) {
19890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19891 }
19892 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19893 if (obj1) {
19894 ecode2 = SWIG_AsVal_int(obj1, &val2);
19895 if (!SWIG_IsOK(ecode2)) {
19896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19897 }
19898 arg2 = static_cast< int >(val2);
19899 }
19900 {
19901 PyThreadState* __tstate = wxPyBeginAllowThreads();
19902 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19903 wxPyEndAllowThreads(__tstate);
19904 if (PyErr_Occurred()) SWIG_fail;
19905 }
19906 {
19907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19908 }
19909 return resultobj;
19910 fail:
19911 return NULL;
19912 }
19913
19914
19915 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19916 PyObject *resultobj = 0;
19917 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19918 int arg2 = (int) wxMOUSE_BTN_ANY ;
19919 bool result;
19920 void *argp1 = 0 ;
19921 int res1 = 0 ;
19922 int val2 ;
19923 int ecode2 = 0 ;
19924 PyObject * obj0 = 0 ;
19925 PyObject * obj1 = 0 ;
19926 char * kwnames[] = {
19927 (char *) "self",(char *) "but", NULL
19928 };
19929
19930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19932 if (!SWIG_IsOK(res1)) {
19933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19934 }
19935 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19936 if (obj1) {
19937 ecode2 = SWIG_AsVal_int(obj1, &val2);
19938 if (!SWIG_IsOK(ecode2)) {
19939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19940 }
19941 arg2 = static_cast< int >(val2);
19942 }
19943 {
19944 PyThreadState* __tstate = wxPyBeginAllowThreads();
19945 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19946 wxPyEndAllowThreads(__tstate);
19947 if (PyErr_Occurred()) SWIG_fail;
19948 }
19949 {
19950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19951 }
19952 return resultobj;
19953 fail:
19954 return NULL;
19955 }
19956
19957
19958 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19959 PyObject *resultobj = 0;
19960 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19961 int arg2 = (int) wxMOUSE_BTN_ANY ;
19962 bool result;
19963 void *argp1 = 0 ;
19964 int res1 = 0 ;
19965 int val2 ;
19966 int ecode2 = 0 ;
19967 PyObject * obj0 = 0 ;
19968 PyObject * obj1 = 0 ;
19969 char * kwnames[] = {
19970 (char *) "self",(char *) "but", NULL
19971 };
19972
19973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19975 if (!SWIG_IsOK(res1)) {
19976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19977 }
19978 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19979 if (obj1) {
19980 ecode2 = SWIG_AsVal_int(obj1, &val2);
19981 if (!SWIG_IsOK(ecode2)) {
19982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19983 }
19984 arg2 = static_cast< int >(val2);
19985 }
19986 {
19987 PyThreadState* __tstate = wxPyBeginAllowThreads();
19988 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19989 wxPyEndAllowThreads(__tstate);
19990 if (PyErr_Occurred()) SWIG_fail;
19991 }
19992 {
19993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19994 }
19995 return resultobj;
19996 fail:
19997 return NULL;
19998 }
19999
20000
20001 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20002 PyObject *resultobj = 0;
20003 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20004 int arg2 ;
20005 bool result;
20006 void *argp1 = 0 ;
20007 int res1 = 0 ;
20008 int val2 ;
20009 int ecode2 = 0 ;
20010 PyObject * obj0 = 0 ;
20011 PyObject * obj1 = 0 ;
20012 char * kwnames[] = {
20013 (char *) "self",(char *) "button", NULL
20014 };
20015
20016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20018 if (!SWIG_IsOK(res1)) {
20019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20020 }
20021 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20022 ecode2 = SWIG_AsVal_int(obj1, &val2);
20023 if (!SWIG_IsOK(ecode2)) {
20024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20025 }
20026 arg2 = static_cast< int >(val2);
20027 {
20028 PyThreadState* __tstate = wxPyBeginAllowThreads();
20029 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20030 wxPyEndAllowThreads(__tstate);
20031 if (PyErr_Occurred()) SWIG_fail;
20032 }
20033 {
20034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20035 }
20036 return resultobj;
20037 fail:
20038 return NULL;
20039 }
20040
20041
20042 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20043 PyObject *resultobj = 0;
20044 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20045 int arg2 ;
20046 bool result;
20047 void *argp1 = 0 ;
20048 int res1 = 0 ;
20049 int val2 ;
20050 int ecode2 = 0 ;
20051 PyObject * obj0 = 0 ;
20052 PyObject * obj1 = 0 ;
20053 char * kwnames[] = {
20054 (char *) "self",(char *) "but", NULL
20055 };
20056
20057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20059 if (!SWIG_IsOK(res1)) {
20060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20061 }
20062 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20063 ecode2 = SWIG_AsVal_int(obj1, &val2);
20064 if (!SWIG_IsOK(ecode2)) {
20065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20066 }
20067 arg2 = static_cast< int >(val2);
20068 {
20069 PyThreadState* __tstate = wxPyBeginAllowThreads();
20070 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20071 wxPyEndAllowThreads(__tstate);
20072 if (PyErr_Occurred()) SWIG_fail;
20073 }
20074 {
20075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20076 }
20077 return resultobj;
20078 fail:
20079 return NULL;
20080 }
20081
20082
20083 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20084 PyObject *resultobj = 0;
20085 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20086 int result;
20087 void *argp1 = 0 ;
20088 int res1 = 0 ;
20089 PyObject *swig_obj[1] ;
20090
20091 if (!args) SWIG_fail;
20092 swig_obj[0] = args;
20093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20094 if (!SWIG_IsOK(res1)) {
20095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20096 }
20097 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20098 {
20099 PyThreadState* __tstate = wxPyBeginAllowThreads();
20100 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20101 wxPyEndAllowThreads(__tstate);
20102 if (PyErr_Occurred()) SWIG_fail;
20103 }
20104 resultobj = SWIG_From_int(static_cast< int >(result));
20105 return resultobj;
20106 fail:
20107 return NULL;
20108 }
20109
20110
20111 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20112 PyObject *resultobj = 0;
20113 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20114 bool result;
20115 void *argp1 = 0 ;
20116 int res1 = 0 ;
20117 PyObject *swig_obj[1] ;
20118
20119 if (!args) SWIG_fail;
20120 swig_obj[0] = args;
20121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20122 if (!SWIG_IsOK(res1)) {
20123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20124 }
20125 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20126 {
20127 PyThreadState* __tstate = wxPyBeginAllowThreads();
20128 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20129 wxPyEndAllowThreads(__tstate);
20130 if (PyErr_Occurred()) SWIG_fail;
20131 }
20132 {
20133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20134 }
20135 return resultobj;
20136 fail:
20137 return NULL;
20138 }
20139
20140
20141 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20142 PyObject *resultobj = 0;
20143 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20144 bool result;
20145 void *argp1 = 0 ;
20146 int res1 = 0 ;
20147 PyObject *swig_obj[1] ;
20148
20149 if (!args) SWIG_fail;
20150 swig_obj[0] = args;
20151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20152 if (!SWIG_IsOK(res1)) {
20153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20154 }
20155 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20156 {
20157 PyThreadState* __tstate = wxPyBeginAllowThreads();
20158 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20159 wxPyEndAllowThreads(__tstate);
20160 if (PyErr_Occurred()) SWIG_fail;
20161 }
20162 {
20163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20164 }
20165 return resultobj;
20166 fail:
20167 return NULL;
20168 }
20169
20170
20171 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20172 PyObject *resultobj = 0;
20173 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20174 bool result;
20175 void *argp1 = 0 ;
20176 int res1 = 0 ;
20177 PyObject *swig_obj[1] ;
20178
20179 if (!args) SWIG_fail;
20180 swig_obj[0] = args;
20181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20182 if (!SWIG_IsOK(res1)) {
20183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20184 }
20185 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20186 {
20187 PyThreadState* __tstate = wxPyBeginAllowThreads();
20188 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20189 wxPyEndAllowThreads(__tstate);
20190 if (PyErr_Occurred()) SWIG_fail;
20191 }
20192 {
20193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20194 }
20195 return resultobj;
20196 fail:
20197 return NULL;
20198 }
20199
20200
20201 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20202 PyObject *resultobj = 0;
20203 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20204 bool result;
20205 void *argp1 = 0 ;
20206 int res1 = 0 ;
20207 PyObject *swig_obj[1] ;
20208
20209 if (!args) SWIG_fail;
20210 swig_obj[0] = args;
20211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20212 if (!SWIG_IsOK(res1)) {
20213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20214 }
20215 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20216 {
20217 PyThreadState* __tstate = wxPyBeginAllowThreads();
20218 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20219 wxPyEndAllowThreads(__tstate);
20220 if (PyErr_Occurred()) SWIG_fail;
20221 }
20222 {
20223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20224 }
20225 return resultobj;
20226 fail:
20227 return NULL;
20228 }
20229
20230
20231 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20232 PyObject *resultobj = 0;
20233 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20234 bool result;
20235 void *argp1 = 0 ;
20236 int res1 = 0 ;
20237 PyObject *swig_obj[1] ;
20238
20239 if (!args) SWIG_fail;
20240 swig_obj[0] = args;
20241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20242 if (!SWIG_IsOK(res1)) {
20243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20244 }
20245 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20246 {
20247 PyThreadState* __tstate = wxPyBeginAllowThreads();
20248 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20249 wxPyEndAllowThreads(__tstate);
20250 if (PyErr_Occurred()) SWIG_fail;
20251 }
20252 {
20253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20254 }
20255 return resultobj;
20256 fail:
20257 return NULL;
20258 }
20259
20260
20261 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20262 PyObject *resultobj = 0;
20263 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20264 bool result;
20265 void *argp1 = 0 ;
20266 int res1 = 0 ;
20267 PyObject *swig_obj[1] ;
20268
20269 if (!args) SWIG_fail;
20270 swig_obj[0] = args;
20271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20272 if (!SWIG_IsOK(res1)) {
20273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20274 }
20275 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20276 {
20277 PyThreadState* __tstate = wxPyBeginAllowThreads();
20278 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20279 wxPyEndAllowThreads(__tstate);
20280 if (PyErr_Occurred()) SWIG_fail;
20281 }
20282 {
20283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20284 }
20285 return resultobj;
20286 fail:
20287 return NULL;
20288 }
20289
20290
20291 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20292 PyObject *resultobj = 0;
20293 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20294 bool result;
20295 void *argp1 = 0 ;
20296 int res1 = 0 ;
20297 PyObject *swig_obj[1] ;
20298
20299 if (!args) SWIG_fail;
20300 swig_obj[0] = args;
20301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20302 if (!SWIG_IsOK(res1)) {
20303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20304 }
20305 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20306 {
20307 PyThreadState* __tstate = wxPyBeginAllowThreads();
20308 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20309 wxPyEndAllowThreads(__tstate);
20310 if (PyErr_Occurred()) SWIG_fail;
20311 }
20312 {
20313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20314 }
20315 return resultobj;
20316 fail:
20317 return NULL;
20318 }
20319
20320
20321 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20322 PyObject *resultobj = 0;
20323 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20324 bool result;
20325 void *argp1 = 0 ;
20326 int res1 = 0 ;
20327 PyObject *swig_obj[1] ;
20328
20329 if (!args) SWIG_fail;
20330 swig_obj[0] = args;
20331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20332 if (!SWIG_IsOK(res1)) {
20333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20334 }
20335 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20336 {
20337 PyThreadState* __tstate = wxPyBeginAllowThreads();
20338 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20339 wxPyEndAllowThreads(__tstate);
20340 if (PyErr_Occurred()) SWIG_fail;
20341 }
20342 {
20343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20344 }
20345 return resultobj;
20346 fail:
20347 return NULL;
20348 }
20349
20350
20351 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20352 PyObject *resultobj = 0;
20353 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20354 bool result;
20355 void *argp1 = 0 ;
20356 int res1 = 0 ;
20357 PyObject *swig_obj[1] ;
20358
20359 if (!args) SWIG_fail;
20360 swig_obj[0] = args;
20361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20362 if (!SWIG_IsOK(res1)) {
20363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20364 }
20365 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20366 {
20367 PyThreadState* __tstate = wxPyBeginAllowThreads();
20368 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20369 wxPyEndAllowThreads(__tstate);
20370 if (PyErr_Occurred()) SWIG_fail;
20371 }
20372 {
20373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20374 }
20375 return resultobj;
20376 fail:
20377 return NULL;
20378 }
20379
20380
20381 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20382 PyObject *resultobj = 0;
20383 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20384 bool result;
20385 void *argp1 = 0 ;
20386 int res1 = 0 ;
20387 PyObject *swig_obj[1] ;
20388
20389 if (!args) SWIG_fail;
20390 swig_obj[0] = args;
20391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20392 if (!SWIG_IsOK(res1)) {
20393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20394 }
20395 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20396 {
20397 PyThreadState* __tstate = wxPyBeginAllowThreads();
20398 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20399 wxPyEndAllowThreads(__tstate);
20400 if (PyErr_Occurred()) SWIG_fail;
20401 }
20402 {
20403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20404 }
20405 return resultobj;
20406 fail:
20407 return NULL;
20408 }
20409
20410
20411 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20412 PyObject *resultobj = 0;
20413 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20414 bool result;
20415 void *argp1 = 0 ;
20416 int res1 = 0 ;
20417 PyObject *swig_obj[1] ;
20418
20419 if (!args) SWIG_fail;
20420 swig_obj[0] = args;
20421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20422 if (!SWIG_IsOK(res1)) {
20423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20424 }
20425 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20426 {
20427 PyThreadState* __tstate = wxPyBeginAllowThreads();
20428 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20429 wxPyEndAllowThreads(__tstate);
20430 if (PyErr_Occurred()) SWIG_fail;
20431 }
20432 {
20433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20434 }
20435 return resultobj;
20436 fail:
20437 return NULL;
20438 }
20439
20440
20441 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20442 PyObject *resultobj = 0;
20443 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20444 bool result;
20445 void *argp1 = 0 ;
20446 int res1 = 0 ;
20447 PyObject *swig_obj[1] ;
20448
20449 if (!args) SWIG_fail;
20450 swig_obj[0] = args;
20451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20452 if (!SWIG_IsOK(res1)) {
20453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20454 }
20455 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20456 {
20457 PyThreadState* __tstate = wxPyBeginAllowThreads();
20458 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20459 wxPyEndAllowThreads(__tstate);
20460 if (PyErr_Occurred()) SWIG_fail;
20461 }
20462 {
20463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20464 }
20465 return resultobj;
20466 fail:
20467 return NULL;
20468 }
20469
20470
20471 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20472 PyObject *resultobj = 0;
20473 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20474 bool result;
20475 void *argp1 = 0 ;
20476 int res1 = 0 ;
20477 PyObject *swig_obj[1] ;
20478
20479 if (!args) SWIG_fail;
20480 swig_obj[0] = args;
20481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20482 if (!SWIG_IsOK(res1)) {
20483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20484 }
20485 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20486 {
20487 PyThreadState* __tstate = wxPyBeginAllowThreads();
20488 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20489 wxPyEndAllowThreads(__tstate);
20490 if (PyErr_Occurred()) SWIG_fail;
20491 }
20492 {
20493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20494 }
20495 return resultobj;
20496 fail:
20497 return NULL;
20498 }
20499
20500
20501 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20502 PyObject *resultobj = 0;
20503 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20504 bool result;
20505 void *argp1 = 0 ;
20506 int res1 = 0 ;
20507 PyObject *swig_obj[1] ;
20508
20509 if (!args) SWIG_fail;
20510 swig_obj[0] = args;
20511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20512 if (!SWIG_IsOK(res1)) {
20513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20514 }
20515 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20516 {
20517 PyThreadState* __tstate = wxPyBeginAllowThreads();
20518 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20519 wxPyEndAllowThreads(__tstate);
20520 if (PyErr_Occurred()) SWIG_fail;
20521 }
20522 {
20523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20524 }
20525 return resultobj;
20526 fail:
20527 return NULL;
20528 }
20529
20530
20531 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20532 PyObject *resultobj = 0;
20533 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20534 bool result;
20535 void *argp1 = 0 ;
20536 int res1 = 0 ;
20537 PyObject *swig_obj[1] ;
20538
20539 if (!args) SWIG_fail;
20540 swig_obj[0] = args;
20541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20542 if (!SWIG_IsOK(res1)) {
20543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20544 }
20545 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20546 {
20547 PyThreadState* __tstate = wxPyBeginAllowThreads();
20548 result = (bool)(arg1)->LeftIsDown();
20549 wxPyEndAllowThreads(__tstate);
20550 if (PyErr_Occurred()) SWIG_fail;
20551 }
20552 {
20553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20554 }
20555 return resultobj;
20556 fail:
20557 return NULL;
20558 }
20559
20560
20561 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20562 PyObject *resultobj = 0;
20563 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20564 bool result;
20565 void *argp1 = 0 ;
20566 int res1 = 0 ;
20567 PyObject *swig_obj[1] ;
20568
20569 if (!args) SWIG_fail;
20570 swig_obj[0] = args;
20571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20572 if (!SWIG_IsOK(res1)) {
20573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20574 }
20575 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20576 {
20577 PyThreadState* __tstate = wxPyBeginAllowThreads();
20578 result = (bool)(arg1)->MiddleIsDown();
20579 wxPyEndAllowThreads(__tstate);
20580 if (PyErr_Occurred()) SWIG_fail;
20581 }
20582 {
20583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20584 }
20585 return resultobj;
20586 fail:
20587 return NULL;
20588 }
20589
20590
20591 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20592 PyObject *resultobj = 0;
20593 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20594 bool result;
20595 void *argp1 = 0 ;
20596 int res1 = 0 ;
20597 PyObject *swig_obj[1] ;
20598
20599 if (!args) SWIG_fail;
20600 swig_obj[0] = args;
20601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20602 if (!SWIG_IsOK(res1)) {
20603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20604 }
20605 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20606 {
20607 PyThreadState* __tstate = wxPyBeginAllowThreads();
20608 result = (bool)(arg1)->RightIsDown();
20609 wxPyEndAllowThreads(__tstate);
20610 if (PyErr_Occurred()) SWIG_fail;
20611 }
20612 {
20613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20614 }
20615 return resultobj;
20616 fail:
20617 return NULL;
20618 }
20619
20620
20621 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20622 PyObject *resultobj = 0;
20623 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20624 bool result;
20625 void *argp1 = 0 ;
20626 int res1 = 0 ;
20627 PyObject *swig_obj[1] ;
20628
20629 if (!args) SWIG_fail;
20630 swig_obj[0] = args;
20631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20632 if (!SWIG_IsOK(res1)) {
20633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20634 }
20635 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20636 {
20637 PyThreadState* __tstate = wxPyBeginAllowThreads();
20638 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20639 wxPyEndAllowThreads(__tstate);
20640 if (PyErr_Occurred()) SWIG_fail;
20641 }
20642 {
20643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20644 }
20645 return resultobj;
20646 fail:
20647 return NULL;
20648 }
20649
20650
20651 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20652 PyObject *resultobj = 0;
20653 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20654 bool result;
20655 void *argp1 = 0 ;
20656 int res1 = 0 ;
20657 PyObject *swig_obj[1] ;
20658
20659 if (!args) SWIG_fail;
20660 swig_obj[0] = args;
20661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20662 if (!SWIG_IsOK(res1)) {
20663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20664 }
20665 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20666 {
20667 PyThreadState* __tstate = wxPyBeginAllowThreads();
20668 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20669 wxPyEndAllowThreads(__tstate);
20670 if (PyErr_Occurred()) SWIG_fail;
20671 }
20672 {
20673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20674 }
20675 return resultobj;
20676 fail:
20677 return NULL;
20678 }
20679
20680
20681 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20682 PyObject *resultobj = 0;
20683 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20684 bool result;
20685 void *argp1 = 0 ;
20686 int res1 = 0 ;
20687 PyObject *swig_obj[1] ;
20688
20689 if (!args) SWIG_fail;
20690 swig_obj[0] = args;
20691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20692 if (!SWIG_IsOK(res1)) {
20693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20694 }
20695 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20696 {
20697 PyThreadState* __tstate = wxPyBeginAllowThreads();
20698 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20699 wxPyEndAllowThreads(__tstate);
20700 if (PyErr_Occurred()) SWIG_fail;
20701 }
20702 {
20703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20704 }
20705 return resultobj;
20706 fail:
20707 return NULL;
20708 }
20709
20710
20711 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20712 PyObject *resultobj = 0;
20713 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20714 bool result;
20715 void *argp1 = 0 ;
20716 int res1 = 0 ;
20717 PyObject *swig_obj[1] ;
20718
20719 if (!args) SWIG_fail;
20720 swig_obj[0] = args;
20721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20722 if (!SWIG_IsOK(res1)) {
20723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20724 }
20725 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20726 {
20727 PyThreadState* __tstate = wxPyBeginAllowThreads();
20728 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20729 wxPyEndAllowThreads(__tstate);
20730 if (PyErr_Occurred()) SWIG_fail;
20731 }
20732 {
20733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20734 }
20735 return resultobj;
20736 fail:
20737 return NULL;
20738 }
20739
20740
20741 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20742 PyObject *resultobj = 0;
20743 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20744 wxPoint result;
20745 void *argp1 = 0 ;
20746 int res1 = 0 ;
20747 PyObject *swig_obj[1] ;
20748
20749 if (!args) SWIG_fail;
20750 swig_obj[0] = args;
20751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20752 if (!SWIG_IsOK(res1)) {
20753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20754 }
20755 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20756 {
20757 PyThreadState* __tstate = wxPyBeginAllowThreads();
20758 result = (arg1)->GetPosition();
20759 wxPyEndAllowThreads(__tstate);
20760 if (PyErr_Occurred()) SWIG_fail;
20761 }
20762 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20763 return resultobj;
20764 fail:
20765 return NULL;
20766 }
20767
20768
20769 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20770 PyObject *resultobj = 0;
20771 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20772 long *arg2 = (long *) 0 ;
20773 long *arg3 = (long *) 0 ;
20774 void *argp1 = 0 ;
20775 int res1 = 0 ;
20776 long temp2 ;
20777 int res2 = SWIG_TMPOBJ ;
20778 long temp3 ;
20779 int res3 = SWIG_TMPOBJ ;
20780 PyObject *swig_obj[1] ;
20781
20782 arg2 = &temp2;
20783 arg3 = &temp3;
20784 if (!args) SWIG_fail;
20785 swig_obj[0] = args;
20786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20787 if (!SWIG_IsOK(res1)) {
20788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20789 }
20790 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20791 {
20792 PyThreadState* __tstate = wxPyBeginAllowThreads();
20793 (arg1)->GetPosition(arg2,arg3);
20794 wxPyEndAllowThreads(__tstate);
20795 if (PyErr_Occurred()) SWIG_fail;
20796 }
20797 resultobj = SWIG_Py_Void();
20798 if (SWIG_IsTmpObj(res2)) {
20799 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20800 } else {
20801 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20802 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20803 }
20804 if (SWIG_IsTmpObj(res3)) {
20805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20806 } else {
20807 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20808 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20809 }
20810 return resultobj;
20811 fail:
20812 return NULL;
20813 }
20814
20815
20816 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20817 PyObject *resultobj = 0;
20818 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20819 wxDC *arg2 = 0 ;
20820 wxPoint result;
20821 void *argp1 = 0 ;
20822 int res1 = 0 ;
20823 void *argp2 = 0 ;
20824 int res2 = 0 ;
20825 PyObject * obj0 = 0 ;
20826 PyObject * obj1 = 0 ;
20827 char * kwnames[] = {
20828 (char *) "self",(char *) "dc", NULL
20829 };
20830
20831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20833 if (!SWIG_IsOK(res1)) {
20834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20835 }
20836 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20837 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20838 if (!SWIG_IsOK(res2)) {
20839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20840 }
20841 if (!argp2) {
20842 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20843 }
20844 arg2 = reinterpret_cast< wxDC * >(argp2);
20845 {
20846 PyThreadState* __tstate = wxPyBeginAllowThreads();
20847 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20848 wxPyEndAllowThreads(__tstate);
20849 if (PyErr_Occurred()) SWIG_fail;
20850 }
20851 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20852 return resultobj;
20853 fail:
20854 return NULL;
20855 }
20856
20857
20858 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20859 PyObject *resultobj = 0;
20860 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20861 int result;
20862 void *argp1 = 0 ;
20863 int res1 = 0 ;
20864 PyObject *swig_obj[1] ;
20865
20866 if (!args) SWIG_fail;
20867 swig_obj[0] = args;
20868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20869 if (!SWIG_IsOK(res1)) {
20870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20871 }
20872 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20873 {
20874 PyThreadState* __tstate = wxPyBeginAllowThreads();
20875 result = (int)((wxMouseEvent const *)arg1)->GetX();
20876 wxPyEndAllowThreads(__tstate);
20877 if (PyErr_Occurred()) SWIG_fail;
20878 }
20879 resultobj = SWIG_From_int(static_cast< int >(result));
20880 return resultobj;
20881 fail:
20882 return NULL;
20883 }
20884
20885
20886 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20887 PyObject *resultobj = 0;
20888 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20889 int result;
20890 void *argp1 = 0 ;
20891 int res1 = 0 ;
20892 PyObject *swig_obj[1] ;
20893
20894 if (!args) SWIG_fail;
20895 swig_obj[0] = args;
20896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20897 if (!SWIG_IsOK(res1)) {
20898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20899 }
20900 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20901 {
20902 PyThreadState* __tstate = wxPyBeginAllowThreads();
20903 result = (int)((wxMouseEvent const *)arg1)->GetY();
20904 wxPyEndAllowThreads(__tstate);
20905 if (PyErr_Occurred()) SWIG_fail;
20906 }
20907 resultobj = SWIG_From_int(static_cast< int >(result));
20908 return resultobj;
20909 fail:
20910 return NULL;
20911 }
20912
20913
20914 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20915 PyObject *resultobj = 0;
20916 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20917 int result;
20918 void *argp1 = 0 ;
20919 int res1 = 0 ;
20920 PyObject *swig_obj[1] ;
20921
20922 if (!args) SWIG_fail;
20923 swig_obj[0] = args;
20924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20925 if (!SWIG_IsOK(res1)) {
20926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20927 }
20928 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20929 {
20930 PyThreadState* __tstate = wxPyBeginAllowThreads();
20931 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20932 wxPyEndAllowThreads(__tstate);
20933 if (PyErr_Occurred()) SWIG_fail;
20934 }
20935 resultobj = SWIG_From_int(static_cast< int >(result));
20936 return resultobj;
20937 fail:
20938 return NULL;
20939 }
20940
20941
20942 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20943 PyObject *resultobj = 0;
20944 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20945 int result;
20946 void *argp1 = 0 ;
20947 int res1 = 0 ;
20948 PyObject *swig_obj[1] ;
20949
20950 if (!args) SWIG_fail;
20951 swig_obj[0] = args;
20952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20953 if (!SWIG_IsOK(res1)) {
20954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20955 }
20956 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20957 {
20958 PyThreadState* __tstate = wxPyBeginAllowThreads();
20959 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20960 wxPyEndAllowThreads(__tstate);
20961 if (PyErr_Occurred()) SWIG_fail;
20962 }
20963 resultobj = SWIG_From_int(static_cast< int >(result));
20964 return resultobj;
20965 fail:
20966 return NULL;
20967 }
20968
20969
20970 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20971 PyObject *resultobj = 0;
20972 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20973 int result;
20974 void *argp1 = 0 ;
20975 int res1 = 0 ;
20976 PyObject *swig_obj[1] ;
20977
20978 if (!args) SWIG_fail;
20979 swig_obj[0] = args;
20980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20981 if (!SWIG_IsOK(res1)) {
20982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20983 }
20984 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20985 {
20986 PyThreadState* __tstate = wxPyBeginAllowThreads();
20987 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20988 wxPyEndAllowThreads(__tstate);
20989 if (PyErr_Occurred()) SWIG_fail;
20990 }
20991 resultobj = SWIG_From_int(static_cast< int >(result));
20992 return resultobj;
20993 fail:
20994 return NULL;
20995 }
20996
20997
20998 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20999 PyObject *resultobj = 0;
21000 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21001 bool result;
21002 void *argp1 = 0 ;
21003 int res1 = 0 ;
21004 PyObject *swig_obj[1] ;
21005
21006 if (!args) SWIG_fail;
21007 swig_obj[0] = args;
21008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21009 if (!SWIG_IsOK(res1)) {
21010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21011 }
21012 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21013 {
21014 PyThreadState* __tstate = wxPyBeginAllowThreads();
21015 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21016 wxPyEndAllowThreads(__tstate);
21017 if (PyErr_Occurred()) SWIG_fail;
21018 }
21019 {
21020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21021 }
21022 return resultobj;
21023 fail:
21024 return NULL;
21025 }
21026
21027
21028 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21029 PyObject *resultobj = 0;
21030 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21031 int arg2 ;
21032 void *argp1 = 0 ;
21033 int res1 = 0 ;
21034 int val2 ;
21035 int ecode2 = 0 ;
21036 PyObject *swig_obj[2] ;
21037
21038 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21040 if (!SWIG_IsOK(res1)) {
21041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21042 }
21043 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21044 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21045 if (!SWIG_IsOK(ecode2)) {
21046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21047 }
21048 arg2 = static_cast< int >(val2);
21049 if (arg1) (arg1)->m_x = arg2;
21050
21051 resultobj = SWIG_Py_Void();
21052 return resultobj;
21053 fail:
21054 return NULL;
21055 }
21056
21057
21058 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21059 PyObject *resultobj = 0;
21060 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21061 int result;
21062 void *argp1 = 0 ;
21063 int res1 = 0 ;
21064 PyObject *swig_obj[1] ;
21065
21066 if (!args) SWIG_fail;
21067 swig_obj[0] = args;
21068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21069 if (!SWIG_IsOK(res1)) {
21070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21071 }
21072 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21073 result = (int) ((arg1)->m_x);
21074 resultobj = SWIG_From_int(static_cast< int >(result));
21075 return resultobj;
21076 fail:
21077 return NULL;
21078 }
21079
21080
21081 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21082 PyObject *resultobj = 0;
21083 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21084 int arg2 ;
21085 void *argp1 = 0 ;
21086 int res1 = 0 ;
21087 int val2 ;
21088 int ecode2 = 0 ;
21089 PyObject *swig_obj[2] ;
21090
21091 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21093 if (!SWIG_IsOK(res1)) {
21094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21095 }
21096 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21097 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21098 if (!SWIG_IsOK(ecode2)) {
21099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21100 }
21101 arg2 = static_cast< int >(val2);
21102 if (arg1) (arg1)->m_y = arg2;
21103
21104 resultobj = SWIG_Py_Void();
21105 return resultobj;
21106 fail:
21107 return NULL;
21108 }
21109
21110
21111 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21112 PyObject *resultobj = 0;
21113 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21114 int result;
21115 void *argp1 = 0 ;
21116 int res1 = 0 ;
21117 PyObject *swig_obj[1] ;
21118
21119 if (!args) SWIG_fail;
21120 swig_obj[0] = args;
21121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21122 if (!SWIG_IsOK(res1)) {
21123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21124 }
21125 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21126 result = (int) ((arg1)->m_y);
21127 resultobj = SWIG_From_int(static_cast< int >(result));
21128 return resultobj;
21129 fail:
21130 return NULL;
21131 }
21132
21133
21134 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21135 PyObject *resultobj = 0;
21136 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21137 bool arg2 ;
21138 void *argp1 = 0 ;
21139 int res1 = 0 ;
21140 bool val2 ;
21141 int ecode2 = 0 ;
21142 PyObject *swig_obj[2] ;
21143
21144 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21146 if (!SWIG_IsOK(res1)) {
21147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21148 }
21149 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21150 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21151 if (!SWIG_IsOK(ecode2)) {
21152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21153 }
21154 arg2 = static_cast< bool >(val2);
21155 if (arg1) (arg1)->m_leftDown = arg2;
21156
21157 resultobj = SWIG_Py_Void();
21158 return resultobj;
21159 fail:
21160 return NULL;
21161 }
21162
21163
21164 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21165 PyObject *resultobj = 0;
21166 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21167 bool result;
21168 void *argp1 = 0 ;
21169 int res1 = 0 ;
21170 PyObject *swig_obj[1] ;
21171
21172 if (!args) SWIG_fail;
21173 swig_obj[0] = args;
21174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21175 if (!SWIG_IsOK(res1)) {
21176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21177 }
21178 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21179 result = (bool) ((arg1)->m_leftDown);
21180 {
21181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21182 }
21183 return resultobj;
21184 fail:
21185 return NULL;
21186 }
21187
21188
21189 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21190 PyObject *resultobj = 0;
21191 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21192 bool arg2 ;
21193 void *argp1 = 0 ;
21194 int res1 = 0 ;
21195 bool val2 ;
21196 int ecode2 = 0 ;
21197 PyObject *swig_obj[2] ;
21198
21199 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21201 if (!SWIG_IsOK(res1)) {
21202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21203 }
21204 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21205 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21206 if (!SWIG_IsOK(ecode2)) {
21207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21208 }
21209 arg2 = static_cast< bool >(val2);
21210 if (arg1) (arg1)->m_middleDown = arg2;
21211
21212 resultobj = SWIG_Py_Void();
21213 return resultobj;
21214 fail:
21215 return NULL;
21216 }
21217
21218
21219 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21220 PyObject *resultobj = 0;
21221 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21222 bool result;
21223 void *argp1 = 0 ;
21224 int res1 = 0 ;
21225 PyObject *swig_obj[1] ;
21226
21227 if (!args) SWIG_fail;
21228 swig_obj[0] = args;
21229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21230 if (!SWIG_IsOK(res1)) {
21231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21232 }
21233 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21234 result = (bool) ((arg1)->m_middleDown);
21235 {
21236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21237 }
21238 return resultobj;
21239 fail:
21240 return NULL;
21241 }
21242
21243
21244 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21245 PyObject *resultobj = 0;
21246 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21247 bool arg2 ;
21248 void *argp1 = 0 ;
21249 int res1 = 0 ;
21250 bool val2 ;
21251 int ecode2 = 0 ;
21252 PyObject *swig_obj[2] ;
21253
21254 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21256 if (!SWIG_IsOK(res1)) {
21257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21258 }
21259 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21260 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21261 if (!SWIG_IsOK(ecode2)) {
21262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21263 }
21264 arg2 = static_cast< bool >(val2);
21265 if (arg1) (arg1)->m_rightDown = arg2;
21266
21267 resultobj = SWIG_Py_Void();
21268 return resultobj;
21269 fail:
21270 return NULL;
21271 }
21272
21273
21274 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21275 PyObject *resultobj = 0;
21276 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21277 bool result;
21278 void *argp1 = 0 ;
21279 int res1 = 0 ;
21280 PyObject *swig_obj[1] ;
21281
21282 if (!args) SWIG_fail;
21283 swig_obj[0] = args;
21284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21285 if (!SWIG_IsOK(res1)) {
21286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21287 }
21288 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21289 result = (bool) ((arg1)->m_rightDown);
21290 {
21291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21292 }
21293 return resultobj;
21294 fail:
21295 return NULL;
21296 }
21297
21298
21299 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21300 PyObject *resultobj = 0;
21301 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21302 bool arg2 ;
21303 void *argp1 = 0 ;
21304 int res1 = 0 ;
21305 bool val2 ;
21306 int ecode2 = 0 ;
21307 PyObject *swig_obj[2] ;
21308
21309 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21311 if (!SWIG_IsOK(res1)) {
21312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21313 }
21314 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21315 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21316 if (!SWIG_IsOK(ecode2)) {
21317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21318 }
21319 arg2 = static_cast< bool >(val2);
21320 if (arg1) (arg1)->m_controlDown = arg2;
21321
21322 resultobj = SWIG_Py_Void();
21323 return resultobj;
21324 fail:
21325 return NULL;
21326 }
21327
21328
21329 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21330 PyObject *resultobj = 0;
21331 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21332 bool result;
21333 void *argp1 = 0 ;
21334 int res1 = 0 ;
21335 PyObject *swig_obj[1] ;
21336
21337 if (!args) SWIG_fail;
21338 swig_obj[0] = args;
21339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21340 if (!SWIG_IsOK(res1)) {
21341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21342 }
21343 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21344 result = (bool) ((arg1)->m_controlDown);
21345 {
21346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21347 }
21348 return resultobj;
21349 fail:
21350 return NULL;
21351 }
21352
21353
21354 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21355 PyObject *resultobj = 0;
21356 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21357 bool arg2 ;
21358 void *argp1 = 0 ;
21359 int res1 = 0 ;
21360 bool val2 ;
21361 int ecode2 = 0 ;
21362 PyObject *swig_obj[2] ;
21363
21364 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21366 if (!SWIG_IsOK(res1)) {
21367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21368 }
21369 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21370 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21371 if (!SWIG_IsOK(ecode2)) {
21372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21373 }
21374 arg2 = static_cast< bool >(val2);
21375 if (arg1) (arg1)->m_shiftDown = arg2;
21376
21377 resultobj = SWIG_Py_Void();
21378 return resultobj;
21379 fail:
21380 return NULL;
21381 }
21382
21383
21384 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21385 PyObject *resultobj = 0;
21386 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21387 bool result;
21388 void *argp1 = 0 ;
21389 int res1 = 0 ;
21390 PyObject *swig_obj[1] ;
21391
21392 if (!args) SWIG_fail;
21393 swig_obj[0] = args;
21394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21395 if (!SWIG_IsOK(res1)) {
21396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21397 }
21398 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21399 result = (bool) ((arg1)->m_shiftDown);
21400 {
21401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21402 }
21403 return resultobj;
21404 fail:
21405 return NULL;
21406 }
21407
21408
21409 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21410 PyObject *resultobj = 0;
21411 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21412 bool arg2 ;
21413 void *argp1 = 0 ;
21414 int res1 = 0 ;
21415 bool val2 ;
21416 int ecode2 = 0 ;
21417 PyObject *swig_obj[2] ;
21418
21419 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21421 if (!SWIG_IsOK(res1)) {
21422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21423 }
21424 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21425 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21426 if (!SWIG_IsOK(ecode2)) {
21427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21428 }
21429 arg2 = static_cast< bool >(val2);
21430 if (arg1) (arg1)->m_altDown = arg2;
21431
21432 resultobj = SWIG_Py_Void();
21433 return resultobj;
21434 fail:
21435 return NULL;
21436 }
21437
21438
21439 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21440 PyObject *resultobj = 0;
21441 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21442 bool result;
21443 void *argp1 = 0 ;
21444 int res1 = 0 ;
21445 PyObject *swig_obj[1] ;
21446
21447 if (!args) SWIG_fail;
21448 swig_obj[0] = args;
21449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21450 if (!SWIG_IsOK(res1)) {
21451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21452 }
21453 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21454 result = (bool) ((arg1)->m_altDown);
21455 {
21456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21457 }
21458 return resultobj;
21459 fail:
21460 return NULL;
21461 }
21462
21463
21464 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21465 PyObject *resultobj = 0;
21466 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21467 bool arg2 ;
21468 void *argp1 = 0 ;
21469 int res1 = 0 ;
21470 bool val2 ;
21471 int ecode2 = 0 ;
21472 PyObject *swig_obj[2] ;
21473
21474 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21476 if (!SWIG_IsOK(res1)) {
21477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21478 }
21479 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21480 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21481 if (!SWIG_IsOK(ecode2)) {
21482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21483 }
21484 arg2 = static_cast< bool >(val2);
21485 if (arg1) (arg1)->m_metaDown = arg2;
21486
21487 resultobj = SWIG_Py_Void();
21488 return resultobj;
21489 fail:
21490 return NULL;
21491 }
21492
21493
21494 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21495 PyObject *resultobj = 0;
21496 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21497 bool result;
21498 void *argp1 = 0 ;
21499 int res1 = 0 ;
21500 PyObject *swig_obj[1] ;
21501
21502 if (!args) SWIG_fail;
21503 swig_obj[0] = args;
21504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21505 if (!SWIG_IsOK(res1)) {
21506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21507 }
21508 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21509 result = (bool) ((arg1)->m_metaDown);
21510 {
21511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21512 }
21513 return resultobj;
21514 fail:
21515 return NULL;
21516 }
21517
21518
21519 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21520 PyObject *resultobj = 0;
21521 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21522 int arg2 ;
21523 void *argp1 = 0 ;
21524 int res1 = 0 ;
21525 int val2 ;
21526 int ecode2 = 0 ;
21527 PyObject *swig_obj[2] ;
21528
21529 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21531 if (!SWIG_IsOK(res1)) {
21532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21533 }
21534 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21535 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21536 if (!SWIG_IsOK(ecode2)) {
21537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21538 }
21539 arg2 = static_cast< int >(val2);
21540 if (arg1) (arg1)->m_wheelRotation = arg2;
21541
21542 resultobj = SWIG_Py_Void();
21543 return resultobj;
21544 fail:
21545 return NULL;
21546 }
21547
21548
21549 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21550 PyObject *resultobj = 0;
21551 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21552 int result;
21553 void *argp1 = 0 ;
21554 int res1 = 0 ;
21555 PyObject *swig_obj[1] ;
21556
21557 if (!args) SWIG_fail;
21558 swig_obj[0] = args;
21559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21560 if (!SWIG_IsOK(res1)) {
21561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21562 }
21563 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21564 result = (int) ((arg1)->m_wheelRotation);
21565 resultobj = SWIG_From_int(static_cast< int >(result));
21566 return resultobj;
21567 fail:
21568 return NULL;
21569 }
21570
21571
21572 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21573 PyObject *resultobj = 0;
21574 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21575 int arg2 ;
21576 void *argp1 = 0 ;
21577 int res1 = 0 ;
21578 int val2 ;
21579 int ecode2 = 0 ;
21580 PyObject *swig_obj[2] ;
21581
21582 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21584 if (!SWIG_IsOK(res1)) {
21585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21586 }
21587 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21588 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21589 if (!SWIG_IsOK(ecode2)) {
21590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21591 }
21592 arg2 = static_cast< int >(val2);
21593 if (arg1) (arg1)->m_wheelDelta = arg2;
21594
21595 resultobj = SWIG_Py_Void();
21596 return resultobj;
21597 fail:
21598 return NULL;
21599 }
21600
21601
21602 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21603 PyObject *resultobj = 0;
21604 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21605 int result;
21606 void *argp1 = 0 ;
21607 int res1 = 0 ;
21608 PyObject *swig_obj[1] ;
21609
21610 if (!args) SWIG_fail;
21611 swig_obj[0] = args;
21612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21613 if (!SWIG_IsOK(res1)) {
21614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21615 }
21616 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21617 result = (int) ((arg1)->m_wheelDelta);
21618 resultobj = SWIG_From_int(static_cast< int >(result));
21619 return resultobj;
21620 fail:
21621 return NULL;
21622 }
21623
21624
21625 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21626 PyObject *resultobj = 0;
21627 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21628 int arg2 ;
21629 void *argp1 = 0 ;
21630 int res1 = 0 ;
21631 int val2 ;
21632 int ecode2 = 0 ;
21633 PyObject *swig_obj[2] ;
21634
21635 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21637 if (!SWIG_IsOK(res1)) {
21638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21639 }
21640 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21641 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21642 if (!SWIG_IsOK(ecode2)) {
21643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21644 }
21645 arg2 = static_cast< int >(val2);
21646 if (arg1) (arg1)->m_linesPerAction = arg2;
21647
21648 resultobj = SWIG_Py_Void();
21649 return resultobj;
21650 fail:
21651 return NULL;
21652 }
21653
21654
21655 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21656 PyObject *resultobj = 0;
21657 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21658 int result;
21659 void *argp1 = 0 ;
21660 int res1 = 0 ;
21661 PyObject *swig_obj[1] ;
21662
21663 if (!args) SWIG_fail;
21664 swig_obj[0] = args;
21665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21666 if (!SWIG_IsOK(res1)) {
21667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21668 }
21669 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21670 result = (int) ((arg1)->m_linesPerAction);
21671 resultobj = SWIG_From_int(static_cast< int >(result));
21672 return resultobj;
21673 fail:
21674 return NULL;
21675 }
21676
21677
21678 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21679 PyObject *obj;
21680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21681 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21682 return SWIG_Py_Void();
21683 }
21684
21685 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21686 return SWIG_Python_InitShadowInstance(args);
21687 }
21688
21689 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21690 PyObject *resultobj = 0;
21691 int arg1 = (int) 0 ;
21692 int arg2 = (int) 0 ;
21693 wxSetCursorEvent *result = 0 ;
21694 int val1 ;
21695 int ecode1 = 0 ;
21696 int val2 ;
21697 int ecode2 = 0 ;
21698 PyObject * obj0 = 0 ;
21699 PyObject * obj1 = 0 ;
21700 char * kwnames[] = {
21701 (char *) "x",(char *) "y", NULL
21702 };
21703
21704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21705 if (obj0) {
21706 ecode1 = SWIG_AsVal_int(obj0, &val1);
21707 if (!SWIG_IsOK(ecode1)) {
21708 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21709 }
21710 arg1 = static_cast< int >(val1);
21711 }
21712 if (obj1) {
21713 ecode2 = SWIG_AsVal_int(obj1, &val2);
21714 if (!SWIG_IsOK(ecode2)) {
21715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21716 }
21717 arg2 = static_cast< int >(val2);
21718 }
21719 {
21720 PyThreadState* __tstate = wxPyBeginAllowThreads();
21721 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21722 wxPyEndAllowThreads(__tstate);
21723 if (PyErr_Occurred()) SWIG_fail;
21724 }
21725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21726 return resultobj;
21727 fail:
21728 return NULL;
21729 }
21730
21731
21732 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21733 PyObject *resultobj = 0;
21734 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21735 int result;
21736 void *argp1 = 0 ;
21737 int res1 = 0 ;
21738 PyObject *swig_obj[1] ;
21739
21740 if (!args) SWIG_fail;
21741 swig_obj[0] = args;
21742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21743 if (!SWIG_IsOK(res1)) {
21744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21745 }
21746 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21747 {
21748 PyThreadState* __tstate = wxPyBeginAllowThreads();
21749 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21750 wxPyEndAllowThreads(__tstate);
21751 if (PyErr_Occurred()) SWIG_fail;
21752 }
21753 resultobj = SWIG_From_int(static_cast< int >(result));
21754 return resultobj;
21755 fail:
21756 return NULL;
21757 }
21758
21759
21760 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21761 PyObject *resultobj = 0;
21762 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21763 int result;
21764 void *argp1 = 0 ;
21765 int res1 = 0 ;
21766 PyObject *swig_obj[1] ;
21767
21768 if (!args) SWIG_fail;
21769 swig_obj[0] = args;
21770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21771 if (!SWIG_IsOK(res1)) {
21772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21773 }
21774 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21775 {
21776 PyThreadState* __tstate = wxPyBeginAllowThreads();
21777 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21778 wxPyEndAllowThreads(__tstate);
21779 if (PyErr_Occurred()) SWIG_fail;
21780 }
21781 resultobj = SWIG_From_int(static_cast< int >(result));
21782 return resultobj;
21783 fail:
21784 return NULL;
21785 }
21786
21787
21788 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21789 PyObject *resultobj = 0;
21790 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21791 wxCursor *arg2 = 0 ;
21792 void *argp1 = 0 ;
21793 int res1 = 0 ;
21794 void *argp2 = 0 ;
21795 int res2 = 0 ;
21796 PyObject * obj0 = 0 ;
21797 PyObject * obj1 = 0 ;
21798 char * kwnames[] = {
21799 (char *) "self",(char *) "cursor", NULL
21800 };
21801
21802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21804 if (!SWIG_IsOK(res1)) {
21805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21806 }
21807 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21808 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21809 if (!SWIG_IsOK(res2)) {
21810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21811 }
21812 if (!argp2) {
21813 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21814 }
21815 arg2 = reinterpret_cast< wxCursor * >(argp2);
21816 {
21817 PyThreadState* __tstate = wxPyBeginAllowThreads();
21818 (arg1)->SetCursor((wxCursor const &)*arg2);
21819 wxPyEndAllowThreads(__tstate);
21820 if (PyErr_Occurred()) SWIG_fail;
21821 }
21822 resultobj = SWIG_Py_Void();
21823 return resultobj;
21824 fail:
21825 return NULL;
21826 }
21827
21828
21829 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21830 PyObject *resultobj = 0;
21831 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21832 wxCursor *result = 0 ;
21833 void *argp1 = 0 ;
21834 int res1 = 0 ;
21835 PyObject *swig_obj[1] ;
21836
21837 if (!args) SWIG_fail;
21838 swig_obj[0] = args;
21839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21840 if (!SWIG_IsOK(res1)) {
21841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21842 }
21843 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21844 {
21845 PyThreadState* __tstate = wxPyBeginAllowThreads();
21846 {
21847 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21848 result = (wxCursor *) &_result_ref;
21849 }
21850 wxPyEndAllowThreads(__tstate);
21851 if (PyErr_Occurred()) SWIG_fail;
21852 }
21853 {
21854 wxCursor* resultptr = new wxCursor(*result);
21855 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21856 }
21857 return resultobj;
21858 fail:
21859 return NULL;
21860 }
21861
21862
21863 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21864 PyObject *resultobj = 0;
21865 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21866 bool result;
21867 void *argp1 = 0 ;
21868 int res1 = 0 ;
21869 PyObject *swig_obj[1] ;
21870
21871 if (!args) SWIG_fail;
21872 swig_obj[0] = args;
21873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21874 if (!SWIG_IsOK(res1)) {
21875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21876 }
21877 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21878 {
21879 PyThreadState* __tstate = wxPyBeginAllowThreads();
21880 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21881 wxPyEndAllowThreads(__tstate);
21882 if (PyErr_Occurred()) SWIG_fail;
21883 }
21884 {
21885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21886 }
21887 return resultobj;
21888 fail:
21889 return NULL;
21890 }
21891
21892
21893 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21894 PyObject *obj;
21895 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21896 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21897 return SWIG_Py_Void();
21898 }
21899
21900 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21901 return SWIG_Python_InitShadowInstance(args);
21902 }
21903
21904 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21905 PyObject *resultobj = 0;
21906 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21907 wxKeyEvent *result = 0 ;
21908 int val1 ;
21909 int ecode1 = 0 ;
21910 PyObject * obj0 = 0 ;
21911 char * kwnames[] = {
21912 (char *) "eventType", NULL
21913 };
21914
21915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21916 if (obj0) {
21917 ecode1 = SWIG_AsVal_int(obj0, &val1);
21918 if (!SWIG_IsOK(ecode1)) {
21919 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21920 }
21921 arg1 = static_cast< wxEventType >(val1);
21922 }
21923 {
21924 PyThreadState* __tstate = wxPyBeginAllowThreads();
21925 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21926 wxPyEndAllowThreads(__tstate);
21927 if (PyErr_Occurred()) SWIG_fail;
21928 }
21929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21930 return resultobj;
21931 fail:
21932 return NULL;
21933 }
21934
21935
21936 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21937 PyObject *resultobj = 0;
21938 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21939 int result;
21940 void *argp1 = 0 ;
21941 int res1 = 0 ;
21942 PyObject *swig_obj[1] ;
21943
21944 if (!args) SWIG_fail;
21945 swig_obj[0] = args;
21946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21947 if (!SWIG_IsOK(res1)) {
21948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21949 }
21950 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21951 {
21952 PyThreadState* __tstate = wxPyBeginAllowThreads();
21953 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21954 wxPyEndAllowThreads(__tstate);
21955 if (PyErr_Occurred()) SWIG_fail;
21956 }
21957 resultobj = SWIG_From_int(static_cast< int >(result));
21958 return resultobj;
21959 fail:
21960 return NULL;
21961 }
21962
21963
21964 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21965 PyObject *resultobj = 0;
21966 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21967 bool result;
21968 void *argp1 = 0 ;
21969 int res1 = 0 ;
21970 PyObject *swig_obj[1] ;
21971
21972 if (!args) SWIG_fail;
21973 swig_obj[0] = args;
21974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21975 if (!SWIG_IsOK(res1)) {
21976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21977 }
21978 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21979 {
21980 PyThreadState* __tstate = wxPyBeginAllowThreads();
21981 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21982 wxPyEndAllowThreads(__tstate);
21983 if (PyErr_Occurred()) SWIG_fail;
21984 }
21985 {
21986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21987 }
21988 return resultobj;
21989 fail:
21990 return NULL;
21991 }
21992
21993
21994 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21995 PyObject *resultobj = 0;
21996 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21997 bool result;
21998 void *argp1 = 0 ;
21999 int res1 = 0 ;
22000 PyObject *swig_obj[1] ;
22001
22002 if (!args) SWIG_fail;
22003 swig_obj[0] = args;
22004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22005 if (!SWIG_IsOK(res1)) {
22006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22007 }
22008 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22009 {
22010 PyThreadState* __tstate = wxPyBeginAllowThreads();
22011 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22012 wxPyEndAllowThreads(__tstate);
22013 if (PyErr_Occurred()) SWIG_fail;
22014 }
22015 {
22016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22017 }
22018 return resultobj;
22019 fail:
22020 return NULL;
22021 }
22022
22023
22024 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22025 PyObject *resultobj = 0;
22026 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22027 bool result;
22028 void *argp1 = 0 ;
22029 int res1 = 0 ;
22030 PyObject *swig_obj[1] ;
22031
22032 if (!args) SWIG_fail;
22033 swig_obj[0] = args;
22034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22035 if (!SWIG_IsOK(res1)) {
22036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22037 }
22038 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22039 {
22040 PyThreadState* __tstate = wxPyBeginAllowThreads();
22041 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22042 wxPyEndAllowThreads(__tstate);
22043 if (PyErr_Occurred()) SWIG_fail;
22044 }
22045 {
22046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22047 }
22048 return resultobj;
22049 fail:
22050 return NULL;
22051 }
22052
22053
22054 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22055 PyObject *resultobj = 0;
22056 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22057 bool result;
22058 void *argp1 = 0 ;
22059 int res1 = 0 ;
22060 PyObject *swig_obj[1] ;
22061
22062 if (!args) SWIG_fail;
22063 swig_obj[0] = args;
22064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22065 if (!SWIG_IsOK(res1)) {
22066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22067 }
22068 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22069 {
22070 PyThreadState* __tstate = wxPyBeginAllowThreads();
22071 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22072 wxPyEndAllowThreads(__tstate);
22073 if (PyErr_Occurred()) SWIG_fail;
22074 }
22075 {
22076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22077 }
22078 return resultobj;
22079 fail:
22080 return NULL;
22081 }
22082
22083
22084 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22085 PyObject *resultobj = 0;
22086 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22087 bool result;
22088 void *argp1 = 0 ;
22089 int res1 = 0 ;
22090 PyObject *swig_obj[1] ;
22091
22092 if (!args) SWIG_fail;
22093 swig_obj[0] = args;
22094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22095 if (!SWIG_IsOK(res1)) {
22096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22097 }
22098 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22099 {
22100 PyThreadState* __tstate = wxPyBeginAllowThreads();
22101 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22102 wxPyEndAllowThreads(__tstate);
22103 if (PyErr_Occurred()) SWIG_fail;
22104 }
22105 {
22106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22107 }
22108 return resultobj;
22109 fail:
22110 return NULL;
22111 }
22112
22113
22114 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22115 PyObject *resultobj = 0;
22116 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22117 bool result;
22118 void *argp1 = 0 ;
22119 int res1 = 0 ;
22120 PyObject *swig_obj[1] ;
22121
22122 if (!args) SWIG_fail;
22123 swig_obj[0] = args;
22124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22125 if (!SWIG_IsOK(res1)) {
22126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22127 }
22128 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22129 {
22130 PyThreadState* __tstate = wxPyBeginAllowThreads();
22131 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22132 wxPyEndAllowThreads(__tstate);
22133 if (PyErr_Occurred()) SWIG_fail;
22134 }
22135 {
22136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22137 }
22138 return resultobj;
22139 fail:
22140 return NULL;
22141 }
22142
22143
22144 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22145 PyObject *resultobj = 0;
22146 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22147 int result;
22148 void *argp1 = 0 ;
22149 int res1 = 0 ;
22150 PyObject *swig_obj[1] ;
22151
22152 if (!args) SWIG_fail;
22153 swig_obj[0] = args;
22154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22155 if (!SWIG_IsOK(res1)) {
22156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22157 }
22158 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22159 {
22160 PyThreadState* __tstate = wxPyBeginAllowThreads();
22161 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22162 wxPyEndAllowThreads(__tstate);
22163 if (PyErr_Occurred()) SWIG_fail;
22164 }
22165 resultobj = SWIG_From_int(static_cast< int >(result));
22166 return resultobj;
22167 fail:
22168 return NULL;
22169 }
22170
22171
22172 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22173 PyObject *resultobj = 0;
22174 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22175 int result;
22176 void *argp1 = 0 ;
22177 int res1 = 0 ;
22178 PyObject *swig_obj[1] ;
22179
22180 if (!args) SWIG_fail;
22181 swig_obj[0] = args;
22182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22183 if (!SWIG_IsOK(res1)) {
22184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22185 }
22186 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22187 {
22188 PyThreadState* __tstate = wxPyBeginAllowThreads();
22189 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22190 wxPyEndAllowThreads(__tstate);
22191 if (PyErr_Occurred()) SWIG_fail;
22192 }
22193 resultobj = SWIG_From_int(static_cast< int >(result));
22194 return resultobj;
22195 fail:
22196 return NULL;
22197 }
22198
22199
22200 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22201 PyObject *resultobj = 0;
22202 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22203 int arg2 ;
22204 void *argp1 = 0 ;
22205 int res1 = 0 ;
22206 int val2 ;
22207 int ecode2 = 0 ;
22208 PyObject * obj0 = 0 ;
22209 PyObject * obj1 = 0 ;
22210 char * kwnames[] = {
22211 (char *) "self",(char *) "uniChar", NULL
22212 };
22213
22214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22216 if (!SWIG_IsOK(res1)) {
22217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22218 }
22219 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22220 ecode2 = SWIG_AsVal_int(obj1, &val2);
22221 if (!SWIG_IsOK(ecode2)) {
22222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22223 }
22224 arg2 = static_cast< int >(val2);
22225 {
22226 PyThreadState* __tstate = wxPyBeginAllowThreads();
22227 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22228 wxPyEndAllowThreads(__tstate);
22229 if (PyErr_Occurred()) SWIG_fail;
22230 }
22231 resultobj = SWIG_Py_Void();
22232 return resultobj;
22233 fail:
22234 return NULL;
22235 }
22236
22237
22238 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22239 PyObject *resultobj = 0;
22240 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22241 unsigned int result;
22242 void *argp1 = 0 ;
22243 int res1 = 0 ;
22244 PyObject *swig_obj[1] ;
22245
22246 if (!args) SWIG_fail;
22247 swig_obj[0] = args;
22248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22249 if (!SWIG_IsOK(res1)) {
22250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22251 }
22252 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22253 {
22254 PyThreadState* __tstate = wxPyBeginAllowThreads();
22255 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22256 wxPyEndAllowThreads(__tstate);
22257 if (PyErr_Occurred()) SWIG_fail;
22258 }
22259 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22260 return resultobj;
22261 fail:
22262 return NULL;
22263 }
22264
22265
22266 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22267 PyObject *resultobj = 0;
22268 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22269 unsigned int result;
22270 void *argp1 = 0 ;
22271 int res1 = 0 ;
22272 PyObject *swig_obj[1] ;
22273
22274 if (!args) SWIG_fail;
22275 swig_obj[0] = args;
22276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22277 if (!SWIG_IsOK(res1)) {
22278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22279 }
22280 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22281 {
22282 PyThreadState* __tstate = wxPyBeginAllowThreads();
22283 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22284 wxPyEndAllowThreads(__tstate);
22285 if (PyErr_Occurred()) SWIG_fail;
22286 }
22287 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22288 return resultobj;
22289 fail:
22290 return NULL;
22291 }
22292
22293
22294 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22295 PyObject *resultobj = 0;
22296 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22297 wxPoint result;
22298 void *argp1 = 0 ;
22299 int res1 = 0 ;
22300 PyObject *swig_obj[1] ;
22301
22302 if (!args) SWIG_fail;
22303 swig_obj[0] = args;
22304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22305 if (!SWIG_IsOK(res1)) {
22306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22307 }
22308 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22309 {
22310 PyThreadState* __tstate = wxPyBeginAllowThreads();
22311 result = (arg1)->GetPosition();
22312 wxPyEndAllowThreads(__tstate);
22313 if (PyErr_Occurred()) SWIG_fail;
22314 }
22315 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22316 return resultobj;
22317 fail:
22318 return NULL;
22319 }
22320
22321
22322 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22323 PyObject *resultobj = 0;
22324 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22325 long *arg2 = (long *) 0 ;
22326 long *arg3 = (long *) 0 ;
22327 void *argp1 = 0 ;
22328 int res1 = 0 ;
22329 long temp2 ;
22330 int res2 = SWIG_TMPOBJ ;
22331 long temp3 ;
22332 int res3 = SWIG_TMPOBJ ;
22333 PyObject *swig_obj[1] ;
22334
22335 arg2 = &temp2;
22336 arg3 = &temp3;
22337 if (!args) SWIG_fail;
22338 swig_obj[0] = args;
22339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22340 if (!SWIG_IsOK(res1)) {
22341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22342 }
22343 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22344 {
22345 PyThreadState* __tstate = wxPyBeginAllowThreads();
22346 (arg1)->GetPosition(arg2,arg3);
22347 wxPyEndAllowThreads(__tstate);
22348 if (PyErr_Occurred()) SWIG_fail;
22349 }
22350 resultobj = SWIG_Py_Void();
22351 if (SWIG_IsTmpObj(res2)) {
22352 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22353 } else {
22354 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22355 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22356 }
22357 if (SWIG_IsTmpObj(res3)) {
22358 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22359 } else {
22360 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22361 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22362 }
22363 return resultobj;
22364 fail:
22365 return NULL;
22366 }
22367
22368
22369 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22370 PyObject *resultobj = 0;
22371 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22372 int result;
22373 void *argp1 = 0 ;
22374 int res1 = 0 ;
22375 PyObject *swig_obj[1] ;
22376
22377 if (!args) SWIG_fail;
22378 swig_obj[0] = args;
22379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22380 if (!SWIG_IsOK(res1)) {
22381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22382 }
22383 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22384 {
22385 PyThreadState* __tstate = wxPyBeginAllowThreads();
22386 result = (int)((wxKeyEvent const *)arg1)->GetX();
22387 wxPyEndAllowThreads(__tstate);
22388 if (PyErr_Occurred()) SWIG_fail;
22389 }
22390 resultobj = SWIG_From_int(static_cast< int >(result));
22391 return resultobj;
22392 fail:
22393 return NULL;
22394 }
22395
22396
22397 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22398 PyObject *resultobj = 0;
22399 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22400 int result;
22401 void *argp1 = 0 ;
22402 int res1 = 0 ;
22403 PyObject *swig_obj[1] ;
22404
22405 if (!args) SWIG_fail;
22406 swig_obj[0] = args;
22407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22408 if (!SWIG_IsOK(res1)) {
22409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22410 }
22411 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22412 {
22413 PyThreadState* __tstate = wxPyBeginAllowThreads();
22414 result = (int)((wxKeyEvent const *)arg1)->GetY();
22415 wxPyEndAllowThreads(__tstate);
22416 if (PyErr_Occurred()) SWIG_fail;
22417 }
22418 resultobj = SWIG_From_int(static_cast< int >(result));
22419 return resultobj;
22420 fail:
22421 return NULL;
22422 }
22423
22424
22425 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22426 PyObject *resultobj = 0;
22427 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22428 int arg2 ;
22429 void *argp1 = 0 ;
22430 int res1 = 0 ;
22431 int val2 ;
22432 int ecode2 = 0 ;
22433 PyObject *swig_obj[2] ;
22434
22435 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22437 if (!SWIG_IsOK(res1)) {
22438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22439 }
22440 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22441 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22442 if (!SWIG_IsOK(ecode2)) {
22443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22444 }
22445 arg2 = static_cast< int >(val2);
22446 if (arg1) (arg1)->m_x = arg2;
22447
22448 resultobj = SWIG_Py_Void();
22449 return resultobj;
22450 fail:
22451 return NULL;
22452 }
22453
22454
22455 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22456 PyObject *resultobj = 0;
22457 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22458 int result;
22459 void *argp1 = 0 ;
22460 int res1 = 0 ;
22461 PyObject *swig_obj[1] ;
22462
22463 if (!args) SWIG_fail;
22464 swig_obj[0] = args;
22465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22466 if (!SWIG_IsOK(res1)) {
22467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22468 }
22469 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22470 result = (int) ((arg1)->m_x);
22471 resultobj = SWIG_From_int(static_cast< int >(result));
22472 return resultobj;
22473 fail:
22474 return NULL;
22475 }
22476
22477
22478 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22479 PyObject *resultobj = 0;
22480 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22481 int arg2 ;
22482 void *argp1 = 0 ;
22483 int res1 = 0 ;
22484 int val2 ;
22485 int ecode2 = 0 ;
22486 PyObject *swig_obj[2] ;
22487
22488 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22490 if (!SWIG_IsOK(res1)) {
22491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22492 }
22493 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22494 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22495 if (!SWIG_IsOK(ecode2)) {
22496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22497 }
22498 arg2 = static_cast< int >(val2);
22499 if (arg1) (arg1)->m_y = arg2;
22500
22501 resultobj = SWIG_Py_Void();
22502 return resultobj;
22503 fail:
22504 return NULL;
22505 }
22506
22507
22508 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22509 PyObject *resultobj = 0;
22510 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22511 int result;
22512 void *argp1 = 0 ;
22513 int res1 = 0 ;
22514 PyObject *swig_obj[1] ;
22515
22516 if (!args) SWIG_fail;
22517 swig_obj[0] = args;
22518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22519 if (!SWIG_IsOK(res1)) {
22520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22521 }
22522 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22523 result = (int) ((arg1)->m_y);
22524 resultobj = SWIG_From_int(static_cast< int >(result));
22525 return resultobj;
22526 fail:
22527 return NULL;
22528 }
22529
22530
22531 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22532 PyObject *resultobj = 0;
22533 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22534 long arg2 ;
22535 void *argp1 = 0 ;
22536 int res1 = 0 ;
22537 long val2 ;
22538 int ecode2 = 0 ;
22539 PyObject *swig_obj[2] ;
22540
22541 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22543 if (!SWIG_IsOK(res1)) {
22544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22545 }
22546 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22547 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22548 if (!SWIG_IsOK(ecode2)) {
22549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22550 }
22551 arg2 = static_cast< long >(val2);
22552 if (arg1) (arg1)->m_keyCode = arg2;
22553
22554 resultobj = SWIG_Py_Void();
22555 return resultobj;
22556 fail:
22557 return NULL;
22558 }
22559
22560
22561 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22562 PyObject *resultobj = 0;
22563 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22564 long result;
22565 void *argp1 = 0 ;
22566 int res1 = 0 ;
22567 PyObject *swig_obj[1] ;
22568
22569 if (!args) SWIG_fail;
22570 swig_obj[0] = args;
22571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22572 if (!SWIG_IsOK(res1)) {
22573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22574 }
22575 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22576 result = (long) ((arg1)->m_keyCode);
22577 resultobj = SWIG_From_long(static_cast< long >(result));
22578 return resultobj;
22579 fail:
22580 return NULL;
22581 }
22582
22583
22584 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22585 PyObject *resultobj = 0;
22586 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22587 bool arg2 ;
22588 void *argp1 = 0 ;
22589 int res1 = 0 ;
22590 bool val2 ;
22591 int ecode2 = 0 ;
22592 PyObject *swig_obj[2] ;
22593
22594 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22596 if (!SWIG_IsOK(res1)) {
22597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22598 }
22599 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22600 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22601 if (!SWIG_IsOK(ecode2)) {
22602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22603 }
22604 arg2 = static_cast< bool >(val2);
22605 if (arg1) (arg1)->m_controlDown = arg2;
22606
22607 resultobj = SWIG_Py_Void();
22608 return resultobj;
22609 fail:
22610 return NULL;
22611 }
22612
22613
22614 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22615 PyObject *resultobj = 0;
22616 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22617 bool result;
22618 void *argp1 = 0 ;
22619 int res1 = 0 ;
22620 PyObject *swig_obj[1] ;
22621
22622 if (!args) SWIG_fail;
22623 swig_obj[0] = args;
22624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22625 if (!SWIG_IsOK(res1)) {
22626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22627 }
22628 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22629 result = (bool) ((arg1)->m_controlDown);
22630 {
22631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22632 }
22633 return resultobj;
22634 fail:
22635 return NULL;
22636 }
22637
22638
22639 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22640 PyObject *resultobj = 0;
22641 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22642 bool arg2 ;
22643 void *argp1 = 0 ;
22644 int res1 = 0 ;
22645 bool val2 ;
22646 int ecode2 = 0 ;
22647 PyObject *swig_obj[2] ;
22648
22649 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22651 if (!SWIG_IsOK(res1)) {
22652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22653 }
22654 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22655 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22656 if (!SWIG_IsOK(ecode2)) {
22657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22658 }
22659 arg2 = static_cast< bool >(val2);
22660 if (arg1) (arg1)->m_shiftDown = arg2;
22661
22662 resultobj = SWIG_Py_Void();
22663 return resultobj;
22664 fail:
22665 return NULL;
22666 }
22667
22668
22669 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22670 PyObject *resultobj = 0;
22671 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22672 bool result;
22673 void *argp1 = 0 ;
22674 int res1 = 0 ;
22675 PyObject *swig_obj[1] ;
22676
22677 if (!args) SWIG_fail;
22678 swig_obj[0] = args;
22679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22680 if (!SWIG_IsOK(res1)) {
22681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22682 }
22683 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22684 result = (bool) ((arg1)->m_shiftDown);
22685 {
22686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22687 }
22688 return resultobj;
22689 fail:
22690 return NULL;
22691 }
22692
22693
22694 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22695 PyObject *resultobj = 0;
22696 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22697 bool arg2 ;
22698 void *argp1 = 0 ;
22699 int res1 = 0 ;
22700 bool val2 ;
22701 int ecode2 = 0 ;
22702 PyObject *swig_obj[2] ;
22703
22704 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22706 if (!SWIG_IsOK(res1)) {
22707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22708 }
22709 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22710 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22711 if (!SWIG_IsOK(ecode2)) {
22712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22713 }
22714 arg2 = static_cast< bool >(val2);
22715 if (arg1) (arg1)->m_altDown = arg2;
22716
22717 resultobj = SWIG_Py_Void();
22718 return resultobj;
22719 fail:
22720 return NULL;
22721 }
22722
22723
22724 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22725 PyObject *resultobj = 0;
22726 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22727 bool result;
22728 void *argp1 = 0 ;
22729 int res1 = 0 ;
22730 PyObject *swig_obj[1] ;
22731
22732 if (!args) SWIG_fail;
22733 swig_obj[0] = args;
22734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22735 if (!SWIG_IsOK(res1)) {
22736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22737 }
22738 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22739 result = (bool) ((arg1)->m_altDown);
22740 {
22741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22742 }
22743 return resultobj;
22744 fail:
22745 return NULL;
22746 }
22747
22748
22749 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22750 PyObject *resultobj = 0;
22751 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22752 bool arg2 ;
22753 void *argp1 = 0 ;
22754 int res1 = 0 ;
22755 bool val2 ;
22756 int ecode2 = 0 ;
22757 PyObject *swig_obj[2] ;
22758
22759 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22761 if (!SWIG_IsOK(res1)) {
22762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22763 }
22764 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22765 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22766 if (!SWIG_IsOK(ecode2)) {
22767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22768 }
22769 arg2 = static_cast< bool >(val2);
22770 if (arg1) (arg1)->m_metaDown = arg2;
22771
22772 resultobj = SWIG_Py_Void();
22773 return resultobj;
22774 fail:
22775 return NULL;
22776 }
22777
22778
22779 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22780 PyObject *resultobj = 0;
22781 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22782 bool result;
22783 void *argp1 = 0 ;
22784 int res1 = 0 ;
22785 PyObject *swig_obj[1] ;
22786
22787 if (!args) SWIG_fail;
22788 swig_obj[0] = args;
22789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22790 if (!SWIG_IsOK(res1)) {
22791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22792 }
22793 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22794 result = (bool) ((arg1)->m_metaDown);
22795 {
22796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22797 }
22798 return resultobj;
22799 fail:
22800 return NULL;
22801 }
22802
22803
22804 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22805 PyObject *resultobj = 0;
22806 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22807 bool arg2 ;
22808 void *argp1 = 0 ;
22809 int res1 = 0 ;
22810 bool val2 ;
22811 int ecode2 = 0 ;
22812 PyObject *swig_obj[2] ;
22813
22814 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22816 if (!SWIG_IsOK(res1)) {
22817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22818 }
22819 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22820 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22821 if (!SWIG_IsOK(ecode2)) {
22822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22823 }
22824 arg2 = static_cast< bool >(val2);
22825 if (arg1) (arg1)->m_scanCode = arg2;
22826
22827 resultobj = SWIG_Py_Void();
22828 return resultobj;
22829 fail:
22830 return NULL;
22831 }
22832
22833
22834 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22835 PyObject *resultobj = 0;
22836 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22837 bool result;
22838 void *argp1 = 0 ;
22839 int res1 = 0 ;
22840 PyObject *swig_obj[1] ;
22841
22842 if (!args) SWIG_fail;
22843 swig_obj[0] = args;
22844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22845 if (!SWIG_IsOK(res1)) {
22846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22847 }
22848 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22849 result = (bool) ((arg1)->m_scanCode);
22850 {
22851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22852 }
22853 return resultobj;
22854 fail:
22855 return NULL;
22856 }
22857
22858
22859 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22860 PyObject *resultobj = 0;
22861 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22862 unsigned int arg2 ;
22863 void *argp1 = 0 ;
22864 int res1 = 0 ;
22865 unsigned int val2 ;
22866 int ecode2 = 0 ;
22867 PyObject *swig_obj[2] ;
22868
22869 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22871 if (!SWIG_IsOK(res1)) {
22872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22873 }
22874 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22875 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22876 if (!SWIG_IsOK(ecode2)) {
22877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22878 }
22879 arg2 = static_cast< unsigned int >(val2);
22880 if (arg1) (arg1)->m_rawCode = arg2;
22881
22882 resultobj = SWIG_Py_Void();
22883 return resultobj;
22884 fail:
22885 return NULL;
22886 }
22887
22888
22889 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22890 PyObject *resultobj = 0;
22891 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22892 unsigned int result;
22893 void *argp1 = 0 ;
22894 int res1 = 0 ;
22895 PyObject *swig_obj[1] ;
22896
22897 if (!args) SWIG_fail;
22898 swig_obj[0] = args;
22899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22900 if (!SWIG_IsOK(res1)) {
22901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22902 }
22903 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22904 result = (unsigned int) ((arg1)->m_rawCode);
22905 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22906 return resultobj;
22907 fail:
22908 return NULL;
22909 }
22910
22911
22912 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22913 PyObject *resultobj = 0;
22914 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22915 unsigned int arg2 ;
22916 void *argp1 = 0 ;
22917 int res1 = 0 ;
22918 unsigned int val2 ;
22919 int ecode2 = 0 ;
22920 PyObject *swig_obj[2] ;
22921
22922 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22924 if (!SWIG_IsOK(res1)) {
22925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22926 }
22927 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22928 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22929 if (!SWIG_IsOK(ecode2)) {
22930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22931 }
22932 arg2 = static_cast< unsigned int >(val2);
22933 if (arg1) (arg1)->m_rawFlags = arg2;
22934
22935 resultobj = SWIG_Py_Void();
22936 return resultobj;
22937 fail:
22938 return NULL;
22939 }
22940
22941
22942 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22943 PyObject *resultobj = 0;
22944 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22945 unsigned int result;
22946 void *argp1 = 0 ;
22947 int res1 = 0 ;
22948 PyObject *swig_obj[1] ;
22949
22950 if (!args) SWIG_fail;
22951 swig_obj[0] = args;
22952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22953 if (!SWIG_IsOK(res1)) {
22954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22955 }
22956 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22957 result = (unsigned int) ((arg1)->m_rawFlags);
22958 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22959 return resultobj;
22960 fail:
22961 return NULL;
22962 }
22963
22964
22965 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22966 PyObject *obj;
22967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22968 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22969 return SWIG_Py_Void();
22970 }
22971
22972 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22973 return SWIG_Python_InitShadowInstance(args);
22974 }
22975
22976 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22977 PyObject *resultobj = 0;
22978 wxSize const &arg1_defvalue = wxDefaultSize ;
22979 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22980 int arg2 = (int) 0 ;
22981 wxSizeEvent *result = 0 ;
22982 wxSize temp1 ;
22983 int val2 ;
22984 int ecode2 = 0 ;
22985 PyObject * obj0 = 0 ;
22986 PyObject * obj1 = 0 ;
22987 char * kwnames[] = {
22988 (char *) "sz",(char *) "winid", NULL
22989 };
22990
22991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22992 if (obj0) {
22993 {
22994 arg1 = &temp1;
22995 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22996 }
22997 }
22998 if (obj1) {
22999 ecode2 = SWIG_AsVal_int(obj1, &val2);
23000 if (!SWIG_IsOK(ecode2)) {
23001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23002 }
23003 arg2 = static_cast< int >(val2);
23004 }
23005 {
23006 PyThreadState* __tstate = wxPyBeginAllowThreads();
23007 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23008 wxPyEndAllowThreads(__tstate);
23009 if (PyErr_Occurred()) SWIG_fail;
23010 }
23011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23012 return resultobj;
23013 fail:
23014 return NULL;
23015 }
23016
23017
23018 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23019 PyObject *resultobj = 0;
23020 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23021 wxSize result;
23022 void *argp1 = 0 ;
23023 int res1 = 0 ;
23024 PyObject *swig_obj[1] ;
23025
23026 if (!args) SWIG_fail;
23027 swig_obj[0] = args;
23028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23029 if (!SWIG_IsOK(res1)) {
23030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23031 }
23032 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23033 {
23034 PyThreadState* __tstate = wxPyBeginAllowThreads();
23035 result = ((wxSizeEvent const *)arg1)->GetSize();
23036 wxPyEndAllowThreads(__tstate);
23037 if (PyErr_Occurred()) SWIG_fail;
23038 }
23039 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23040 return resultobj;
23041 fail:
23042 return NULL;
23043 }
23044
23045
23046 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23047 PyObject *resultobj = 0;
23048 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23049 wxRect result;
23050 void *argp1 = 0 ;
23051 int res1 = 0 ;
23052 PyObject *swig_obj[1] ;
23053
23054 if (!args) SWIG_fail;
23055 swig_obj[0] = args;
23056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23057 if (!SWIG_IsOK(res1)) {
23058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23059 }
23060 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23061 {
23062 PyThreadState* __tstate = wxPyBeginAllowThreads();
23063 result = ((wxSizeEvent const *)arg1)->GetRect();
23064 wxPyEndAllowThreads(__tstate);
23065 if (PyErr_Occurred()) SWIG_fail;
23066 }
23067 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23068 return resultobj;
23069 fail:
23070 return NULL;
23071 }
23072
23073
23074 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23075 PyObject *resultobj = 0;
23076 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23077 wxRect arg2 ;
23078 void *argp1 = 0 ;
23079 int res1 = 0 ;
23080 void *argp2 ;
23081 int res2 = 0 ;
23082 PyObject * obj0 = 0 ;
23083 PyObject * obj1 = 0 ;
23084 char * kwnames[] = {
23085 (char *) "self",(char *) "rect", NULL
23086 };
23087
23088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23090 if (!SWIG_IsOK(res1)) {
23091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23092 }
23093 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23094 {
23095 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23096 if (!SWIG_IsOK(res2)) {
23097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23098 }
23099 if (!argp2) {
23100 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23101 } else {
23102 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23103 arg2 = *temp;
23104 if (SWIG_IsNewObj(res2)) delete temp;
23105 }
23106 }
23107 {
23108 PyThreadState* __tstate = wxPyBeginAllowThreads();
23109 (arg1)->SetRect(arg2);
23110 wxPyEndAllowThreads(__tstate);
23111 if (PyErr_Occurred()) SWIG_fail;
23112 }
23113 resultobj = SWIG_Py_Void();
23114 return resultobj;
23115 fail:
23116 return NULL;
23117 }
23118
23119
23120 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23121 PyObject *resultobj = 0;
23122 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23123 wxSize arg2 ;
23124 void *argp1 = 0 ;
23125 int res1 = 0 ;
23126 void *argp2 ;
23127 int res2 = 0 ;
23128 PyObject * obj0 = 0 ;
23129 PyObject * obj1 = 0 ;
23130 char * kwnames[] = {
23131 (char *) "self",(char *) "size", NULL
23132 };
23133
23134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23136 if (!SWIG_IsOK(res1)) {
23137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23138 }
23139 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23140 {
23141 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23142 if (!SWIG_IsOK(res2)) {
23143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23144 }
23145 if (!argp2) {
23146 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23147 } else {
23148 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23149 arg2 = *temp;
23150 if (SWIG_IsNewObj(res2)) delete temp;
23151 }
23152 }
23153 {
23154 PyThreadState* __tstate = wxPyBeginAllowThreads();
23155 wxSizeEvent_SetSize(arg1,arg2);
23156 wxPyEndAllowThreads(__tstate);
23157 if (PyErr_Occurred()) SWIG_fail;
23158 }
23159 resultobj = SWIG_Py_Void();
23160 return resultobj;
23161 fail:
23162 return NULL;
23163 }
23164
23165
23166 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23167 PyObject *resultobj = 0;
23168 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23169 wxSize *arg2 = (wxSize *) 0 ;
23170 void *argp1 = 0 ;
23171 int res1 = 0 ;
23172 void *argp2 = 0 ;
23173 int res2 = 0 ;
23174 PyObject *swig_obj[2] ;
23175
23176 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23178 if (!SWIG_IsOK(res1)) {
23179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23180 }
23181 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23182 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23183 if (!SWIG_IsOK(res2)) {
23184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23185 }
23186 arg2 = reinterpret_cast< wxSize * >(argp2);
23187 if (arg1) (arg1)->m_size = *arg2;
23188
23189 resultobj = SWIG_Py_Void();
23190 return resultobj;
23191 fail:
23192 return NULL;
23193 }
23194
23195
23196 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23197 PyObject *resultobj = 0;
23198 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23199 wxSize *result = 0 ;
23200 void *argp1 = 0 ;
23201 int res1 = 0 ;
23202 PyObject *swig_obj[1] ;
23203
23204 if (!args) SWIG_fail;
23205 swig_obj[0] = args;
23206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23207 if (!SWIG_IsOK(res1)) {
23208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23209 }
23210 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23211 result = (wxSize *)& ((arg1)->m_size);
23212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23213 return resultobj;
23214 fail:
23215 return NULL;
23216 }
23217
23218
23219 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23220 PyObject *resultobj = 0;
23221 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23222 wxRect *arg2 = (wxRect *) 0 ;
23223 void *argp1 = 0 ;
23224 int res1 = 0 ;
23225 void *argp2 = 0 ;
23226 int res2 = 0 ;
23227 PyObject *swig_obj[2] ;
23228
23229 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23231 if (!SWIG_IsOK(res1)) {
23232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23233 }
23234 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23235 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23236 if (!SWIG_IsOK(res2)) {
23237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23238 }
23239 arg2 = reinterpret_cast< wxRect * >(argp2);
23240 if (arg1) (arg1)->m_rect = *arg2;
23241
23242 resultobj = SWIG_Py_Void();
23243 return resultobj;
23244 fail:
23245 return NULL;
23246 }
23247
23248
23249 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23250 PyObject *resultobj = 0;
23251 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23252 wxRect *result = 0 ;
23253 void *argp1 = 0 ;
23254 int res1 = 0 ;
23255 PyObject *swig_obj[1] ;
23256
23257 if (!args) SWIG_fail;
23258 swig_obj[0] = args;
23259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23260 if (!SWIG_IsOK(res1)) {
23261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23262 }
23263 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23264 result = (wxRect *)& ((arg1)->m_rect);
23265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23266 return resultobj;
23267 fail:
23268 return NULL;
23269 }
23270
23271
23272 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23273 PyObject *obj;
23274 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23275 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23276 return SWIG_Py_Void();
23277 }
23278
23279 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23280 return SWIG_Python_InitShadowInstance(args);
23281 }
23282
23283 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23284 PyObject *resultobj = 0;
23285 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23286 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23287 int arg2 = (int) 0 ;
23288 wxMoveEvent *result = 0 ;
23289 wxPoint temp1 ;
23290 int val2 ;
23291 int ecode2 = 0 ;
23292 PyObject * obj0 = 0 ;
23293 PyObject * obj1 = 0 ;
23294 char * kwnames[] = {
23295 (char *) "pos",(char *) "winid", NULL
23296 };
23297
23298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23299 if (obj0) {
23300 {
23301 arg1 = &temp1;
23302 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23303 }
23304 }
23305 if (obj1) {
23306 ecode2 = SWIG_AsVal_int(obj1, &val2);
23307 if (!SWIG_IsOK(ecode2)) {
23308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23309 }
23310 arg2 = static_cast< int >(val2);
23311 }
23312 {
23313 PyThreadState* __tstate = wxPyBeginAllowThreads();
23314 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23315 wxPyEndAllowThreads(__tstate);
23316 if (PyErr_Occurred()) SWIG_fail;
23317 }
23318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23319 return resultobj;
23320 fail:
23321 return NULL;
23322 }
23323
23324
23325 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23326 PyObject *resultobj = 0;
23327 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23328 wxPoint result;
23329 void *argp1 = 0 ;
23330 int res1 = 0 ;
23331 PyObject *swig_obj[1] ;
23332
23333 if (!args) SWIG_fail;
23334 swig_obj[0] = args;
23335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23336 if (!SWIG_IsOK(res1)) {
23337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23338 }
23339 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23340 {
23341 PyThreadState* __tstate = wxPyBeginAllowThreads();
23342 result = ((wxMoveEvent const *)arg1)->GetPosition();
23343 wxPyEndAllowThreads(__tstate);
23344 if (PyErr_Occurred()) SWIG_fail;
23345 }
23346 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23347 return resultobj;
23348 fail:
23349 return NULL;
23350 }
23351
23352
23353 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23354 PyObject *resultobj = 0;
23355 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23356 wxRect result;
23357 void *argp1 = 0 ;
23358 int res1 = 0 ;
23359 PyObject *swig_obj[1] ;
23360
23361 if (!args) SWIG_fail;
23362 swig_obj[0] = args;
23363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23364 if (!SWIG_IsOK(res1)) {
23365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23366 }
23367 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23368 {
23369 PyThreadState* __tstate = wxPyBeginAllowThreads();
23370 result = ((wxMoveEvent const *)arg1)->GetRect();
23371 wxPyEndAllowThreads(__tstate);
23372 if (PyErr_Occurred()) SWIG_fail;
23373 }
23374 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23375 return resultobj;
23376 fail:
23377 return NULL;
23378 }
23379
23380
23381 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23382 PyObject *resultobj = 0;
23383 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23384 wxRect *arg2 = 0 ;
23385 void *argp1 = 0 ;
23386 int res1 = 0 ;
23387 wxRect temp2 ;
23388 PyObject * obj0 = 0 ;
23389 PyObject * obj1 = 0 ;
23390 char * kwnames[] = {
23391 (char *) "self",(char *) "rect", NULL
23392 };
23393
23394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23396 if (!SWIG_IsOK(res1)) {
23397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23398 }
23399 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23400 {
23401 arg2 = &temp2;
23402 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23403 }
23404 {
23405 PyThreadState* __tstate = wxPyBeginAllowThreads();
23406 (arg1)->SetRect((wxRect const &)*arg2);
23407 wxPyEndAllowThreads(__tstate);
23408 if (PyErr_Occurred()) SWIG_fail;
23409 }
23410 resultobj = SWIG_Py_Void();
23411 return resultobj;
23412 fail:
23413 return NULL;
23414 }
23415
23416
23417 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23418 PyObject *resultobj = 0;
23419 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23420 wxPoint *arg2 = 0 ;
23421 void *argp1 = 0 ;
23422 int res1 = 0 ;
23423 wxPoint temp2 ;
23424 PyObject * obj0 = 0 ;
23425 PyObject * obj1 = 0 ;
23426 char * kwnames[] = {
23427 (char *) "self",(char *) "pos", NULL
23428 };
23429
23430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23432 if (!SWIG_IsOK(res1)) {
23433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23434 }
23435 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23436 {
23437 arg2 = &temp2;
23438 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23439 }
23440 {
23441 PyThreadState* __tstate = wxPyBeginAllowThreads();
23442 (arg1)->SetPosition((wxPoint const &)*arg2);
23443 wxPyEndAllowThreads(__tstate);
23444 if (PyErr_Occurred()) SWIG_fail;
23445 }
23446 resultobj = SWIG_Py_Void();
23447 return resultobj;
23448 fail:
23449 return NULL;
23450 }
23451
23452
23453 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23454 PyObject *obj;
23455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23456 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23457 return SWIG_Py_Void();
23458 }
23459
23460 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23461 return SWIG_Python_InitShadowInstance(args);
23462 }
23463
23464 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23465 PyObject *resultobj = 0;
23466 int arg1 = (int) 0 ;
23467 wxPaintEvent *result = 0 ;
23468 int val1 ;
23469 int ecode1 = 0 ;
23470 PyObject * obj0 = 0 ;
23471 char * kwnames[] = {
23472 (char *) "Id", NULL
23473 };
23474
23475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23476 if (obj0) {
23477 ecode1 = SWIG_AsVal_int(obj0, &val1);
23478 if (!SWIG_IsOK(ecode1)) {
23479 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23480 }
23481 arg1 = static_cast< int >(val1);
23482 }
23483 {
23484 PyThreadState* __tstate = wxPyBeginAllowThreads();
23485 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23486 wxPyEndAllowThreads(__tstate);
23487 if (PyErr_Occurred()) SWIG_fail;
23488 }
23489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23490 return resultobj;
23491 fail:
23492 return NULL;
23493 }
23494
23495
23496 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23497 PyObject *obj;
23498 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23499 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23500 return SWIG_Py_Void();
23501 }
23502
23503 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23504 return SWIG_Python_InitShadowInstance(args);
23505 }
23506
23507 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23508 PyObject *resultobj = 0;
23509 int arg1 = (int) 0 ;
23510 wxNcPaintEvent *result = 0 ;
23511 int val1 ;
23512 int ecode1 = 0 ;
23513 PyObject * obj0 = 0 ;
23514 char * kwnames[] = {
23515 (char *) "winid", NULL
23516 };
23517
23518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23519 if (obj0) {
23520 ecode1 = SWIG_AsVal_int(obj0, &val1);
23521 if (!SWIG_IsOK(ecode1)) {
23522 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23523 }
23524 arg1 = static_cast< int >(val1);
23525 }
23526 {
23527 PyThreadState* __tstate = wxPyBeginAllowThreads();
23528 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23529 wxPyEndAllowThreads(__tstate);
23530 if (PyErr_Occurred()) SWIG_fail;
23531 }
23532 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23533 return resultobj;
23534 fail:
23535 return NULL;
23536 }
23537
23538
23539 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23540 PyObject *obj;
23541 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23542 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23543 return SWIG_Py_Void();
23544 }
23545
23546 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23547 return SWIG_Python_InitShadowInstance(args);
23548 }
23549
23550 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23551 PyObject *resultobj = 0;
23552 int arg1 = (int) 0 ;
23553 wxDC *arg2 = (wxDC *) NULL ;
23554 wxEraseEvent *result = 0 ;
23555 int val1 ;
23556 int ecode1 = 0 ;
23557 void *argp2 = 0 ;
23558 int res2 = 0 ;
23559 PyObject * obj0 = 0 ;
23560 PyObject * obj1 = 0 ;
23561 char * kwnames[] = {
23562 (char *) "Id",(char *) "dc", NULL
23563 };
23564
23565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23566 if (obj0) {
23567 ecode1 = SWIG_AsVal_int(obj0, &val1);
23568 if (!SWIG_IsOK(ecode1)) {
23569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23570 }
23571 arg1 = static_cast< int >(val1);
23572 }
23573 if (obj1) {
23574 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23575 if (!SWIG_IsOK(res2)) {
23576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23577 }
23578 arg2 = reinterpret_cast< wxDC * >(argp2);
23579 }
23580 {
23581 PyThreadState* __tstate = wxPyBeginAllowThreads();
23582 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23583 wxPyEndAllowThreads(__tstate);
23584 if (PyErr_Occurred()) SWIG_fail;
23585 }
23586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23587 return resultobj;
23588 fail:
23589 return NULL;
23590 }
23591
23592
23593 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23594 PyObject *resultobj = 0;
23595 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23596 wxDC *result = 0 ;
23597 void *argp1 = 0 ;
23598 int res1 = 0 ;
23599 PyObject *swig_obj[1] ;
23600
23601 if (!args) SWIG_fail;
23602 swig_obj[0] = args;
23603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23604 if (!SWIG_IsOK(res1)) {
23605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23606 }
23607 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23608 {
23609 PyThreadState* __tstate = wxPyBeginAllowThreads();
23610 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23611 wxPyEndAllowThreads(__tstate);
23612 if (PyErr_Occurred()) SWIG_fail;
23613 }
23614 {
23615 resultobj = wxPyMake_wxObject(result, (bool)0);
23616 }
23617 return resultobj;
23618 fail:
23619 return NULL;
23620 }
23621
23622
23623 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23624 PyObject *obj;
23625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23626 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23627 return SWIG_Py_Void();
23628 }
23629
23630 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23631 return SWIG_Python_InitShadowInstance(args);
23632 }
23633
23634 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23635 PyObject *resultobj = 0;
23636 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23637 int arg2 = (int) 0 ;
23638 wxFocusEvent *result = 0 ;
23639 int val1 ;
23640 int ecode1 = 0 ;
23641 int val2 ;
23642 int ecode2 = 0 ;
23643 PyObject * obj0 = 0 ;
23644 PyObject * obj1 = 0 ;
23645 char * kwnames[] = {
23646 (char *) "type",(char *) "winid", NULL
23647 };
23648
23649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23650 if (obj0) {
23651 ecode1 = SWIG_AsVal_int(obj0, &val1);
23652 if (!SWIG_IsOK(ecode1)) {
23653 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23654 }
23655 arg1 = static_cast< wxEventType >(val1);
23656 }
23657 if (obj1) {
23658 ecode2 = SWIG_AsVal_int(obj1, &val2);
23659 if (!SWIG_IsOK(ecode2)) {
23660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23661 }
23662 arg2 = static_cast< int >(val2);
23663 }
23664 {
23665 PyThreadState* __tstate = wxPyBeginAllowThreads();
23666 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23667 wxPyEndAllowThreads(__tstate);
23668 if (PyErr_Occurred()) SWIG_fail;
23669 }
23670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23671 return resultobj;
23672 fail:
23673 return NULL;
23674 }
23675
23676
23677 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23678 PyObject *resultobj = 0;
23679 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23680 wxWindow *result = 0 ;
23681 void *argp1 = 0 ;
23682 int res1 = 0 ;
23683 PyObject *swig_obj[1] ;
23684
23685 if (!args) SWIG_fail;
23686 swig_obj[0] = args;
23687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23688 if (!SWIG_IsOK(res1)) {
23689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23690 }
23691 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23692 {
23693 PyThreadState* __tstate = wxPyBeginAllowThreads();
23694 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23695 wxPyEndAllowThreads(__tstate);
23696 if (PyErr_Occurred()) SWIG_fail;
23697 }
23698 {
23699 resultobj = wxPyMake_wxObject(result, (bool)0);
23700 }
23701 return resultobj;
23702 fail:
23703 return NULL;
23704 }
23705
23706
23707 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23708 PyObject *resultobj = 0;
23709 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23710 wxWindow *arg2 = (wxWindow *) 0 ;
23711 void *argp1 = 0 ;
23712 int res1 = 0 ;
23713 void *argp2 = 0 ;
23714 int res2 = 0 ;
23715 PyObject * obj0 = 0 ;
23716 PyObject * obj1 = 0 ;
23717 char * kwnames[] = {
23718 (char *) "self",(char *) "win", NULL
23719 };
23720
23721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23723 if (!SWIG_IsOK(res1)) {
23724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23725 }
23726 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23727 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23728 if (!SWIG_IsOK(res2)) {
23729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23730 }
23731 arg2 = reinterpret_cast< wxWindow * >(argp2);
23732 {
23733 PyThreadState* __tstate = wxPyBeginAllowThreads();
23734 (arg1)->SetWindow(arg2);
23735 wxPyEndAllowThreads(__tstate);
23736 if (PyErr_Occurred()) SWIG_fail;
23737 }
23738 resultobj = SWIG_Py_Void();
23739 return resultobj;
23740 fail:
23741 return NULL;
23742 }
23743
23744
23745 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23746 PyObject *obj;
23747 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23748 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23749 return SWIG_Py_Void();
23750 }
23751
23752 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23753 return SWIG_Python_InitShadowInstance(args);
23754 }
23755
23756 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23757 PyObject *resultobj = 0;
23758 wxWindow *arg1 = (wxWindow *) NULL ;
23759 wxChildFocusEvent *result = 0 ;
23760 void *argp1 = 0 ;
23761 int res1 = 0 ;
23762 PyObject * obj0 = 0 ;
23763 char * kwnames[] = {
23764 (char *) "win", NULL
23765 };
23766
23767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23768 if (obj0) {
23769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23770 if (!SWIG_IsOK(res1)) {
23771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23772 }
23773 arg1 = reinterpret_cast< wxWindow * >(argp1);
23774 }
23775 {
23776 PyThreadState* __tstate = wxPyBeginAllowThreads();
23777 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23778 wxPyEndAllowThreads(__tstate);
23779 if (PyErr_Occurred()) SWIG_fail;
23780 }
23781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23782 return resultobj;
23783 fail:
23784 return NULL;
23785 }
23786
23787
23788 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23789 PyObject *resultobj = 0;
23790 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23791 wxWindow *result = 0 ;
23792 void *argp1 = 0 ;
23793 int res1 = 0 ;
23794 PyObject *swig_obj[1] ;
23795
23796 if (!args) SWIG_fail;
23797 swig_obj[0] = args;
23798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23799 if (!SWIG_IsOK(res1)) {
23800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23801 }
23802 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23803 {
23804 PyThreadState* __tstate = wxPyBeginAllowThreads();
23805 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23806 wxPyEndAllowThreads(__tstate);
23807 if (PyErr_Occurred()) SWIG_fail;
23808 }
23809 {
23810 resultobj = wxPyMake_wxObject(result, (bool)0);
23811 }
23812 return resultobj;
23813 fail:
23814 return NULL;
23815 }
23816
23817
23818 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23819 PyObject *obj;
23820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23821 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23822 return SWIG_Py_Void();
23823 }
23824
23825 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23826 return SWIG_Python_InitShadowInstance(args);
23827 }
23828
23829 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23830 PyObject *resultobj = 0;
23831 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23832 bool arg2 = (bool) true ;
23833 int arg3 = (int) 0 ;
23834 wxActivateEvent *result = 0 ;
23835 int val1 ;
23836 int ecode1 = 0 ;
23837 bool val2 ;
23838 int ecode2 = 0 ;
23839 int val3 ;
23840 int ecode3 = 0 ;
23841 PyObject * obj0 = 0 ;
23842 PyObject * obj1 = 0 ;
23843 PyObject * obj2 = 0 ;
23844 char * kwnames[] = {
23845 (char *) "type",(char *) "active",(char *) "Id", NULL
23846 };
23847
23848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23849 if (obj0) {
23850 ecode1 = SWIG_AsVal_int(obj0, &val1);
23851 if (!SWIG_IsOK(ecode1)) {
23852 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23853 }
23854 arg1 = static_cast< wxEventType >(val1);
23855 }
23856 if (obj1) {
23857 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23858 if (!SWIG_IsOK(ecode2)) {
23859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23860 }
23861 arg2 = static_cast< bool >(val2);
23862 }
23863 if (obj2) {
23864 ecode3 = SWIG_AsVal_int(obj2, &val3);
23865 if (!SWIG_IsOK(ecode3)) {
23866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23867 }
23868 arg3 = static_cast< int >(val3);
23869 }
23870 {
23871 PyThreadState* __tstate = wxPyBeginAllowThreads();
23872 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23873 wxPyEndAllowThreads(__tstate);
23874 if (PyErr_Occurred()) SWIG_fail;
23875 }
23876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23877 return resultobj;
23878 fail:
23879 return NULL;
23880 }
23881
23882
23883 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23884 PyObject *resultobj = 0;
23885 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23886 bool result;
23887 void *argp1 = 0 ;
23888 int res1 = 0 ;
23889 PyObject *swig_obj[1] ;
23890
23891 if (!args) SWIG_fail;
23892 swig_obj[0] = args;
23893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23894 if (!SWIG_IsOK(res1)) {
23895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23896 }
23897 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23898 {
23899 PyThreadState* __tstate = wxPyBeginAllowThreads();
23900 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23901 wxPyEndAllowThreads(__tstate);
23902 if (PyErr_Occurred()) SWIG_fail;
23903 }
23904 {
23905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23906 }
23907 return resultobj;
23908 fail:
23909 return NULL;
23910 }
23911
23912
23913 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23914 PyObject *obj;
23915 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23916 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23917 return SWIG_Py_Void();
23918 }
23919
23920 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23921 return SWIG_Python_InitShadowInstance(args);
23922 }
23923
23924 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23925 PyObject *resultobj = 0;
23926 int arg1 = (int) 0 ;
23927 wxInitDialogEvent *result = 0 ;
23928 int val1 ;
23929 int ecode1 = 0 ;
23930 PyObject * obj0 = 0 ;
23931 char * kwnames[] = {
23932 (char *) "Id", NULL
23933 };
23934
23935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23936 if (obj0) {
23937 ecode1 = SWIG_AsVal_int(obj0, &val1);
23938 if (!SWIG_IsOK(ecode1)) {
23939 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23940 }
23941 arg1 = static_cast< int >(val1);
23942 }
23943 {
23944 PyThreadState* __tstate = wxPyBeginAllowThreads();
23945 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23946 wxPyEndAllowThreads(__tstate);
23947 if (PyErr_Occurred()) SWIG_fail;
23948 }
23949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23950 return resultobj;
23951 fail:
23952 return NULL;
23953 }
23954
23955
23956 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23957 PyObject *obj;
23958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23959 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23960 return SWIG_Py_Void();
23961 }
23962
23963 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23964 return SWIG_Python_InitShadowInstance(args);
23965 }
23966
23967 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23968 PyObject *resultobj = 0;
23969 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23970 int arg2 = (int) 0 ;
23971 wxMenu *arg3 = (wxMenu *) NULL ;
23972 wxMenuEvent *result = 0 ;
23973 int val1 ;
23974 int ecode1 = 0 ;
23975 int val2 ;
23976 int ecode2 = 0 ;
23977 void *argp3 = 0 ;
23978 int res3 = 0 ;
23979 PyObject * obj0 = 0 ;
23980 PyObject * obj1 = 0 ;
23981 PyObject * obj2 = 0 ;
23982 char * kwnames[] = {
23983 (char *) "type",(char *) "winid",(char *) "menu", NULL
23984 };
23985
23986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23987 if (obj0) {
23988 ecode1 = SWIG_AsVal_int(obj0, &val1);
23989 if (!SWIG_IsOK(ecode1)) {
23990 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23991 }
23992 arg1 = static_cast< wxEventType >(val1);
23993 }
23994 if (obj1) {
23995 ecode2 = SWIG_AsVal_int(obj1, &val2);
23996 if (!SWIG_IsOK(ecode2)) {
23997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23998 }
23999 arg2 = static_cast< int >(val2);
24000 }
24001 if (obj2) {
24002 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24003 if (!SWIG_IsOK(res3)) {
24004 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24005 }
24006 arg3 = reinterpret_cast< wxMenu * >(argp3);
24007 }
24008 {
24009 PyThreadState* __tstate = wxPyBeginAllowThreads();
24010 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24011 wxPyEndAllowThreads(__tstate);
24012 if (PyErr_Occurred()) SWIG_fail;
24013 }
24014 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24015 return resultobj;
24016 fail:
24017 return NULL;
24018 }
24019
24020
24021 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24022 PyObject *resultobj = 0;
24023 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24024 int result;
24025 void *argp1 = 0 ;
24026 int res1 = 0 ;
24027 PyObject *swig_obj[1] ;
24028
24029 if (!args) SWIG_fail;
24030 swig_obj[0] = args;
24031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24032 if (!SWIG_IsOK(res1)) {
24033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24034 }
24035 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24036 {
24037 PyThreadState* __tstate = wxPyBeginAllowThreads();
24038 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24039 wxPyEndAllowThreads(__tstate);
24040 if (PyErr_Occurred()) SWIG_fail;
24041 }
24042 resultobj = SWIG_From_int(static_cast< int >(result));
24043 return resultobj;
24044 fail:
24045 return NULL;
24046 }
24047
24048
24049 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24050 PyObject *resultobj = 0;
24051 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24052 bool result;
24053 void *argp1 = 0 ;
24054 int res1 = 0 ;
24055 PyObject *swig_obj[1] ;
24056
24057 if (!args) SWIG_fail;
24058 swig_obj[0] = args;
24059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24060 if (!SWIG_IsOK(res1)) {
24061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24062 }
24063 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24064 {
24065 PyThreadState* __tstate = wxPyBeginAllowThreads();
24066 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24067 wxPyEndAllowThreads(__tstate);
24068 if (PyErr_Occurred()) SWIG_fail;
24069 }
24070 {
24071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24072 }
24073 return resultobj;
24074 fail:
24075 return NULL;
24076 }
24077
24078
24079 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24080 PyObject *resultobj = 0;
24081 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24082 wxMenu *result = 0 ;
24083 void *argp1 = 0 ;
24084 int res1 = 0 ;
24085 PyObject *swig_obj[1] ;
24086
24087 if (!args) SWIG_fail;
24088 swig_obj[0] = args;
24089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24090 if (!SWIG_IsOK(res1)) {
24091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24092 }
24093 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24094 {
24095 PyThreadState* __tstate = wxPyBeginAllowThreads();
24096 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24097 wxPyEndAllowThreads(__tstate);
24098 if (PyErr_Occurred()) SWIG_fail;
24099 }
24100 {
24101 resultobj = wxPyMake_wxObject(result, (bool)0);
24102 }
24103 return resultobj;
24104 fail:
24105 return NULL;
24106 }
24107
24108
24109 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24110 PyObject *obj;
24111 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24112 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24113 return SWIG_Py_Void();
24114 }
24115
24116 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24117 return SWIG_Python_InitShadowInstance(args);
24118 }
24119
24120 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24121 PyObject *resultobj = 0;
24122 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24123 int arg2 = (int) 0 ;
24124 wxCloseEvent *result = 0 ;
24125 int val1 ;
24126 int ecode1 = 0 ;
24127 int val2 ;
24128 int ecode2 = 0 ;
24129 PyObject * obj0 = 0 ;
24130 PyObject * obj1 = 0 ;
24131 char * kwnames[] = {
24132 (char *) "type",(char *) "winid", NULL
24133 };
24134
24135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24136 if (obj0) {
24137 ecode1 = SWIG_AsVal_int(obj0, &val1);
24138 if (!SWIG_IsOK(ecode1)) {
24139 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24140 }
24141 arg1 = static_cast< wxEventType >(val1);
24142 }
24143 if (obj1) {
24144 ecode2 = SWIG_AsVal_int(obj1, &val2);
24145 if (!SWIG_IsOK(ecode2)) {
24146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24147 }
24148 arg2 = static_cast< int >(val2);
24149 }
24150 {
24151 PyThreadState* __tstate = wxPyBeginAllowThreads();
24152 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24153 wxPyEndAllowThreads(__tstate);
24154 if (PyErr_Occurred()) SWIG_fail;
24155 }
24156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24157 return resultobj;
24158 fail:
24159 return NULL;
24160 }
24161
24162
24163 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24164 PyObject *resultobj = 0;
24165 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24166 bool arg2 ;
24167 void *argp1 = 0 ;
24168 int res1 = 0 ;
24169 bool val2 ;
24170 int ecode2 = 0 ;
24171 PyObject * obj0 = 0 ;
24172 PyObject * obj1 = 0 ;
24173 char * kwnames[] = {
24174 (char *) "self",(char *) "logOff", NULL
24175 };
24176
24177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24179 if (!SWIG_IsOK(res1)) {
24180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24181 }
24182 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24183 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24184 if (!SWIG_IsOK(ecode2)) {
24185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24186 }
24187 arg2 = static_cast< bool >(val2);
24188 {
24189 PyThreadState* __tstate = wxPyBeginAllowThreads();
24190 (arg1)->SetLoggingOff(arg2);
24191 wxPyEndAllowThreads(__tstate);
24192 if (PyErr_Occurred()) SWIG_fail;
24193 }
24194 resultobj = SWIG_Py_Void();
24195 return resultobj;
24196 fail:
24197 return NULL;
24198 }
24199
24200
24201 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24202 PyObject *resultobj = 0;
24203 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24204 bool result;
24205 void *argp1 = 0 ;
24206 int res1 = 0 ;
24207 PyObject *swig_obj[1] ;
24208
24209 if (!args) SWIG_fail;
24210 swig_obj[0] = args;
24211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24212 if (!SWIG_IsOK(res1)) {
24213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24214 }
24215 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24216 {
24217 PyThreadState* __tstate = wxPyBeginAllowThreads();
24218 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24219 wxPyEndAllowThreads(__tstate);
24220 if (PyErr_Occurred()) SWIG_fail;
24221 }
24222 {
24223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24224 }
24225 return resultobj;
24226 fail:
24227 return NULL;
24228 }
24229
24230
24231 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24232 PyObject *resultobj = 0;
24233 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24234 bool arg2 = (bool) true ;
24235 void *argp1 = 0 ;
24236 int res1 = 0 ;
24237 bool val2 ;
24238 int ecode2 = 0 ;
24239 PyObject * obj0 = 0 ;
24240 PyObject * obj1 = 0 ;
24241 char * kwnames[] = {
24242 (char *) "self",(char *) "veto", NULL
24243 };
24244
24245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24247 if (!SWIG_IsOK(res1)) {
24248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24249 }
24250 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24251 if (obj1) {
24252 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24253 if (!SWIG_IsOK(ecode2)) {
24254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24255 }
24256 arg2 = static_cast< bool >(val2);
24257 }
24258 {
24259 PyThreadState* __tstate = wxPyBeginAllowThreads();
24260 (arg1)->Veto(arg2);
24261 wxPyEndAllowThreads(__tstate);
24262 if (PyErr_Occurred()) SWIG_fail;
24263 }
24264 resultobj = SWIG_Py_Void();
24265 return resultobj;
24266 fail:
24267 return NULL;
24268 }
24269
24270
24271 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24272 PyObject *resultobj = 0;
24273 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24274 bool result;
24275 void *argp1 = 0 ;
24276 int res1 = 0 ;
24277 PyObject *swig_obj[1] ;
24278
24279 if (!args) SWIG_fail;
24280 swig_obj[0] = args;
24281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24282 if (!SWIG_IsOK(res1)) {
24283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24284 }
24285 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24286 {
24287 PyThreadState* __tstate = wxPyBeginAllowThreads();
24288 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24289 wxPyEndAllowThreads(__tstate);
24290 if (PyErr_Occurred()) SWIG_fail;
24291 }
24292 {
24293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24294 }
24295 return resultobj;
24296 fail:
24297 return NULL;
24298 }
24299
24300
24301 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24302 PyObject *resultobj = 0;
24303 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24304 bool arg2 ;
24305 void *argp1 = 0 ;
24306 int res1 = 0 ;
24307 bool val2 ;
24308 int ecode2 = 0 ;
24309 PyObject * obj0 = 0 ;
24310 PyObject * obj1 = 0 ;
24311 char * kwnames[] = {
24312 (char *) "self",(char *) "canVeto", NULL
24313 };
24314
24315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24317 if (!SWIG_IsOK(res1)) {
24318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24319 }
24320 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24321 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24322 if (!SWIG_IsOK(ecode2)) {
24323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24324 }
24325 arg2 = static_cast< bool >(val2);
24326 {
24327 PyThreadState* __tstate = wxPyBeginAllowThreads();
24328 (arg1)->SetCanVeto(arg2);
24329 wxPyEndAllowThreads(__tstate);
24330 if (PyErr_Occurred()) SWIG_fail;
24331 }
24332 resultobj = SWIG_Py_Void();
24333 return resultobj;
24334 fail:
24335 return NULL;
24336 }
24337
24338
24339 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24340 PyObject *resultobj = 0;
24341 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24342 bool result;
24343 void *argp1 = 0 ;
24344 int res1 = 0 ;
24345 PyObject *swig_obj[1] ;
24346
24347 if (!args) SWIG_fail;
24348 swig_obj[0] = args;
24349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24350 if (!SWIG_IsOK(res1)) {
24351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24352 }
24353 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24354 {
24355 PyThreadState* __tstate = wxPyBeginAllowThreads();
24356 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24357 wxPyEndAllowThreads(__tstate);
24358 if (PyErr_Occurred()) SWIG_fail;
24359 }
24360 {
24361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24362 }
24363 return resultobj;
24364 fail:
24365 return NULL;
24366 }
24367
24368
24369 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24370 PyObject *obj;
24371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24372 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24373 return SWIG_Py_Void();
24374 }
24375
24376 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24377 return SWIG_Python_InitShadowInstance(args);
24378 }
24379
24380 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24381 PyObject *resultobj = 0;
24382 int arg1 = (int) 0 ;
24383 bool arg2 = (bool) false ;
24384 wxShowEvent *result = 0 ;
24385 int val1 ;
24386 int ecode1 = 0 ;
24387 bool val2 ;
24388 int ecode2 = 0 ;
24389 PyObject * obj0 = 0 ;
24390 PyObject * obj1 = 0 ;
24391 char * kwnames[] = {
24392 (char *) "winid",(char *) "show", NULL
24393 };
24394
24395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24396 if (obj0) {
24397 ecode1 = SWIG_AsVal_int(obj0, &val1);
24398 if (!SWIG_IsOK(ecode1)) {
24399 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24400 }
24401 arg1 = static_cast< int >(val1);
24402 }
24403 if (obj1) {
24404 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24405 if (!SWIG_IsOK(ecode2)) {
24406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24407 }
24408 arg2 = static_cast< bool >(val2);
24409 }
24410 {
24411 PyThreadState* __tstate = wxPyBeginAllowThreads();
24412 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24413 wxPyEndAllowThreads(__tstate);
24414 if (PyErr_Occurred()) SWIG_fail;
24415 }
24416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24417 return resultobj;
24418 fail:
24419 return NULL;
24420 }
24421
24422
24423 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24424 PyObject *resultobj = 0;
24425 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24426 bool arg2 ;
24427 void *argp1 = 0 ;
24428 int res1 = 0 ;
24429 bool val2 ;
24430 int ecode2 = 0 ;
24431 PyObject * obj0 = 0 ;
24432 PyObject * obj1 = 0 ;
24433 char * kwnames[] = {
24434 (char *) "self",(char *) "show", NULL
24435 };
24436
24437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24439 if (!SWIG_IsOK(res1)) {
24440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24441 }
24442 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24443 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24444 if (!SWIG_IsOK(ecode2)) {
24445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24446 }
24447 arg2 = static_cast< bool >(val2);
24448 {
24449 PyThreadState* __tstate = wxPyBeginAllowThreads();
24450 (arg1)->SetShow(arg2);
24451 wxPyEndAllowThreads(__tstate);
24452 if (PyErr_Occurred()) SWIG_fail;
24453 }
24454 resultobj = SWIG_Py_Void();
24455 return resultobj;
24456 fail:
24457 return NULL;
24458 }
24459
24460
24461 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24462 PyObject *resultobj = 0;
24463 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24464 bool result;
24465 void *argp1 = 0 ;
24466 int res1 = 0 ;
24467 PyObject *swig_obj[1] ;
24468
24469 if (!args) SWIG_fail;
24470 swig_obj[0] = args;
24471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24472 if (!SWIG_IsOK(res1)) {
24473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24474 }
24475 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24476 {
24477 PyThreadState* __tstate = wxPyBeginAllowThreads();
24478 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24479 wxPyEndAllowThreads(__tstate);
24480 if (PyErr_Occurred()) SWIG_fail;
24481 }
24482 {
24483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24484 }
24485 return resultobj;
24486 fail:
24487 return NULL;
24488 }
24489
24490
24491 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24492 PyObject *obj;
24493 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24494 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24495 return SWIG_Py_Void();
24496 }
24497
24498 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24499 return SWIG_Python_InitShadowInstance(args);
24500 }
24501
24502 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24503 PyObject *resultobj = 0;
24504 int arg1 = (int) 0 ;
24505 bool arg2 = (bool) true ;
24506 wxIconizeEvent *result = 0 ;
24507 int val1 ;
24508 int ecode1 = 0 ;
24509 bool val2 ;
24510 int ecode2 = 0 ;
24511 PyObject * obj0 = 0 ;
24512 PyObject * obj1 = 0 ;
24513 char * kwnames[] = {
24514 (char *) "id",(char *) "iconized", NULL
24515 };
24516
24517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24518 if (obj0) {
24519 ecode1 = SWIG_AsVal_int(obj0, &val1);
24520 if (!SWIG_IsOK(ecode1)) {
24521 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24522 }
24523 arg1 = static_cast< int >(val1);
24524 }
24525 if (obj1) {
24526 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24527 if (!SWIG_IsOK(ecode2)) {
24528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24529 }
24530 arg2 = static_cast< bool >(val2);
24531 }
24532 {
24533 PyThreadState* __tstate = wxPyBeginAllowThreads();
24534 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24535 wxPyEndAllowThreads(__tstate);
24536 if (PyErr_Occurred()) SWIG_fail;
24537 }
24538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24539 return resultobj;
24540 fail:
24541 return NULL;
24542 }
24543
24544
24545 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24546 PyObject *resultobj = 0;
24547 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24548 bool result;
24549 void *argp1 = 0 ;
24550 int res1 = 0 ;
24551 PyObject *swig_obj[1] ;
24552
24553 if (!args) SWIG_fail;
24554 swig_obj[0] = args;
24555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24556 if (!SWIG_IsOK(res1)) {
24557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24558 }
24559 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24560 {
24561 PyThreadState* __tstate = wxPyBeginAllowThreads();
24562 result = (bool)(arg1)->Iconized();
24563 wxPyEndAllowThreads(__tstate);
24564 if (PyErr_Occurred()) SWIG_fail;
24565 }
24566 {
24567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24568 }
24569 return resultobj;
24570 fail:
24571 return NULL;
24572 }
24573
24574
24575 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24576 PyObject *obj;
24577 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24578 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24579 return SWIG_Py_Void();
24580 }
24581
24582 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24583 return SWIG_Python_InitShadowInstance(args);
24584 }
24585
24586 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24587 PyObject *resultobj = 0;
24588 int arg1 = (int) 0 ;
24589 wxMaximizeEvent *result = 0 ;
24590 int val1 ;
24591 int ecode1 = 0 ;
24592 PyObject * obj0 = 0 ;
24593 char * kwnames[] = {
24594 (char *) "id", NULL
24595 };
24596
24597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24598 if (obj0) {
24599 ecode1 = SWIG_AsVal_int(obj0, &val1);
24600 if (!SWIG_IsOK(ecode1)) {
24601 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24602 }
24603 arg1 = static_cast< int >(val1);
24604 }
24605 {
24606 PyThreadState* __tstate = wxPyBeginAllowThreads();
24607 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24608 wxPyEndAllowThreads(__tstate);
24609 if (PyErr_Occurred()) SWIG_fail;
24610 }
24611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24612 return resultobj;
24613 fail:
24614 return NULL;
24615 }
24616
24617
24618 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24619 PyObject *obj;
24620 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24621 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24622 return SWIG_Py_Void();
24623 }
24624
24625 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24626 return SWIG_Python_InitShadowInstance(args);
24627 }
24628
24629 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24630 PyObject *resultobj = 0;
24631 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24632 wxPoint result;
24633 void *argp1 = 0 ;
24634 int res1 = 0 ;
24635 PyObject *swig_obj[1] ;
24636
24637 if (!args) SWIG_fail;
24638 swig_obj[0] = args;
24639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24640 if (!SWIG_IsOK(res1)) {
24641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24642 }
24643 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24644 {
24645 PyThreadState* __tstate = wxPyBeginAllowThreads();
24646 result = (arg1)->GetPosition();
24647 wxPyEndAllowThreads(__tstate);
24648 if (PyErr_Occurred()) SWIG_fail;
24649 }
24650 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24651 return resultobj;
24652 fail:
24653 return NULL;
24654 }
24655
24656
24657 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24658 PyObject *resultobj = 0;
24659 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24660 int result;
24661 void *argp1 = 0 ;
24662 int res1 = 0 ;
24663 PyObject *swig_obj[1] ;
24664
24665 if (!args) SWIG_fail;
24666 swig_obj[0] = args;
24667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24668 if (!SWIG_IsOK(res1)) {
24669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24670 }
24671 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24672 {
24673 PyThreadState* __tstate = wxPyBeginAllowThreads();
24674 result = (int)(arg1)->GetNumberOfFiles();
24675 wxPyEndAllowThreads(__tstate);
24676 if (PyErr_Occurred()) SWIG_fail;
24677 }
24678 resultobj = SWIG_From_int(static_cast< int >(result));
24679 return resultobj;
24680 fail:
24681 return NULL;
24682 }
24683
24684
24685 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24686 PyObject *resultobj = 0;
24687 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24688 PyObject *result = 0 ;
24689 void *argp1 = 0 ;
24690 int res1 = 0 ;
24691 PyObject *swig_obj[1] ;
24692
24693 if (!args) SWIG_fail;
24694 swig_obj[0] = args;
24695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24696 if (!SWIG_IsOK(res1)) {
24697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24698 }
24699 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24700 {
24701 PyThreadState* __tstate = wxPyBeginAllowThreads();
24702 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24703 wxPyEndAllowThreads(__tstate);
24704 if (PyErr_Occurred()) SWIG_fail;
24705 }
24706 resultobj = result;
24707 return resultobj;
24708 fail:
24709 return NULL;
24710 }
24711
24712
24713 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24714 PyObject *obj;
24715 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24716 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24717 return SWIG_Py_Void();
24718 }
24719
24720 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24721 PyObject *resultobj = 0;
24722 int arg1 = (int) 0 ;
24723 wxUpdateUIEvent *result = 0 ;
24724 int val1 ;
24725 int ecode1 = 0 ;
24726 PyObject * obj0 = 0 ;
24727 char * kwnames[] = {
24728 (char *) "commandId", NULL
24729 };
24730
24731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24732 if (obj0) {
24733 ecode1 = SWIG_AsVal_int(obj0, &val1);
24734 if (!SWIG_IsOK(ecode1)) {
24735 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24736 }
24737 arg1 = static_cast< int >(val1);
24738 }
24739 {
24740 PyThreadState* __tstate = wxPyBeginAllowThreads();
24741 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24742 wxPyEndAllowThreads(__tstate);
24743 if (PyErr_Occurred()) SWIG_fail;
24744 }
24745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24746 return resultobj;
24747 fail:
24748 return NULL;
24749 }
24750
24751
24752 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24753 PyObject *resultobj = 0;
24754 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24755 bool result;
24756 void *argp1 = 0 ;
24757 int res1 = 0 ;
24758 PyObject *swig_obj[1] ;
24759
24760 if (!args) SWIG_fail;
24761 swig_obj[0] = args;
24762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24763 if (!SWIG_IsOK(res1)) {
24764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24765 }
24766 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24767 {
24768 PyThreadState* __tstate = wxPyBeginAllowThreads();
24769 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24770 wxPyEndAllowThreads(__tstate);
24771 if (PyErr_Occurred()) SWIG_fail;
24772 }
24773 {
24774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24775 }
24776 return resultobj;
24777 fail:
24778 return NULL;
24779 }
24780
24781
24782 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24783 PyObject *resultobj = 0;
24784 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24785 bool result;
24786 void *argp1 = 0 ;
24787 int res1 = 0 ;
24788 PyObject *swig_obj[1] ;
24789
24790 if (!args) SWIG_fail;
24791 swig_obj[0] = args;
24792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24793 if (!SWIG_IsOK(res1)) {
24794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24795 }
24796 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24797 {
24798 PyThreadState* __tstate = wxPyBeginAllowThreads();
24799 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24800 wxPyEndAllowThreads(__tstate);
24801 if (PyErr_Occurred()) SWIG_fail;
24802 }
24803 {
24804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24805 }
24806 return resultobj;
24807 fail:
24808 return NULL;
24809 }
24810
24811
24812 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24813 PyObject *resultobj = 0;
24814 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24815 bool result;
24816 void *argp1 = 0 ;
24817 int res1 = 0 ;
24818 PyObject *swig_obj[1] ;
24819
24820 if (!args) SWIG_fail;
24821 swig_obj[0] = args;
24822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24823 if (!SWIG_IsOK(res1)) {
24824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24825 }
24826 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24827 {
24828 PyThreadState* __tstate = wxPyBeginAllowThreads();
24829 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24830 wxPyEndAllowThreads(__tstate);
24831 if (PyErr_Occurred()) SWIG_fail;
24832 }
24833 {
24834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24835 }
24836 return resultobj;
24837 fail:
24838 return NULL;
24839 }
24840
24841
24842 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24843 PyObject *resultobj = 0;
24844 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24845 wxString result;
24846 void *argp1 = 0 ;
24847 int res1 = 0 ;
24848 PyObject *swig_obj[1] ;
24849
24850 if (!args) SWIG_fail;
24851 swig_obj[0] = args;
24852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24853 if (!SWIG_IsOK(res1)) {
24854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24855 }
24856 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24857 {
24858 PyThreadState* __tstate = wxPyBeginAllowThreads();
24859 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24860 wxPyEndAllowThreads(__tstate);
24861 if (PyErr_Occurred()) SWIG_fail;
24862 }
24863 {
24864 #if wxUSE_UNICODE
24865 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24866 #else
24867 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24868 #endif
24869 }
24870 return resultobj;
24871 fail:
24872 return NULL;
24873 }
24874
24875
24876 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24877 PyObject *resultobj = 0;
24878 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24879 bool result;
24880 void *argp1 = 0 ;
24881 int res1 = 0 ;
24882 PyObject *swig_obj[1] ;
24883
24884 if (!args) SWIG_fail;
24885 swig_obj[0] = args;
24886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24887 if (!SWIG_IsOK(res1)) {
24888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24889 }
24890 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24891 {
24892 PyThreadState* __tstate = wxPyBeginAllowThreads();
24893 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24894 wxPyEndAllowThreads(__tstate);
24895 if (PyErr_Occurred()) SWIG_fail;
24896 }
24897 {
24898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24899 }
24900 return resultobj;
24901 fail:
24902 return NULL;
24903 }
24904
24905
24906 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24907 PyObject *resultobj = 0;
24908 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24909 bool result;
24910 void *argp1 = 0 ;
24911 int res1 = 0 ;
24912 PyObject *swig_obj[1] ;
24913
24914 if (!args) SWIG_fail;
24915 swig_obj[0] = args;
24916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24917 if (!SWIG_IsOK(res1)) {
24918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24919 }
24920 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24921 {
24922 PyThreadState* __tstate = wxPyBeginAllowThreads();
24923 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24924 wxPyEndAllowThreads(__tstate);
24925 if (PyErr_Occurred()) SWIG_fail;
24926 }
24927 {
24928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24929 }
24930 return resultobj;
24931 fail:
24932 return NULL;
24933 }
24934
24935
24936 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24937 PyObject *resultobj = 0;
24938 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24939 bool result;
24940 void *argp1 = 0 ;
24941 int res1 = 0 ;
24942 PyObject *swig_obj[1] ;
24943
24944 if (!args) SWIG_fail;
24945 swig_obj[0] = args;
24946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24947 if (!SWIG_IsOK(res1)) {
24948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24949 }
24950 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24951 {
24952 PyThreadState* __tstate = wxPyBeginAllowThreads();
24953 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24954 wxPyEndAllowThreads(__tstate);
24955 if (PyErr_Occurred()) SWIG_fail;
24956 }
24957 {
24958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24959 }
24960 return resultobj;
24961 fail:
24962 return NULL;
24963 }
24964
24965
24966 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24967 PyObject *resultobj = 0;
24968 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24969 bool result;
24970 void *argp1 = 0 ;
24971 int res1 = 0 ;
24972 PyObject *swig_obj[1] ;
24973
24974 if (!args) SWIG_fail;
24975 swig_obj[0] = args;
24976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24977 if (!SWIG_IsOK(res1)) {
24978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24979 }
24980 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24981 {
24982 PyThreadState* __tstate = wxPyBeginAllowThreads();
24983 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24984 wxPyEndAllowThreads(__tstate);
24985 if (PyErr_Occurred()) SWIG_fail;
24986 }
24987 {
24988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24989 }
24990 return resultobj;
24991 fail:
24992 return NULL;
24993 }
24994
24995
24996 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24997 PyObject *resultobj = 0;
24998 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24999 bool arg2 ;
25000 void *argp1 = 0 ;
25001 int res1 = 0 ;
25002 bool val2 ;
25003 int ecode2 = 0 ;
25004 PyObject * obj0 = 0 ;
25005 PyObject * obj1 = 0 ;
25006 char * kwnames[] = {
25007 (char *) "self",(char *) "check", NULL
25008 };
25009
25010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25012 if (!SWIG_IsOK(res1)) {
25013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25014 }
25015 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25016 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25017 if (!SWIG_IsOK(ecode2)) {
25018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25019 }
25020 arg2 = static_cast< bool >(val2);
25021 {
25022 PyThreadState* __tstate = wxPyBeginAllowThreads();
25023 (arg1)->Check(arg2);
25024 wxPyEndAllowThreads(__tstate);
25025 if (PyErr_Occurred()) SWIG_fail;
25026 }
25027 resultobj = SWIG_Py_Void();
25028 return resultobj;
25029 fail:
25030 return NULL;
25031 }
25032
25033
25034 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25035 PyObject *resultobj = 0;
25036 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25037 bool arg2 ;
25038 void *argp1 = 0 ;
25039 int res1 = 0 ;
25040 bool val2 ;
25041 int ecode2 = 0 ;
25042 PyObject * obj0 = 0 ;
25043 PyObject * obj1 = 0 ;
25044 char * kwnames[] = {
25045 (char *) "self",(char *) "enable", NULL
25046 };
25047
25048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25050 if (!SWIG_IsOK(res1)) {
25051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25052 }
25053 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25054 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25055 if (!SWIG_IsOK(ecode2)) {
25056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25057 }
25058 arg2 = static_cast< bool >(val2);
25059 {
25060 PyThreadState* __tstate = wxPyBeginAllowThreads();
25061 (arg1)->Enable(arg2);
25062 wxPyEndAllowThreads(__tstate);
25063 if (PyErr_Occurred()) SWIG_fail;
25064 }
25065 resultobj = SWIG_Py_Void();
25066 return resultobj;
25067 fail:
25068 return NULL;
25069 }
25070
25071
25072 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25073 PyObject *resultobj = 0;
25074 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25075 bool arg2 ;
25076 void *argp1 = 0 ;
25077 int res1 = 0 ;
25078 bool val2 ;
25079 int ecode2 = 0 ;
25080 PyObject * obj0 = 0 ;
25081 PyObject * obj1 = 0 ;
25082 char * kwnames[] = {
25083 (char *) "self",(char *) "show", NULL
25084 };
25085
25086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25088 if (!SWIG_IsOK(res1)) {
25089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25090 }
25091 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25092 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25093 if (!SWIG_IsOK(ecode2)) {
25094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25095 }
25096 arg2 = static_cast< bool >(val2);
25097 {
25098 PyThreadState* __tstate = wxPyBeginAllowThreads();
25099 (arg1)->Show(arg2);
25100 wxPyEndAllowThreads(__tstate);
25101 if (PyErr_Occurred()) SWIG_fail;
25102 }
25103 resultobj = SWIG_Py_Void();
25104 return resultobj;
25105 fail:
25106 return NULL;
25107 }
25108
25109
25110 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25111 PyObject *resultobj = 0;
25112 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25113 wxString *arg2 = 0 ;
25114 void *argp1 = 0 ;
25115 int res1 = 0 ;
25116 bool temp2 = false ;
25117 PyObject * obj0 = 0 ;
25118 PyObject * obj1 = 0 ;
25119 char * kwnames[] = {
25120 (char *) "self",(char *) "text", NULL
25121 };
25122
25123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25125 if (!SWIG_IsOK(res1)) {
25126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25127 }
25128 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25129 {
25130 arg2 = wxString_in_helper(obj1);
25131 if (arg2 == NULL) SWIG_fail;
25132 temp2 = true;
25133 }
25134 {
25135 PyThreadState* __tstate = wxPyBeginAllowThreads();
25136 (arg1)->SetText((wxString const &)*arg2);
25137 wxPyEndAllowThreads(__tstate);
25138 if (PyErr_Occurred()) SWIG_fail;
25139 }
25140 resultobj = SWIG_Py_Void();
25141 {
25142 if (temp2)
25143 delete arg2;
25144 }
25145 return resultobj;
25146 fail:
25147 {
25148 if (temp2)
25149 delete arg2;
25150 }
25151 return NULL;
25152 }
25153
25154
25155 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25156 PyObject *resultobj = 0;
25157 long arg1 ;
25158 long val1 ;
25159 int ecode1 = 0 ;
25160 PyObject * obj0 = 0 ;
25161 char * kwnames[] = {
25162 (char *) "updateInterval", NULL
25163 };
25164
25165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25166 ecode1 = SWIG_AsVal_long(obj0, &val1);
25167 if (!SWIG_IsOK(ecode1)) {
25168 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25169 }
25170 arg1 = static_cast< long >(val1);
25171 {
25172 PyThreadState* __tstate = wxPyBeginAllowThreads();
25173 wxUpdateUIEvent::SetUpdateInterval(arg1);
25174 wxPyEndAllowThreads(__tstate);
25175 if (PyErr_Occurred()) SWIG_fail;
25176 }
25177 resultobj = SWIG_Py_Void();
25178 return resultobj;
25179 fail:
25180 return NULL;
25181 }
25182
25183
25184 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25185 PyObject *resultobj = 0;
25186 long result;
25187
25188 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25189 {
25190 PyThreadState* __tstate = wxPyBeginAllowThreads();
25191 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25192 wxPyEndAllowThreads(__tstate);
25193 if (PyErr_Occurred()) SWIG_fail;
25194 }
25195 resultobj = SWIG_From_long(static_cast< long >(result));
25196 return resultobj;
25197 fail:
25198 return NULL;
25199 }
25200
25201
25202 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25203 PyObject *resultobj = 0;
25204 wxWindow *arg1 = (wxWindow *) 0 ;
25205 bool result;
25206 void *argp1 = 0 ;
25207 int res1 = 0 ;
25208 PyObject * obj0 = 0 ;
25209 char * kwnames[] = {
25210 (char *) "win", NULL
25211 };
25212
25213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25215 if (!SWIG_IsOK(res1)) {
25216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25217 }
25218 arg1 = reinterpret_cast< wxWindow * >(argp1);
25219 {
25220 PyThreadState* __tstate = wxPyBeginAllowThreads();
25221 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25222 wxPyEndAllowThreads(__tstate);
25223 if (PyErr_Occurred()) SWIG_fail;
25224 }
25225 {
25226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25227 }
25228 return resultobj;
25229 fail:
25230 return NULL;
25231 }
25232
25233
25234 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25235 PyObject *resultobj = 0;
25236
25237 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25238 {
25239 PyThreadState* __tstate = wxPyBeginAllowThreads();
25240 wxUpdateUIEvent::ResetUpdateTime();
25241 wxPyEndAllowThreads(__tstate);
25242 if (PyErr_Occurred()) SWIG_fail;
25243 }
25244 resultobj = SWIG_Py_Void();
25245 return resultobj;
25246 fail:
25247 return NULL;
25248 }
25249
25250
25251 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25252 PyObject *resultobj = 0;
25253 wxUpdateUIMode arg1 ;
25254 int val1 ;
25255 int ecode1 = 0 ;
25256 PyObject * obj0 = 0 ;
25257 char * kwnames[] = {
25258 (char *) "mode", NULL
25259 };
25260
25261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25262 ecode1 = SWIG_AsVal_int(obj0, &val1);
25263 if (!SWIG_IsOK(ecode1)) {
25264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25265 }
25266 arg1 = static_cast< wxUpdateUIMode >(val1);
25267 {
25268 PyThreadState* __tstate = wxPyBeginAllowThreads();
25269 wxUpdateUIEvent::SetMode(arg1);
25270 wxPyEndAllowThreads(__tstate);
25271 if (PyErr_Occurred()) SWIG_fail;
25272 }
25273 resultobj = SWIG_Py_Void();
25274 return resultobj;
25275 fail:
25276 return NULL;
25277 }
25278
25279
25280 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25281 PyObject *resultobj = 0;
25282 wxUpdateUIMode result;
25283
25284 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25285 {
25286 PyThreadState* __tstate = wxPyBeginAllowThreads();
25287 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25288 wxPyEndAllowThreads(__tstate);
25289 if (PyErr_Occurred()) SWIG_fail;
25290 }
25291 resultobj = SWIG_From_int(static_cast< int >(result));
25292 return resultobj;
25293 fail:
25294 return NULL;
25295 }
25296
25297
25298 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25299 PyObject *obj;
25300 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25301 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25302 return SWIG_Py_Void();
25303 }
25304
25305 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25306 return SWIG_Python_InitShadowInstance(args);
25307 }
25308
25309 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25310 PyObject *resultobj = 0;
25311 wxSysColourChangedEvent *result = 0 ;
25312
25313 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25314 {
25315 PyThreadState* __tstate = wxPyBeginAllowThreads();
25316 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25317 wxPyEndAllowThreads(__tstate);
25318 if (PyErr_Occurred()) SWIG_fail;
25319 }
25320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25321 return resultobj;
25322 fail:
25323 return NULL;
25324 }
25325
25326
25327 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25328 PyObject *obj;
25329 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25330 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25331 return SWIG_Py_Void();
25332 }
25333
25334 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25335 return SWIG_Python_InitShadowInstance(args);
25336 }
25337
25338 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25339 PyObject *resultobj = 0;
25340 int arg1 = (int) 0 ;
25341 wxWindow *arg2 = (wxWindow *) NULL ;
25342 wxMouseCaptureChangedEvent *result = 0 ;
25343 int val1 ;
25344 int ecode1 = 0 ;
25345 void *argp2 = 0 ;
25346 int res2 = 0 ;
25347 PyObject * obj0 = 0 ;
25348 PyObject * obj1 = 0 ;
25349 char * kwnames[] = {
25350 (char *) "winid",(char *) "gainedCapture", NULL
25351 };
25352
25353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25354 if (obj0) {
25355 ecode1 = SWIG_AsVal_int(obj0, &val1);
25356 if (!SWIG_IsOK(ecode1)) {
25357 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25358 }
25359 arg1 = static_cast< int >(val1);
25360 }
25361 if (obj1) {
25362 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25363 if (!SWIG_IsOK(res2)) {
25364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25365 }
25366 arg2 = reinterpret_cast< wxWindow * >(argp2);
25367 }
25368 {
25369 PyThreadState* __tstate = wxPyBeginAllowThreads();
25370 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25371 wxPyEndAllowThreads(__tstate);
25372 if (PyErr_Occurred()) SWIG_fail;
25373 }
25374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25375 return resultobj;
25376 fail:
25377 return NULL;
25378 }
25379
25380
25381 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25382 PyObject *resultobj = 0;
25383 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25384 wxWindow *result = 0 ;
25385 void *argp1 = 0 ;
25386 int res1 = 0 ;
25387 PyObject *swig_obj[1] ;
25388
25389 if (!args) SWIG_fail;
25390 swig_obj[0] = args;
25391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25392 if (!SWIG_IsOK(res1)) {
25393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25394 }
25395 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25396 {
25397 PyThreadState* __tstate = wxPyBeginAllowThreads();
25398 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25399 wxPyEndAllowThreads(__tstate);
25400 if (PyErr_Occurred()) SWIG_fail;
25401 }
25402 {
25403 resultobj = wxPyMake_wxObject(result, (bool)0);
25404 }
25405 return resultobj;
25406 fail:
25407 return NULL;
25408 }
25409
25410
25411 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25412 PyObject *obj;
25413 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25414 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25415 return SWIG_Py_Void();
25416 }
25417
25418 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25419 return SWIG_Python_InitShadowInstance(args);
25420 }
25421
25422 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25423 PyObject *resultobj = 0;
25424 wxDisplayChangedEvent *result = 0 ;
25425
25426 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25427 {
25428 PyThreadState* __tstate = wxPyBeginAllowThreads();
25429 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25430 wxPyEndAllowThreads(__tstate);
25431 if (PyErr_Occurred()) SWIG_fail;
25432 }
25433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25434 return resultobj;
25435 fail:
25436 return NULL;
25437 }
25438
25439
25440 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25441 PyObject *obj;
25442 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25443 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25444 return SWIG_Py_Void();
25445 }
25446
25447 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25448 return SWIG_Python_InitShadowInstance(args);
25449 }
25450
25451 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25452 PyObject *resultobj = 0;
25453 int arg1 = (int) 0 ;
25454 wxPaletteChangedEvent *result = 0 ;
25455 int val1 ;
25456 int ecode1 = 0 ;
25457 PyObject * obj0 = 0 ;
25458 char * kwnames[] = {
25459 (char *) "id", NULL
25460 };
25461
25462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25463 if (obj0) {
25464 ecode1 = SWIG_AsVal_int(obj0, &val1);
25465 if (!SWIG_IsOK(ecode1)) {
25466 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25467 }
25468 arg1 = static_cast< int >(val1);
25469 }
25470 {
25471 PyThreadState* __tstate = wxPyBeginAllowThreads();
25472 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25473 wxPyEndAllowThreads(__tstate);
25474 if (PyErr_Occurred()) SWIG_fail;
25475 }
25476 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25477 return resultobj;
25478 fail:
25479 return NULL;
25480 }
25481
25482
25483 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25484 PyObject *resultobj = 0;
25485 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25486 wxWindow *arg2 = (wxWindow *) 0 ;
25487 void *argp1 = 0 ;
25488 int res1 = 0 ;
25489 void *argp2 = 0 ;
25490 int res2 = 0 ;
25491 PyObject * obj0 = 0 ;
25492 PyObject * obj1 = 0 ;
25493 char * kwnames[] = {
25494 (char *) "self",(char *) "win", NULL
25495 };
25496
25497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25499 if (!SWIG_IsOK(res1)) {
25500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25501 }
25502 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25503 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25504 if (!SWIG_IsOK(res2)) {
25505 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25506 }
25507 arg2 = reinterpret_cast< wxWindow * >(argp2);
25508 {
25509 PyThreadState* __tstate = wxPyBeginAllowThreads();
25510 (arg1)->SetChangedWindow(arg2);
25511 wxPyEndAllowThreads(__tstate);
25512 if (PyErr_Occurred()) SWIG_fail;
25513 }
25514 resultobj = SWIG_Py_Void();
25515 return resultobj;
25516 fail:
25517 return NULL;
25518 }
25519
25520
25521 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25522 PyObject *resultobj = 0;
25523 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25524 wxWindow *result = 0 ;
25525 void *argp1 = 0 ;
25526 int res1 = 0 ;
25527 PyObject *swig_obj[1] ;
25528
25529 if (!args) SWIG_fail;
25530 swig_obj[0] = args;
25531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25532 if (!SWIG_IsOK(res1)) {
25533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25534 }
25535 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25536 {
25537 PyThreadState* __tstate = wxPyBeginAllowThreads();
25538 result = (wxWindow *)(arg1)->GetChangedWindow();
25539 wxPyEndAllowThreads(__tstate);
25540 if (PyErr_Occurred()) SWIG_fail;
25541 }
25542 {
25543 resultobj = wxPyMake_wxObject(result, (bool)0);
25544 }
25545 return resultobj;
25546 fail:
25547 return NULL;
25548 }
25549
25550
25551 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25552 PyObject *obj;
25553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25554 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25555 return SWIG_Py_Void();
25556 }
25557
25558 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25559 return SWIG_Python_InitShadowInstance(args);
25560 }
25561
25562 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25563 PyObject *resultobj = 0;
25564 int arg1 = (int) 0 ;
25565 wxQueryNewPaletteEvent *result = 0 ;
25566 int val1 ;
25567 int ecode1 = 0 ;
25568 PyObject * obj0 = 0 ;
25569 char * kwnames[] = {
25570 (char *) "winid", NULL
25571 };
25572
25573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25574 if (obj0) {
25575 ecode1 = SWIG_AsVal_int(obj0, &val1);
25576 if (!SWIG_IsOK(ecode1)) {
25577 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25578 }
25579 arg1 = static_cast< int >(val1);
25580 }
25581 {
25582 PyThreadState* __tstate = wxPyBeginAllowThreads();
25583 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25584 wxPyEndAllowThreads(__tstate);
25585 if (PyErr_Occurred()) SWIG_fail;
25586 }
25587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25588 return resultobj;
25589 fail:
25590 return NULL;
25591 }
25592
25593
25594 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25595 PyObject *resultobj = 0;
25596 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25597 bool arg2 ;
25598 void *argp1 = 0 ;
25599 int res1 = 0 ;
25600 bool val2 ;
25601 int ecode2 = 0 ;
25602 PyObject * obj0 = 0 ;
25603 PyObject * obj1 = 0 ;
25604 char * kwnames[] = {
25605 (char *) "self",(char *) "realized", NULL
25606 };
25607
25608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25610 if (!SWIG_IsOK(res1)) {
25611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25612 }
25613 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25614 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25615 if (!SWIG_IsOK(ecode2)) {
25616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25617 }
25618 arg2 = static_cast< bool >(val2);
25619 {
25620 PyThreadState* __tstate = wxPyBeginAllowThreads();
25621 (arg1)->SetPaletteRealized(arg2);
25622 wxPyEndAllowThreads(__tstate);
25623 if (PyErr_Occurred()) SWIG_fail;
25624 }
25625 resultobj = SWIG_Py_Void();
25626 return resultobj;
25627 fail:
25628 return NULL;
25629 }
25630
25631
25632 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25633 PyObject *resultobj = 0;
25634 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25635 bool result;
25636 void *argp1 = 0 ;
25637 int res1 = 0 ;
25638 PyObject *swig_obj[1] ;
25639
25640 if (!args) SWIG_fail;
25641 swig_obj[0] = args;
25642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25643 if (!SWIG_IsOK(res1)) {
25644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25645 }
25646 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25647 {
25648 PyThreadState* __tstate = wxPyBeginAllowThreads();
25649 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25650 wxPyEndAllowThreads(__tstate);
25651 if (PyErr_Occurred()) SWIG_fail;
25652 }
25653 {
25654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25655 }
25656 return resultobj;
25657 fail:
25658 return NULL;
25659 }
25660
25661
25662 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25663 PyObject *obj;
25664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25665 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25666 return SWIG_Py_Void();
25667 }
25668
25669 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25670 return SWIG_Python_InitShadowInstance(args);
25671 }
25672
25673 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25674 PyObject *resultobj = 0;
25675 wxNavigationKeyEvent *result = 0 ;
25676
25677 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25678 {
25679 PyThreadState* __tstate = wxPyBeginAllowThreads();
25680 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25681 wxPyEndAllowThreads(__tstate);
25682 if (PyErr_Occurred()) SWIG_fail;
25683 }
25684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25685 return resultobj;
25686 fail:
25687 return NULL;
25688 }
25689
25690
25691 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25692 PyObject *resultobj = 0;
25693 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25694 bool result;
25695 void *argp1 = 0 ;
25696 int res1 = 0 ;
25697 PyObject *swig_obj[1] ;
25698
25699 if (!args) SWIG_fail;
25700 swig_obj[0] = args;
25701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25702 if (!SWIG_IsOK(res1)) {
25703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25704 }
25705 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25706 {
25707 PyThreadState* __tstate = wxPyBeginAllowThreads();
25708 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25709 wxPyEndAllowThreads(__tstate);
25710 if (PyErr_Occurred()) SWIG_fail;
25711 }
25712 {
25713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25714 }
25715 return resultobj;
25716 fail:
25717 return NULL;
25718 }
25719
25720
25721 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25722 PyObject *resultobj = 0;
25723 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25724 bool arg2 ;
25725 void *argp1 = 0 ;
25726 int res1 = 0 ;
25727 bool val2 ;
25728 int ecode2 = 0 ;
25729 PyObject * obj0 = 0 ;
25730 PyObject * obj1 = 0 ;
25731 char * kwnames[] = {
25732 (char *) "self",(char *) "forward", NULL
25733 };
25734
25735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25737 if (!SWIG_IsOK(res1)) {
25738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25739 }
25740 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25741 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25742 if (!SWIG_IsOK(ecode2)) {
25743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25744 }
25745 arg2 = static_cast< bool >(val2);
25746 {
25747 PyThreadState* __tstate = wxPyBeginAllowThreads();
25748 (arg1)->SetDirection(arg2);
25749 wxPyEndAllowThreads(__tstate);
25750 if (PyErr_Occurred()) SWIG_fail;
25751 }
25752 resultobj = SWIG_Py_Void();
25753 return resultobj;
25754 fail:
25755 return NULL;
25756 }
25757
25758
25759 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25760 PyObject *resultobj = 0;
25761 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25762 bool result;
25763 void *argp1 = 0 ;
25764 int res1 = 0 ;
25765 PyObject *swig_obj[1] ;
25766
25767 if (!args) SWIG_fail;
25768 swig_obj[0] = args;
25769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25770 if (!SWIG_IsOK(res1)) {
25771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25772 }
25773 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25774 {
25775 PyThreadState* __tstate = wxPyBeginAllowThreads();
25776 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25777 wxPyEndAllowThreads(__tstate);
25778 if (PyErr_Occurred()) SWIG_fail;
25779 }
25780 {
25781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25782 }
25783 return resultobj;
25784 fail:
25785 return NULL;
25786 }
25787
25788
25789 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25790 PyObject *resultobj = 0;
25791 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25792 bool arg2 ;
25793 void *argp1 = 0 ;
25794 int res1 = 0 ;
25795 bool val2 ;
25796 int ecode2 = 0 ;
25797 PyObject * obj0 = 0 ;
25798 PyObject * obj1 = 0 ;
25799 char * kwnames[] = {
25800 (char *) "self",(char *) "ischange", NULL
25801 };
25802
25803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25805 if (!SWIG_IsOK(res1)) {
25806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25807 }
25808 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25809 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25810 if (!SWIG_IsOK(ecode2)) {
25811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25812 }
25813 arg2 = static_cast< bool >(val2);
25814 {
25815 PyThreadState* __tstate = wxPyBeginAllowThreads();
25816 (arg1)->SetWindowChange(arg2);
25817 wxPyEndAllowThreads(__tstate);
25818 if (PyErr_Occurred()) SWIG_fail;
25819 }
25820 resultobj = SWIG_Py_Void();
25821 return resultobj;
25822 fail:
25823 return NULL;
25824 }
25825
25826
25827 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25828 PyObject *resultobj = 0;
25829 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25830 bool result;
25831 void *argp1 = 0 ;
25832 int res1 = 0 ;
25833 PyObject *swig_obj[1] ;
25834
25835 if (!args) SWIG_fail;
25836 swig_obj[0] = args;
25837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25838 if (!SWIG_IsOK(res1)) {
25839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25840 }
25841 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25842 {
25843 PyThreadState* __tstate = wxPyBeginAllowThreads();
25844 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25845 wxPyEndAllowThreads(__tstate);
25846 if (PyErr_Occurred()) SWIG_fail;
25847 }
25848 {
25849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25850 }
25851 return resultobj;
25852 fail:
25853 return NULL;
25854 }
25855
25856
25857 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25858 PyObject *resultobj = 0;
25859 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25860 bool arg2 ;
25861 void *argp1 = 0 ;
25862 int res1 = 0 ;
25863 bool val2 ;
25864 int ecode2 = 0 ;
25865 PyObject * obj0 = 0 ;
25866 PyObject * obj1 = 0 ;
25867 char * kwnames[] = {
25868 (char *) "self",(char *) "bIs", NULL
25869 };
25870
25871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25873 if (!SWIG_IsOK(res1)) {
25874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25875 }
25876 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25877 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25878 if (!SWIG_IsOK(ecode2)) {
25879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25880 }
25881 arg2 = static_cast< bool >(val2);
25882 {
25883 PyThreadState* __tstate = wxPyBeginAllowThreads();
25884 (arg1)->SetFromTab(arg2);
25885 wxPyEndAllowThreads(__tstate);
25886 if (PyErr_Occurred()) SWIG_fail;
25887 }
25888 resultobj = SWIG_Py_Void();
25889 return resultobj;
25890 fail:
25891 return NULL;
25892 }
25893
25894
25895 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25896 PyObject *resultobj = 0;
25897 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25898 long arg2 ;
25899 void *argp1 = 0 ;
25900 int res1 = 0 ;
25901 long val2 ;
25902 int ecode2 = 0 ;
25903 PyObject * obj0 = 0 ;
25904 PyObject * obj1 = 0 ;
25905 char * kwnames[] = {
25906 (char *) "self",(char *) "flags", NULL
25907 };
25908
25909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25911 if (!SWIG_IsOK(res1)) {
25912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25913 }
25914 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25915 ecode2 = SWIG_AsVal_long(obj1, &val2);
25916 if (!SWIG_IsOK(ecode2)) {
25917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25918 }
25919 arg2 = static_cast< long >(val2);
25920 {
25921 PyThreadState* __tstate = wxPyBeginAllowThreads();
25922 (arg1)->SetFlags(arg2);
25923 wxPyEndAllowThreads(__tstate);
25924 if (PyErr_Occurred()) SWIG_fail;
25925 }
25926 resultobj = SWIG_Py_Void();
25927 return resultobj;
25928 fail:
25929 return NULL;
25930 }
25931
25932
25933 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25934 PyObject *resultobj = 0;
25935 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25936 wxWindow *result = 0 ;
25937 void *argp1 = 0 ;
25938 int res1 = 0 ;
25939 PyObject *swig_obj[1] ;
25940
25941 if (!args) SWIG_fail;
25942 swig_obj[0] = args;
25943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25944 if (!SWIG_IsOK(res1)) {
25945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25946 }
25947 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25948 {
25949 PyThreadState* __tstate = wxPyBeginAllowThreads();
25950 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25951 wxPyEndAllowThreads(__tstate);
25952 if (PyErr_Occurred()) SWIG_fail;
25953 }
25954 {
25955 resultobj = wxPyMake_wxObject(result, (bool)0);
25956 }
25957 return resultobj;
25958 fail:
25959 return NULL;
25960 }
25961
25962
25963 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25964 PyObject *resultobj = 0;
25965 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25966 wxWindow *arg2 = (wxWindow *) 0 ;
25967 void *argp1 = 0 ;
25968 int res1 = 0 ;
25969 void *argp2 = 0 ;
25970 int res2 = 0 ;
25971 PyObject * obj0 = 0 ;
25972 PyObject * obj1 = 0 ;
25973 char * kwnames[] = {
25974 (char *) "self",(char *) "win", NULL
25975 };
25976
25977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25979 if (!SWIG_IsOK(res1)) {
25980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25981 }
25982 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25983 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25984 if (!SWIG_IsOK(res2)) {
25985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25986 }
25987 arg2 = reinterpret_cast< wxWindow * >(argp2);
25988 {
25989 PyThreadState* __tstate = wxPyBeginAllowThreads();
25990 (arg1)->SetCurrentFocus(arg2);
25991 wxPyEndAllowThreads(__tstate);
25992 if (PyErr_Occurred()) SWIG_fail;
25993 }
25994 resultobj = SWIG_Py_Void();
25995 return resultobj;
25996 fail:
25997 return NULL;
25998 }
25999
26000
26001 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26002 PyObject *obj;
26003 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26004 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26005 return SWIG_Py_Void();
26006 }
26007
26008 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26009 return SWIG_Python_InitShadowInstance(args);
26010 }
26011
26012 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26013 PyObject *resultobj = 0;
26014 wxWindow *arg1 = (wxWindow *) NULL ;
26015 wxWindowCreateEvent *result = 0 ;
26016 void *argp1 = 0 ;
26017 int res1 = 0 ;
26018 PyObject * obj0 = 0 ;
26019 char * kwnames[] = {
26020 (char *) "win", NULL
26021 };
26022
26023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26024 if (obj0) {
26025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26026 if (!SWIG_IsOK(res1)) {
26027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26028 }
26029 arg1 = reinterpret_cast< wxWindow * >(argp1);
26030 }
26031 {
26032 PyThreadState* __tstate = wxPyBeginAllowThreads();
26033 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26034 wxPyEndAllowThreads(__tstate);
26035 if (PyErr_Occurred()) SWIG_fail;
26036 }
26037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26038 return resultobj;
26039 fail:
26040 return NULL;
26041 }
26042
26043
26044 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26045 PyObject *resultobj = 0;
26046 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26047 wxWindow *result = 0 ;
26048 void *argp1 = 0 ;
26049 int res1 = 0 ;
26050 PyObject *swig_obj[1] ;
26051
26052 if (!args) SWIG_fail;
26053 swig_obj[0] = args;
26054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26055 if (!SWIG_IsOK(res1)) {
26056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26057 }
26058 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26059 {
26060 PyThreadState* __tstate = wxPyBeginAllowThreads();
26061 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26062 wxPyEndAllowThreads(__tstate);
26063 if (PyErr_Occurred()) SWIG_fail;
26064 }
26065 {
26066 resultobj = wxPyMake_wxObject(result, (bool)0);
26067 }
26068 return resultobj;
26069 fail:
26070 return NULL;
26071 }
26072
26073
26074 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26075 PyObject *obj;
26076 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26077 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26078 return SWIG_Py_Void();
26079 }
26080
26081 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26082 return SWIG_Python_InitShadowInstance(args);
26083 }
26084
26085 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26086 PyObject *resultobj = 0;
26087 wxWindow *arg1 = (wxWindow *) NULL ;
26088 wxWindowDestroyEvent *result = 0 ;
26089 void *argp1 = 0 ;
26090 int res1 = 0 ;
26091 PyObject * obj0 = 0 ;
26092 char * kwnames[] = {
26093 (char *) "win", NULL
26094 };
26095
26096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26097 if (obj0) {
26098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26099 if (!SWIG_IsOK(res1)) {
26100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26101 }
26102 arg1 = reinterpret_cast< wxWindow * >(argp1);
26103 }
26104 {
26105 PyThreadState* __tstate = wxPyBeginAllowThreads();
26106 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26107 wxPyEndAllowThreads(__tstate);
26108 if (PyErr_Occurred()) SWIG_fail;
26109 }
26110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26111 return resultobj;
26112 fail:
26113 return NULL;
26114 }
26115
26116
26117 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26118 PyObject *resultobj = 0;
26119 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26120 wxWindow *result = 0 ;
26121 void *argp1 = 0 ;
26122 int res1 = 0 ;
26123 PyObject *swig_obj[1] ;
26124
26125 if (!args) SWIG_fail;
26126 swig_obj[0] = args;
26127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26128 if (!SWIG_IsOK(res1)) {
26129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26130 }
26131 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26132 {
26133 PyThreadState* __tstate = wxPyBeginAllowThreads();
26134 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26135 wxPyEndAllowThreads(__tstate);
26136 if (PyErr_Occurred()) SWIG_fail;
26137 }
26138 {
26139 resultobj = wxPyMake_wxObject(result, (bool)0);
26140 }
26141 return resultobj;
26142 fail:
26143 return NULL;
26144 }
26145
26146
26147 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26148 PyObject *obj;
26149 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26150 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26151 return SWIG_Py_Void();
26152 }
26153
26154 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26155 return SWIG_Python_InitShadowInstance(args);
26156 }
26157
26158 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26159 PyObject *resultobj = 0;
26160 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26161 int arg2 = (int) 0 ;
26162 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26163 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26164 wxContextMenuEvent *result = 0 ;
26165 int val1 ;
26166 int ecode1 = 0 ;
26167 int val2 ;
26168 int ecode2 = 0 ;
26169 wxPoint temp3 ;
26170 PyObject * obj0 = 0 ;
26171 PyObject * obj1 = 0 ;
26172 PyObject * obj2 = 0 ;
26173 char * kwnames[] = {
26174 (char *) "type",(char *) "winid",(char *) "pt", NULL
26175 };
26176
26177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26178 if (obj0) {
26179 ecode1 = SWIG_AsVal_int(obj0, &val1);
26180 if (!SWIG_IsOK(ecode1)) {
26181 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26182 }
26183 arg1 = static_cast< wxEventType >(val1);
26184 }
26185 if (obj1) {
26186 ecode2 = SWIG_AsVal_int(obj1, &val2);
26187 if (!SWIG_IsOK(ecode2)) {
26188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26189 }
26190 arg2 = static_cast< int >(val2);
26191 }
26192 if (obj2) {
26193 {
26194 arg3 = &temp3;
26195 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26196 }
26197 }
26198 {
26199 PyThreadState* __tstate = wxPyBeginAllowThreads();
26200 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26201 wxPyEndAllowThreads(__tstate);
26202 if (PyErr_Occurred()) SWIG_fail;
26203 }
26204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26205 return resultobj;
26206 fail:
26207 return NULL;
26208 }
26209
26210
26211 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26212 PyObject *resultobj = 0;
26213 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26214 wxPoint *result = 0 ;
26215 void *argp1 = 0 ;
26216 int res1 = 0 ;
26217 PyObject *swig_obj[1] ;
26218
26219 if (!args) SWIG_fail;
26220 swig_obj[0] = args;
26221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26222 if (!SWIG_IsOK(res1)) {
26223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26224 }
26225 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26226 {
26227 PyThreadState* __tstate = wxPyBeginAllowThreads();
26228 {
26229 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26230 result = (wxPoint *) &_result_ref;
26231 }
26232 wxPyEndAllowThreads(__tstate);
26233 if (PyErr_Occurred()) SWIG_fail;
26234 }
26235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26236 return resultobj;
26237 fail:
26238 return NULL;
26239 }
26240
26241
26242 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26243 PyObject *resultobj = 0;
26244 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26245 wxPoint *arg2 = 0 ;
26246 void *argp1 = 0 ;
26247 int res1 = 0 ;
26248 wxPoint temp2 ;
26249 PyObject * obj0 = 0 ;
26250 PyObject * obj1 = 0 ;
26251 char * kwnames[] = {
26252 (char *) "self",(char *) "pos", NULL
26253 };
26254
26255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26257 if (!SWIG_IsOK(res1)) {
26258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26259 }
26260 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26261 {
26262 arg2 = &temp2;
26263 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26264 }
26265 {
26266 PyThreadState* __tstate = wxPyBeginAllowThreads();
26267 (arg1)->SetPosition((wxPoint const &)*arg2);
26268 wxPyEndAllowThreads(__tstate);
26269 if (PyErr_Occurred()) SWIG_fail;
26270 }
26271 resultobj = SWIG_Py_Void();
26272 return resultobj;
26273 fail:
26274 return NULL;
26275 }
26276
26277
26278 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26279 PyObject *obj;
26280 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26281 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26282 return SWIG_Py_Void();
26283 }
26284
26285 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26286 return SWIG_Python_InitShadowInstance(args);
26287 }
26288
26289 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26290 PyObject *resultobj = 0;
26291 wxIdleEvent *result = 0 ;
26292
26293 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26294 {
26295 PyThreadState* __tstate = wxPyBeginAllowThreads();
26296 result = (wxIdleEvent *)new wxIdleEvent();
26297 wxPyEndAllowThreads(__tstate);
26298 if (PyErr_Occurred()) SWIG_fail;
26299 }
26300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26301 return resultobj;
26302 fail:
26303 return NULL;
26304 }
26305
26306
26307 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26308 PyObject *resultobj = 0;
26309 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26310 bool arg2 = (bool) true ;
26311 void *argp1 = 0 ;
26312 int res1 = 0 ;
26313 bool val2 ;
26314 int ecode2 = 0 ;
26315 PyObject * obj0 = 0 ;
26316 PyObject * obj1 = 0 ;
26317 char * kwnames[] = {
26318 (char *) "self",(char *) "needMore", NULL
26319 };
26320
26321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26323 if (!SWIG_IsOK(res1)) {
26324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26325 }
26326 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26327 if (obj1) {
26328 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26329 if (!SWIG_IsOK(ecode2)) {
26330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26331 }
26332 arg2 = static_cast< bool >(val2);
26333 }
26334 {
26335 PyThreadState* __tstate = wxPyBeginAllowThreads();
26336 (arg1)->RequestMore(arg2);
26337 wxPyEndAllowThreads(__tstate);
26338 if (PyErr_Occurred()) SWIG_fail;
26339 }
26340 resultobj = SWIG_Py_Void();
26341 return resultobj;
26342 fail:
26343 return NULL;
26344 }
26345
26346
26347 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26348 PyObject *resultobj = 0;
26349 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26350 bool result;
26351 void *argp1 = 0 ;
26352 int res1 = 0 ;
26353 PyObject *swig_obj[1] ;
26354
26355 if (!args) SWIG_fail;
26356 swig_obj[0] = args;
26357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26358 if (!SWIG_IsOK(res1)) {
26359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26360 }
26361 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26362 {
26363 PyThreadState* __tstate = wxPyBeginAllowThreads();
26364 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26365 wxPyEndAllowThreads(__tstate);
26366 if (PyErr_Occurred()) SWIG_fail;
26367 }
26368 {
26369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26370 }
26371 return resultobj;
26372 fail:
26373 return NULL;
26374 }
26375
26376
26377 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26378 PyObject *resultobj = 0;
26379 wxIdleMode arg1 ;
26380 int val1 ;
26381 int ecode1 = 0 ;
26382 PyObject * obj0 = 0 ;
26383 char * kwnames[] = {
26384 (char *) "mode", NULL
26385 };
26386
26387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26388 ecode1 = SWIG_AsVal_int(obj0, &val1);
26389 if (!SWIG_IsOK(ecode1)) {
26390 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26391 }
26392 arg1 = static_cast< wxIdleMode >(val1);
26393 {
26394 PyThreadState* __tstate = wxPyBeginAllowThreads();
26395 wxIdleEvent::SetMode(arg1);
26396 wxPyEndAllowThreads(__tstate);
26397 if (PyErr_Occurred()) SWIG_fail;
26398 }
26399 resultobj = SWIG_Py_Void();
26400 return resultobj;
26401 fail:
26402 return NULL;
26403 }
26404
26405
26406 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26407 PyObject *resultobj = 0;
26408 wxIdleMode result;
26409
26410 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26411 {
26412 PyThreadState* __tstate = wxPyBeginAllowThreads();
26413 result = (wxIdleMode)wxIdleEvent::GetMode();
26414 wxPyEndAllowThreads(__tstate);
26415 if (PyErr_Occurred()) SWIG_fail;
26416 }
26417 resultobj = SWIG_From_int(static_cast< int >(result));
26418 return resultobj;
26419 fail:
26420 return NULL;
26421 }
26422
26423
26424 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26425 PyObject *resultobj = 0;
26426 wxWindow *arg1 = (wxWindow *) 0 ;
26427 bool result;
26428 void *argp1 = 0 ;
26429 int res1 = 0 ;
26430 PyObject * obj0 = 0 ;
26431 char * kwnames[] = {
26432 (char *) "win", NULL
26433 };
26434
26435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26437 if (!SWIG_IsOK(res1)) {
26438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26439 }
26440 arg1 = reinterpret_cast< wxWindow * >(argp1);
26441 {
26442 PyThreadState* __tstate = wxPyBeginAllowThreads();
26443 result = (bool)wxIdleEvent::CanSend(arg1);
26444 wxPyEndAllowThreads(__tstate);
26445 if (PyErr_Occurred()) SWIG_fail;
26446 }
26447 {
26448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26449 }
26450 return resultobj;
26451 fail:
26452 return NULL;
26453 }
26454
26455
26456 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26457 PyObject *obj;
26458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26459 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26460 return SWIG_Py_Void();
26461 }
26462
26463 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26464 return SWIG_Python_InitShadowInstance(args);
26465 }
26466
26467 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26468 PyObject *resultobj = 0;
26469 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26470 int arg2 = (int) 0 ;
26471 wxClipboardTextEvent *result = 0 ;
26472 int val1 ;
26473 int ecode1 = 0 ;
26474 int val2 ;
26475 int ecode2 = 0 ;
26476 PyObject * obj0 = 0 ;
26477 PyObject * obj1 = 0 ;
26478 char * kwnames[] = {
26479 (char *) "type",(char *) "winid", NULL
26480 };
26481
26482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26483 if (obj0) {
26484 ecode1 = SWIG_AsVal_int(obj0, &val1);
26485 if (!SWIG_IsOK(ecode1)) {
26486 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26487 }
26488 arg1 = static_cast< wxEventType >(val1);
26489 }
26490 if (obj1) {
26491 ecode2 = SWIG_AsVal_int(obj1, &val2);
26492 if (!SWIG_IsOK(ecode2)) {
26493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26494 }
26495 arg2 = static_cast< int >(val2);
26496 }
26497 {
26498 PyThreadState* __tstate = wxPyBeginAllowThreads();
26499 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26500 wxPyEndAllowThreads(__tstate);
26501 if (PyErr_Occurred()) SWIG_fail;
26502 }
26503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26504 return resultobj;
26505 fail:
26506 return NULL;
26507 }
26508
26509
26510 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26511 PyObject *obj;
26512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26513 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26514 return SWIG_Py_Void();
26515 }
26516
26517 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26518 return SWIG_Python_InitShadowInstance(args);
26519 }
26520
26521 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26522 PyObject *resultobj = 0;
26523 int arg1 = (int) 0 ;
26524 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26525 wxPyEvent *result = 0 ;
26526 int val1 ;
26527 int ecode1 = 0 ;
26528 int val2 ;
26529 int ecode2 = 0 ;
26530 PyObject * obj0 = 0 ;
26531 PyObject * obj1 = 0 ;
26532 char * kwnames[] = {
26533 (char *) "winid",(char *) "eventType", NULL
26534 };
26535
26536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26537 if (obj0) {
26538 ecode1 = SWIG_AsVal_int(obj0, &val1);
26539 if (!SWIG_IsOK(ecode1)) {
26540 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26541 }
26542 arg1 = static_cast< int >(val1);
26543 }
26544 if (obj1) {
26545 ecode2 = SWIG_AsVal_int(obj1, &val2);
26546 if (!SWIG_IsOK(ecode2)) {
26547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26548 }
26549 arg2 = static_cast< wxEventType >(val2);
26550 }
26551 {
26552 PyThreadState* __tstate = wxPyBeginAllowThreads();
26553 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26554 wxPyEndAllowThreads(__tstate);
26555 if (PyErr_Occurred()) SWIG_fail;
26556 }
26557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26558 return resultobj;
26559 fail:
26560 return NULL;
26561 }
26562
26563
26564 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26565 PyObject *resultobj = 0;
26566 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26567 void *argp1 = 0 ;
26568 int res1 = 0 ;
26569 PyObject *swig_obj[1] ;
26570
26571 if (!args) SWIG_fail;
26572 swig_obj[0] = args;
26573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26574 if (!SWIG_IsOK(res1)) {
26575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26576 }
26577 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26578 {
26579 PyThreadState* __tstate = wxPyBeginAllowThreads();
26580 delete arg1;
26581
26582 wxPyEndAllowThreads(__tstate);
26583 if (PyErr_Occurred()) SWIG_fail;
26584 }
26585 resultobj = SWIG_Py_Void();
26586 return resultobj;
26587 fail:
26588 return NULL;
26589 }
26590
26591
26592 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26593 PyObject *resultobj = 0;
26594 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26595 PyObject *arg2 = (PyObject *) 0 ;
26596 void *argp1 = 0 ;
26597 int res1 = 0 ;
26598 PyObject * obj0 = 0 ;
26599 PyObject * obj1 = 0 ;
26600 char * kwnames[] = {
26601 (char *) "self",(char *) "self", NULL
26602 };
26603
26604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26606 if (!SWIG_IsOK(res1)) {
26607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26608 }
26609 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26610 arg2 = obj1;
26611 {
26612 PyThreadState* __tstate = wxPyBeginAllowThreads();
26613 (arg1)->SetSelf(arg2);
26614 wxPyEndAllowThreads(__tstate);
26615 if (PyErr_Occurred()) SWIG_fail;
26616 }
26617 resultobj = SWIG_Py_Void();
26618 return resultobj;
26619 fail:
26620 return NULL;
26621 }
26622
26623
26624 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26625 PyObject *resultobj = 0;
26626 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26627 PyObject *result = 0 ;
26628 void *argp1 = 0 ;
26629 int res1 = 0 ;
26630 PyObject *swig_obj[1] ;
26631
26632 if (!args) SWIG_fail;
26633 swig_obj[0] = args;
26634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26635 if (!SWIG_IsOK(res1)) {
26636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26637 }
26638 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26639 {
26640 PyThreadState* __tstate = wxPyBeginAllowThreads();
26641 result = (PyObject *)(arg1)->GetSelf();
26642 wxPyEndAllowThreads(__tstate);
26643 if (PyErr_Occurred()) SWIG_fail;
26644 }
26645 resultobj = result;
26646 return resultobj;
26647 fail:
26648 return NULL;
26649 }
26650
26651
26652 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26653 PyObject *obj;
26654 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26655 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26656 return SWIG_Py_Void();
26657 }
26658
26659 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26660 return SWIG_Python_InitShadowInstance(args);
26661 }
26662
26663 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26664 PyObject *resultobj = 0;
26665 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26666 int arg2 = (int) 0 ;
26667 wxPyCommandEvent *result = 0 ;
26668 int val1 ;
26669 int ecode1 = 0 ;
26670 int val2 ;
26671 int ecode2 = 0 ;
26672 PyObject * obj0 = 0 ;
26673 PyObject * obj1 = 0 ;
26674 char * kwnames[] = {
26675 (char *) "eventType",(char *) "id", NULL
26676 };
26677
26678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26679 if (obj0) {
26680 ecode1 = SWIG_AsVal_int(obj0, &val1);
26681 if (!SWIG_IsOK(ecode1)) {
26682 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26683 }
26684 arg1 = static_cast< wxEventType >(val1);
26685 }
26686 if (obj1) {
26687 ecode2 = SWIG_AsVal_int(obj1, &val2);
26688 if (!SWIG_IsOK(ecode2)) {
26689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26690 }
26691 arg2 = static_cast< int >(val2);
26692 }
26693 {
26694 PyThreadState* __tstate = wxPyBeginAllowThreads();
26695 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26696 wxPyEndAllowThreads(__tstate);
26697 if (PyErr_Occurred()) SWIG_fail;
26698 }
26699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26700 return resultobj;
26701 fail:
26702 return NULL;
26703 }
26704
26705
26706 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26707 PyObject *resultobj = 0;
26708 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26709 void *argp1 = 0 ;
26710 int res1 = 0 ;
26711 PyObject *swig_obj[1] ;
26712
26713 if (!args) SWIG_fail;
26714 swig_obj[0] = args;
26715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26716 if (!SWIG_IsOK(res1)) {
26717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26718 }
26719 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26720 {
26721 PyThreadState* __tstate = wxPyBeginAllowThreads();
26722 delete arg1;
26723
26724 wxPyEndAllowThreads(__tstate);
26725 if (PyErr_Occurred()) SWIG_fail;
26726 }
26727 resultobj = SWIG_Py_Void();
26728 return resultobj;
26729 fail:
26730 return NULL;
26731 }
26732
26733
26734 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26735 PyObject *resultobj = 0;
26736 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26737 PyObject *arg2 = (PyObject *) 0 ;
26738 void *argp1 = 0 ;
26739 int res1 = 0 ;
26740 PyObject * obj0 = 0 ;
26741 PyObject * obj1 = 0 ;
26742 char * kwnames[] = {
26743 (char *) "self",(char *) "self", NULL
26744 };
26745
26746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26748 if (!SWIG_IsOK(res1)) {
26749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26750 }
26751 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26752 arg2 = obj1;
26753 {
26754 PyThreadState* __tstate = wxPyBeginAllowThreads();
26755 (arg1)->SetSelf(arg2);
26756 wxPyEndAllowThreads(__tstate);
26757 if (PyErr_Occurred()) SWIG_fail;
26758 }
26759 resultobj = SWIG_Py_Void();
26760 return resultobj;
26761 fail:
26762 return NULL;
26763 }
26764
26765
26766 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26767 PyObject *resultobj = 0;
26768 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26769 PyObject *result = 0 ;
26770 void *argp1 = 0 ;
26771 int res1 = 0 ;
26772 PyObject *swig_obj[1] ;
26773
26774 if (!args) SWIG_fail;
26775 swig_obj[0] = args;
26776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26777 if (!SWIG_IsOK(res1)) {
26778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26779 }
26780 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26781 {
26782 PyThreadState* __tstate = wxPyBeginAllowThreads();
26783 result = (PyObject *)(arg1)->GetSelf();
26784 wxPyEndAllowThreads(__tstate);
26785 if (PyErr_Occurred()) SWIG_fail;
26786 }
26787 resultobj = result;
26788 return resultobj;
26789 fail:
26790 return NULL;
26791 }
26792
26793
26794 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26795 PyObject *obj;
26796 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26797 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26798 return SWIG_Py_Void();
26799 }
26800
26801 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26802 return SWIG_Python_InitShadowInstance(args);
26803 }
26804
26805 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26806 PyObject *resultobj = 0;
26807 wxWindow *arg1 = (wxWindow *) 0 ;
26808 wxDateTime *arg2 = 0 ;
26809 wxEventType arg3 ;
26810 wxDateEvent *result = 0 ;
26811 void *argp1 = 0 ;
26812 int res1 = 0 ;
26813 void *argp2 = 0 ;
26814 int res2 = 0 ;
26815 int val3 ;
26816 int ecode3 = 0 ;
26817 PyObject * obj0 = 0 ;
26818 PyObject * obj1 = 0 ;
26819 PyObject * obj2 = 0 ;
26820 char * kwnames[] = {
26821 (char *) "win",(char *) "dt",(char *) "type", NULL
26822 };
26823
26824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26826 if (!SWIG_IsOK(res1)) {
26827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26828 }
26829 arg1 = reinterpret_cast< wxWindow * >(argp1);
26830 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26831 if (!SWIG_IsOK(res2)) {
26832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26833 }
26834 if (!argp2) {
26835 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26836 }
26837 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26838 ecode3 = SWIG_AsVal_int(obj2, &val3);
26839 if (!SWIG_IsOK(ecode3)) {
26840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26841 }
26842 arg3 = static_cast< wxEventType >(val3);
26843 {
26844 PyThreadState* __tstate = wxPyBeginAllowThreads();
26845 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26846 wxPyEndAllowThreads(__tstate);
26847 if (PyErr_Occurred()) SWIG_fail;
26848 }
26849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26850 return resultobj;
26851 fail:
26852 return NULL;
26853 }
26854
26855
26856 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26857 PyObject *resultobj = 0;
26858 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26859 wxDateTime *result = 0 ;
26860 void *argp1 = 0 ;
26861 int res1 = 0 ;
26862 PyObject *swig_obj[1] ;
26863
26864 if (!args) SWIG_fail;
26865 swig_obj[0] = args;
26866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26867 if (!SWIG_IsOK(res1)) {
26868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26869 }
26870 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26871 {
26872 PyThreadState* __tstate = wxPyBeginAllowThreads();
26873 {
26874 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26875 result = (wxDateTime *) &_result_ref;
26876 }
26877 wxPyEndAllowThreads(__tstate);
26878 if (PyErr_Occurred()) SWIG_fail;
26879 }
26880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26881 return resultobj;
26882 fail:
26883 return NULL;
26884 }
26885
26886
26887 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26888 PyObject *resultobj = 0;
26889 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26890 wxDateTime *arg2 = 0 ;
26891 void *argp1 = 0 ;
26892 int res1 = 0 ;
26893 void *argp2 = 0 ;
26894 int res2 = 0 ;
26895 PyObject * obj0 = 0 ;
26896 PyObject * obj1 = 0 ;
26897 char * kwnames[] = {
26898 (char *) "self",(char *) "date", NULL
26899 };
26900
26901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26903 if (!SWIG_IsOK(res1)) {
26904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26905 }
26906 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26907 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26908 if (!SWIG_IsOK(res2)) {
26909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26910 }
26911 if (!argp2) {
26912 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26913 }
26914 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26915 {
26916 PyThreadState* __tstate = wxPyBeginAllowThreads();
26917 (arg1)->SetDate((wxDateTime const &)*arg2);
26918 wxPyEndAllowThreads(__tstate);
26919 if (PyErr_Occurred()) SWIG_fail;
26920 }
26921 resultobj = SWIG_Py_Void();
26922 return resultobj;
26923 fail:
26924 return NULL;
26925 }
26926
26927
26928 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26929 PyObject *obj;
26930 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26931 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26932 return SWIG_Py_Void();
26933 }
26934
26935 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26936 return SWIG_Python_InitShadowInstance(args);
26937 }
26938
26939 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26940 PyObject *resultobj = 0;
26941 wxPyApp *result = 0 ;
26942
26943 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26944 {
26945 PyThreadState* __tstate = wxPyBeginAllowThreads();
26946 result = (wxPyApp *)new_wxPyApp();
26947 wxPyEndAllowThreads(__tstate);
26948 if (PyErr_Occurred()) SWIG_fail;
26949 }
26950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26951 return resultobj;
26952 fail:
26953 return NULL;
26954 }
26955
26956
26957 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26958 PyObject *resultobj = 0;
26959 wxPyApp *arg1 = (wxPyApp *) 0 ;
26960 void *argp1 = 0 ;
26961 int res1 = 0 ;
26962 PyObject *swig_obj[1] ;
26963
26964 if (!args) SWIG_fail;
26965 swig_obj[0] = args;
26966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26967 if (!SWIG_IsOK(res1)) {
26968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26969 }
26970 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26971 {
26972 PyThreadState* __tstate = wxPyBeginAllowThreads();
26973 delete arg1;
26974
26975 wxPyEndAllowThreads(__tstate);
26976 if (PyErr_Occurred()) SWIG_fail;
26977 }
26978 resultobj = SWIG_Py_Void();
26979 return resultobj;
26980 fail:
26981 return NULL;
26982 }
26983
26984
26985 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26986 PyObject *resultobj = 0;
26987 wxPyApp *arg1 = (wxPyApp *) 0 ;
26988 PyObject *arg2 = (PyObject *) 0 ;
26989 PyObject *arg3 = (PyObject *) 0 ;
26990 bool arg4 ;
26991 void *argp1 = 0 ;
26992 int res1 = 0 ;
26993 bool val4 ;
26994 int ecode4 = 0 ;
26995 PyObject * obj0 = 0 ;
26996 PyObject * obj1 = 0 ;
26997 PyObject * obj2 = 0 ;
26998 PyObject * obj3 = 0 ;
26999 char * kwnames[] = {
27000 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27001 };
27002
27003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27005 if (!SWIG_IsOK(res1)) {
27006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27007 }
27008 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27009 arg2 = obj1;
27010 arg3 = obj2;
27011 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27012 if (!SWIG_IsOK(ecode4)) {
27013 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27014 }
27015 arg4 = static_cast< bool >(val4);
27016 {
27017 PyThreadState* __tstate = wxPyBeginAllowThreads();
27018 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27019 wxPyEndAllowThreads(__tstate);
27020 if (PyErr_Occurred()) SWIG_fail;
27021 }
27022 resultobj = SWIG_Py_Void();
27023 return resultobj;
27024 fail:
27025 return NULL;
27026 }
27027
27028
27029 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27030 PyObject *resultobj = 0;
27031 wxPyApp *arg1 = (wxPyApp *) 0 ;
27032 wxString result;
27033 void *argp1 = 0 ;
27034 int res1 = 0 ;
27035 PyObject *swig_obj[1] ;
27036
27037 if (!args) SWIG_fail;
27038 swig_obj[0] = args;
27039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27040 if (!SWIG_IsOK(res1)) {
27041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27042 }
27043 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27044 {
27045 PyThreadState* __tstate = wxPyBeginAllowThreads();
27046 result = ((wxPyApp const *)arg1)->GetAppName();
27047 wxPyEndAllowThreads(__tstate);
27048 if (PyErr_Occurred()) SWIG_fail;
27049 }
27050 {
27051 #if wxUSE_UNICODE
27052 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27053 #else
27054 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27055 #endif
27056 }
27057 return resultobj;
27058 fail:
27059 return NULL;
27060 }
27061
27062
27063 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27064 PyObject *resultobj = 0;
27065 wxPyApp *arg1 = (wxPyApp *) 0 ;
27066 wxString *arg2 = 0 ;
27067 void *argp1 = 0 ;
27068 int res1 = 0 ;
27069 bool temp2 = false ;
27070 PyObject * obj0 = 0 ;
27071 PyObject * obj1 = 0 ;
27072 char * kwnames[] = {
27073 (char *) "self",(char *) "name", NULL
27074 };
27075
27076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27078 if (!SWIG_IsOK(res1)) {
27079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27080 }
27081 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27082 {
27083 arg2 = wxString_in_helper(obj1);
27084 if (arg2 == NULL) SWIG_fail;
27085 temp2 = true;
27086 }
27087 {
27088 PyThreadState* __tstate = wxPyBeginAllowThreads();
27089 (arg1)->SetAppName((wxString const &)*arg2);
27090 wxPyEndAllowThreads(__tstate);
27091 if (PyErr_Occurred()) SWIG_fail;
27092 }
27093 resultobj = SWIG_Py_Void();
27094 {
27095 if (temp2)
27096 delete arg2;
27097 }
27098 return resultobj;
27099 fail:
27100 {
27101 if (temp2)
27102 delete arg2;
27103 }
27104 return NULL;
27105 }
27106
27107
27108 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27109 PyObject *resultobj = 0;
27110 wxPyApp *arg1 = (wxPyApp *) 0 ;
27111 wxString result;
27112 void *argp1 = 0 ;
27113 int res1 = 0 ;
27114 PyObject *swig_obj[1] ;
27115
27116 if (!args) SWIG_fail;
27117 swig_obj[0] = args;
27118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27119 if (!SWIG_IsOK(res1)) {
27120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27121 }
27122 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27123 {
27124 PyThreadState* __tstate = wxPyBeginAllowThreads();
27125 result = ((wxPyApp const *)arg1)->GetClassName();
27126 wxPyEndAllowThreads(__tstate);
27127 if (PyErr_Occurred()) SWIG_fail;
27128 }
27129 {
27130 #if wxUSE_UNICODE
27131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27132 #else
27133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27134 #endif
27135 }
27136 return resultobj;
27137 fail:
27138 return NULL;
27139 }
27140
27141
27142 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27143 PyObject *resultobj = 0;
27144 wxPyApp *arg1 = (wxPyApp *) 0 ;
27145 wxString *arg2 = 0 ;
27146 void *argp1 = 0 ;
27147 int res1 = 0 ;
27148 bool temp2 = false ;
27149 PyObject * obj0 = 0 ;
27150 PyObject * obj1 = 0 ;
27151 char * kwnames[] = {
27152 (char *) "self",(char *) "name", NULL
27153 };
27154
27155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27157 if (!SWIG_IsOK(res1)) {
27158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27159 }
27160 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27161 {
27162 arg2 = wxString_in_helper(obj1);
27163 if (arg2 == NULL) SWIG_fail;
27164 temp2 = true;
27165 }
27166 {
27167 PyThreadState* __tstate = wxPyBeginAllowThreads();
27168 (arg1)->SetClassName((wxString const &)*arg2);
27169 wxPyEndAllowThreads(__tstate);
27170 if (PyErr_Occurred()) SWIG_fail;
27171 }
27172 resultobj = SWIG_Py_Void();
27173 {
27174 if (temp2)
27175 delete arg2;
27176 }
27177 return resultobj;
27178 fail:
27179 {
27180 if (temp2)
27181 delete arg2;
27182 }
27183 return NULL;
27184 }
27185
27186
27187 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27188 PyObject *resultobj = 0;
27189 wxPyApp *arg1 = (wxPyApp *) 0 ;
27190 wxString *result = 0 ;
27191 void *argp1 = 0 ;
27192 int res1 = 0 ;
27193 PyObject *swig_obj[1] ;
27194
27195 if (!args) SWIG_fail;
27196 swig_obj[0] = args;
27197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27198 if (!SWIG_IsOK(res1)) {
27199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27200 }
27201 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27202 {
27203 PyThreadState* __tstate = wxPyBeginAllowThreads();
27204 {
27205 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27206 result = (wxString *) &_result_ref;
27207 }
27208 wxPyEndAllowThreads(__tstate);
27209 if (PyErr_Occurred()) SWIG_fail;
27210 }
27211 {
27212 #if wxUSE_UNICODE
27213 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27214 #else
27215 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27216 #endif
27217 }
27218 return resultobj;
27219 fail:
27220 return NULL;
27221 }
27222
27223
27224 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27225 PyObject *resultobj = 0;
27226 wxPyApp *arg1 = (wxPyApp *) 0 ;
27227 wxString *arg2 = 0 ;
27228 void *argp1 = 0 ;
27229 int res1 = 0 ;
27230 bool temp2 = false ;
27231 PyObject * obj0 = 0 ;
27232 PyObject * obj1 = 0 ;
27233 char * kwnames[] = {
27234 (char *) "self",(char *) "name", NULL
27235 };
27236
27237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27239 if (!SWIG_IsOK(res1)) {
27240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27241 }
27242 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27243 {
27244 arg2 = wxString_in_helper(obj1);
27245 if (arg2 == NULL) SWIG_fail;
27246 temp2 = true;
27247 }
27248 {
27249 PyThreadState* __tstate = wxPyBeginAllowThreads();
27250 (arg1)->SetVendorName((wxString const &)*arg2);
27251 wxPyEndAllowThreads(__tstate);
27252 if (PyErr_Occurred()) SWIG_fail;
27253 }
27254 resultobj = SWIG_Py_Void();
27255 {
27256 if (temp2)
27257 delete arg2;
27258 }
27259 return resultobj;
27260 fail:
27261 {
27262 if (temp2)
27263 delete arg2;
27264 }
27265 return NULL;
27266 }
27267
27268
27269 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27270 PyObject *resultobj = 0;
27271 wxPyApp *arg1 = (wxPyApp *) 0 ;
27272 wxAppTraits *result = 0 ;
27273 void *argp1 = 0 ;
27274 int res1 = 0 ;
27275 PyObject *swig_obj[1] ;
27276
27277 if (!args) SWIG_fail;
27278 swig_obj[0] = args;
27279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27280 if (!SWIG_IsOK(res1)) {
27281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27282 }
27283 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27284 {
27285 PyThreadState* __tstate = wxPyBeginAllowThreads();
27286 result = (wxAppTraits *)(arg1)->GetTraits();
27287 wxPyEndAllowThreads(__tstate);
27288 if (PyErr_Occurred()) SWIG_fail;
27289 }
27290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27291 return resultobj;
27292 fail:
27293 return NULL;
27294 }
27295
27296
27297 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27298 PyObject *resultobj = 0;
27299 wxPyApp *arg1 = (wxPyApp *) 0 ;
27300 void *argp1 = 0 ;
27301 int res1 = 0 ;
27302 PyObject *swig_obj[1] ;
27303
27304 if (!args) SWIG_fail;
27305 swig_obj[0] = args;
27306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27307 if (!SWIG_IsOK(res1)) {
27308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27309 }
27310 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27311 {
27312 PyThreadState* __tstate = wxPyBeginAllowThreads();
27313 (arg1)->ProcessPendingEvents();
27314 wxPyEndAllowThreads(__tstate);
27315 if (PyErr_Occurred()) SWIG_fail;
27316 }
27317 resultobj = SWIG_Py_Void();
27318 return resultobj;
27319 fail:
27320 return NULL;
27321 }
27322
27323
27324 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27325 PyObject *resultobj = 0;
27326 wxPyApp *arg1 = (wxPyApp *) 0 ;
27327 bool arg2 = (bool) false ;
27328 bool result;
27329 void *argp1 = 0 ;
27330 int res1 = 0 ;
27331 bool val2 ;
27332 int ecode2 = 0 ;
27333 PyObject * obj0 = 0 ;
27334 PyObject * obj1 = 0 ;
27335 char * kwnames[] = {
27336 (char *) "self",(char *) "onlyIfNeeded", NULL
27337 };
27338
27339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27341 if (!SWIG_IsOK(res1)) {
27342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27343 }
27344 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27345 if (obj1) {
27346 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27347 if (!SWIG_IsOK(ecode2)) {
27348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27349 }
27350 arg2 = static_cast< bool >(val2);
27351 }
27352 {
27353 PyThreadState* __tstate = wxPyBeginAllowThreads();
27354 result = (bool)(arg1)->Yield(arg2);
27355 wxPyEndAllowThreads(__tstate);
27356 if (PyErr_Occurred()) SWIG_fail;
27357 }
27358 {
27359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27360 }
27361 return resultobj;
27362 fail:
27363 return NULL;
27364 }
27365
27366
27367 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27368 PyObject *resultobj = 0;
27369 wxPyApp *arg1 = (wxPyApp *) 0 ;
27370 void *argp1 = 0 ;
27371 int res1 = 0 ;
27372 PyObject *swig_obj[1] ;
27373
27374 if (!args) SWIG_fail;
27375 swig_obj[0] = args;
27376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27377 if (!SWIG_IsOK(res1)) {
27378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27379 }
27380 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27381 {
27382 PyThreadState* __tstate = wxPyBeginAllowThreads();
27383 (arg1)->WakeUpIdle();
27384 wxPyEndAllowThreads(__tstate);
27385 if (PyErr_Occurred()) SWIG_fail;
27386 }
27387 resultobj = SWIG_Py_Void();
27388 return resultobj;
27389 fail:
27390 return NULL;
27391 }
27392
27393
27394 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27395 PyObject *resultobj = 0;
27396 bool result;
27397
27398 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27399 {
27400 PyThreadState* __tstate = wxPyBeginAllowThreads();
27401 result = (bool)wxPyApp::IsMainLoopRunning();
27402 wxPyEndAllowThreads(__tstate);
27403 if (PyErr_Occurred()) SWIG_fail;
27404 }
27405 {
27406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27407 }
27408 return resultobj;
27409 fail:
27410 return NULL;
27411 }
27412
27413
27414 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27415 PyObject *resultobj = 0;
27416 wxPyApp *arg1 = (wxPyApp *) 0 ;
27417 int result;
27418 void *argp1 = 0 ;
27419 int res1 = 0 ;
27420 PyObject *swig_obj[1] ;
27421
27422 if (!args) SWIG_fail;
27423 swig_obj[0] = args;
27424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27425 if (!SWIG_IsOK(res1)) {
27426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27427 }
27428 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27429 {
27430 PyThreadState* __tstate = wxPyBeginAllowThreads();
27431 result = (int)(arg1)->MainLoop();
27432 wxPyEndAllowThreads(__tstate);
27433 if (PyErr_Occurred()) SWIG_fail;
27434 }
27435 resultobj = SWIG_From_int(static_cast< int >(result));
27436 return resultobj;
27437 fail:
27438 return NULL;
27439 }
27440
27441
27442 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27443 PyObject *resultobj = 0;
27444 wxPyApp *arg1 = (wxPyApp *) 0 ;
27445 void *argp1 = 0 ;
27446 int res1 = 0 ;
27447 PyObject *swig_obj[1] ;
27448
27449 if (!args) SWIG_fail;
27450 swig_obj[0] = args;
27451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27452 if (!SWIG_IsOK(res1)) {
27453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27454 }
27455 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27456 {
27457 PyThreadState* __tstate = wxPyBeginAllowThreads();
27458 (arg1)->Exit();
27459 wxPyEndAllowThreads(__tstate);
27460 if (PyErr_Occurred()) SWIG_fail;
27461 }
27462 resultobj = SWIG_Py_Void();
27463 return resultobj;
27464 fail:
27465 return NULL;
27466 }
27467
27468
27469 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27470 PyObject *resultobj = 0;
27471 wxPyApp *arg1 = (wxPyApp *) 0 ;
27472 void *argp1 = 0 ;
27473 int res1 = 0 ;
27474 PyObject *swig_obj[1] ;
27475
27476 if (!args) SWIG_fail;
27477 swig_obj[0] = args;
27478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27479 if (!SWIG_IsOK(res1)) {
27480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27481 }
27482 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27483 {
27484 PyThreadState* __tstate = wxPyBeginAllowThreads();
27485 (arg1)->ExitMainLoop();
27486 wxPyEndAllowThreads(__tstate);
27487 if (PyErr_Occurred()) SWIG_fail;
27488 }
27489 resultobj = SWIG_Py_Void();
27490 return resultobj;
27491 fail:
27492 return NULL;
27493 }
27494
27495
27496 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27497 PyObject *resultobj = 0;
27498 wxPyApp *arg1 = (wxPyApp *) 0 ;
27499 bool result;
27500 void *argp1 = 0 ;
27501 int res1 = 0 ;
27502 PyObject *swig_obj[1] ;
27503
27504 if (!args) SWIG_fail;
27505 swig_obj[0] = args;
27506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27507 if (!SWIG_IsOK(res1)) {
27508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27509 }
27510 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27511 {
27512 PyThreadState* __tstate = wxPyBeginAllowThreads();
27513 result = (bool)(arg1)->Pending();
27514 wxPyEndAllowThreads(__tstate);
27515 if (PyErr_Occurred()) SWIG_fail;
27516 }
27517 {
27518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27519 }
27520 return resultobj;
27521 fail:
27522 return NULL;
27523 }
27524
27525
27526 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27527 PyObject *resultobj = 0;
27528 wxPyApp *arg1 = (wxPyApp *) 0 ;
27529 bool result;
27530 void *argp1 = 0 ;
27531 int res1 = 0 ;
27532 PyObject *swig_obj[1] ;
27533
27534 if (!args) SWIG_fail;
27535 swig_obj[0] = args;
27536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27537 if (!SWIG_IsOK(res1)) {
27538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27539 }
27540 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27541 {
27542 PyThreadState* __tstate = wxPyBeginAllowThreads();
27543 result = (bool)(arg1)->Dispatch();
27544 wxPyEndAllowThreads(__tstate);
27545 if (PyErr_Occurred()) SWIG_fail;
27546 }
27547 {
27548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27549 }
27550 return resultobj;
27551 fail:
27552 return NULL;
27553 }
27554
27555
27556 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27557 PyObject *resultobj = 0;
27558 wxPyApp *arg1 = (wxPyApp *) 0 ;
27559 bool result;
27560 void *argp1 = 0 ;
27561 int res1 = 0 ;
27562 PyObject *swig_obj[1] ;
27563
27564 if (!args) SWIG_fail;
27565 swig_obj[0] = args;
27566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27567 if (!SWIG_IsOK(res1)) {
27568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27569 }
27570 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27571 {
27572 PyThreadState* __tstate = wxPyBeginAllowThreads();
27573 result = (bool)(arg1)->ProcessIdle();
27574 wxPyEndAllowThreads(__tstate);
27575 if (PyErr_Occurred()) SWIG_fail;
27576 }
27577 {
27578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27579 }
27580 return resultobj;
27581 fail:
27582 return NULL;
27583 }
27584
27585
27586 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27587 PyObject *resultobj = 0;
27588 wxPyApp *arg1 = (wxPyApp *) 0 ;
27589 wxWindow *arg2 = (wxWindow *) 0 ;
27590 wxIdleEvent *arg3 = 0 ;
27591 bool result;
27592 void *argp1 = 0 ;
27593 int res1 = 0 ;
27594 void *argp2 = 0 ;
27595 int res2 = 0 ;
27596 void *argp3 = 0 ;
27597 int res3 = 0 ;
27598 PyObject * obj0 = 0 ;
27599 PyObject * obj1 = 0 ;
27600 PyObject * obj2 = 0 ;
27601 char * kwnames[] = {
27602 (char *) "self",(char *) "win",(char *) "event", NULL
27603 };
27604
27605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27607 if (!SWIG_IsOK(res1)) {
27608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27609 }
27610 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27611 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27612 if (!SWIG_IsOK(res2)) {
27613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27614 }
27615 arg2 = reinterpret_cast< wxWindow * >(argp2);
27616 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27617 if (!SWIG_IsOK(res3)) {
27618 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27619 }
27620 if (!argp3) {
27621 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27622 }
27623 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27624 {
27625 PyThreadState* __tstate = wxPyBeginAllowThreads();
27626 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27627 wxPyEndAllowThreads(__tstate);
27628 if (PyErr_Occurred()) SWIG_fail;
27629 }
27630 {
27631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27632 }
27633 return resultobj;
27634 fail:
27635 return NULL;
27636 }
27637
27638
27639 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27640 PyObject *resultobj = 0;
27641 wxPyApp *arg1 = (wxPyApp *) 0 ;
27642 bool result;
27643 void *argp1 = 0 ;
27644 int res1 = 0 ;
27645 PyObject *swig_obj[1] ;
27646
27647 if (!args) SWIG_fail;
27648 swig_obj[0] = args;
27649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27650 if (!SWIG_IsOK(res1)) {
27651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27652 }
27653 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27654 {
27655 PyThreadState* __tstate = wxPyBeginAllowThreads();
27656 result = (bool)((wxPyApp const *)arg1)->IsActive();
27657 wxPyEndAllowThreads(__tstate);
27658 if (PyErr_Occurred()) SWIG_fail;
27659 }
27660 {
27661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27662 }
27663 return resultobj;
27664 fail:
27665 return NULL;
27666 }
27667
27668
27669 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27670 PyObject *resultobj = 0;
27671 wxPyApp *arg1 = (wxPyApp *) 0 ;
27672 wxWindow *arg2 = (wxWindow *) 0 ;
27673 void *argp1 = 0 ;
27674 int res1 = 0 ;
27675 void *argp2 = 0 ;
27676 int res2 = 0 ;
27677 PyObject * obj0 = 0 ;
27678 PyObject * obj1 = 0 ;
27679 char * kwnames[] = {
27680 (char *) "self",(char *) "win", NULL
27681 };
27682
27683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27685 if (!SWIG_IsOK(res1)) {
27686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27687 }
27688 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27689 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27690 if (!SWIG_IsOK(res2)) {
27691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27692 }
27693 arg2 = reinterpret_cast< wxWindow * >(argp2);
27694 {
27695 PyThreadState* __tstate = wxPyBeginAllowThreads();
27696 (arg1)->SetTopWindow(arg2);
27697 wxPyEndAllowThreads(__tstate);
27698 if (PyErr_Occurred()) SWIG_fail;
27699 }
27700 resultobj = SWIG_Py_Void();
27701 return resultobj;
27702 fail:
27703 return NULL;
27704 }
27705
27706
27707 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27708 PyObject *resultobj = 0;
27709 wxPyApp *arg1 = (wxPyApp *) 0 ;
27710 wxWindow *result = 0 ;
27711 void *argp1 = 0 ;
27712 int res1 = 0 ;
27713 PyObject *swig_obj[1] ;
27714
27715 if (!args) SWIG_fail;
27716 swig_obj[0] = args;
27717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27718 if (!SWIG_IsOK(res1)) {
27719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27720 }
27721 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27722 {
27723 PyThreadState* __tstate = wxPyBeginAllowThreads();
27724 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27725 wxPyEndAllowThreads(__tstate);
27726 if (PyErr_Occurred()) SWIG_fail;
27727 }
27728 {
27729 resultobj = wxPyMake_wxObject(result, (bool)0);
27730 }
27731 return resultobj;
27732 fail:
27733 return NULL;
27734 }
27735
27736
27737 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27738 PyObject *resultobj = 0;
27739 wxPyApp *arg1 = (wxPyApp *) 0 ;
27740 bool arg2 ;
27741 void *argp1 = 0 ;
27742 int res1 = 0 ;
27743 bool val2 ;
27744 int ecode2 = 0 ;
27745 PyObject * obj0 = 0 ;
27746 PyObject * obj1 = 0 ;
27747 char * kwnames[] = {
27748 (char *) "self",(char *) "flag", NULL
27749 };
27750
27751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27753 if (!SWIG_IsOK(res1)) {
27754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27755 }
27756 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27757 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27758 if (!SWIG_IsOK(ecode2)) {
27759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27760 }
27761 arg2 = static_cast< bool >(val2);
27762 {
27763 PyThreadState* __tstate = wxPyBeginAllowThreads();
27764 (arg1)->SetExitOnFrameDelete(arg2);
27765 wxPyEndAllowThreads(__tstate);
27766 if (PyErr_Occurred()) SWIG_fail;
27767 }
27768 resultobj = SWIG_Py_Void();
27769 return resultobj;
27770 fail:
27771 return NULL;
27772 }
27773
27774
27775 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27776 PyObject *resultobj = 0;
27777 wxPyApp *arg1 = (wxPyApp *) 0 ;
27778 bool result;
27779 void *argp1 = 0 ;
27780 int res1 = 0 ;
27781 PyObject *swig_obj[1] ;
27782
27783 if (!args) SWIG_fail;
27784 swig_obj[0] = args;
27785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27786 if (!SWIG_IsOK(res1)) {
27787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27788 }
27789 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27790 {
27791 PyThreadState* __tstate = wxPyBeginAllowThreads();
27792 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27793 wxPyEndAllowThreads(__tstate);
27794 if (PyErr_Occurred()) SWIG_fail;
27795 }
27796 {
27797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27798 }
27799 return resultobj;
27800 fail:
27801 return NULL;
27802 }
27803
27804
27805 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27806 PyObject *resultobj = 0;
27807 wxPyApp *arg1 = (wxPyApp *) 0 ;
27808 bool arg2 ;
27809 void *argp1 = 0 ;
27810 int res1 = 0 ;
27811 bool val2 ;
27812 int ecode2 = 0 ;
27813 PyObject * obj0 = 0 ;
27814 PyObject * obj1 = 0 ;
27815 char * kwnames[] = {
27816 (char *) "self",(char *) "flag", NULL
27817 };
27818
27819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27821 if (!SWIG_IsOK(res1)) {
27822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27823 }
27824 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27825 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27826 if (!SWIG_IsOK(ecode2)) {
27827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27828 }
27829 arg2 = static_cast< bool >(val2);
27830 {
27831 PyThreadState* __tstate = wxPyBeginAllowThreads();
27832 (arg1)->SetUseBestVisual(arg2);
27833 wxPyEndAllowThreads(__tstate);
27834 if (PyErr_Occurred()) SWIG_fail;
27835 }
27836 resultobj = SWIG_Py_Void();
27837 return resultobj;
27838 fail:
27839 return NULL;
27840 }
27841
27842
27843 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27844 PyObject *resultobj = 0;
27845 wxPyApp *arg1 = (wxPyApp *) 0 ;
27846 bool result;
27847 void *argp1 = 0 ;
27848 int res1 = 0 ;
27849 PyObject *swig_obj[1] ;
27850
27851 if (!args) SWIG_fail;
27852 swig_obj[0] = args;
27853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27854 if (!SWIG_IsOK(res1)) {
27855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27856 }
27857 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27858 {
27859 PyThreadState* __tstate = wxPyBeginAllowThreads();
27860 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27861 wxPyEndAllowThreads(__tstate);
27862 if (PyErr_Occurred()) SWIG_fail;
27863 }
27864 {
27865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27866 }
27867 return resultobj;
27868 fail:
27869 return NULL;
27870 }
27871
27872
27873 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27874 PyObject *resultobj = 0;
27875 wxPyApp *arg1 = (wxPyApp *) 0 ;
27876 int arg2 ;
27877 void *argp1 = 0 ;
27878 int res1 = 0 ;
27879 int val2 ;
27880 int ecode2 = 0 ;
27881 PyObject * obj0 = 0 ;
27882 PyObject * obj1 = 0 ;
27883 char * kwnames[] = {
27884 (char *) "self",(char *) "mode", NULL
27885 };
27886
27887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27889 if (!SWIG_IsOK(res1)) {
27890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27891 }
27892 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27893 ecode2 = SWIG_AsVal_int(obj1, &val2);
27894 if (!SWIG_IsOK(ecode2)) {
27895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27896 }
27897 arg2 = static_cast< int >(val2);
27898 {
27899 PyThreadState* __tstate = wxPyBeginAllowThreads();
27900 (arg1)->SetPrintMode(arg2);
27901 wxPyEndAllowThreads(__tstate);
27902 if (PyErr_Occurred()) SWIG_fail;
27903 }
27904 resultobj = SWIG_Py_Void();
27905 return resultobj;
27906 fail:
27907 return NULL;
27908 }
27909
27910
27911 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27912 PyObject *resultobj = 0;
27913 wxPyApp *arg1 = (wxPyApp *) 0 ;
27914 int result;
27915 void *argp1 = 0 ;
27916 int res1 = 0 ;
27917 PyObject *swig_obj[1] ;
27918
27919 if (!args) SWIG_fail;
27920 swig_obj[0] = args;
27921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27922 if (!SWIG_IsOK(res1)) {
27923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27924 }
27925 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27926 {
27927 PyThreadState* __tstate = wxPyBeginAllowThreads();
27928 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27929 wxPyEndAllowThreads(__tstate);
27930 if (PyErr_Occurred()) SWIG_fail;
27931 }
27932 resultobj = SWIG_From_int(static_cast< int >(result));
27933 return resultobj;
27934 fail:
27935 return NULL;
27936 }
27937
27938
27939 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27940 PyObject *resultobj = 0;
27941 wxPyApp *arg1 = (wxPyApp *) 0 ;
27942 int arg2 ;
27943 void *argp1 = 0 ;
27944 int res1 = 0 ;
27945 int val2 ;
27946 int ecode2 = 0 ;
27947 PyObject * obj0 = 0 ;
27948 PyObject * obj1 = 0 ;
27949 char * kwnames[] = {
27950 (char *) "self",(char *) "mode", NULL
27951 };
27952
27953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27955 if (!SWIG_IsOK(res1)) {
27956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27957 }
27958 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27959 ecode2 = SWIG_AsVal_int(obj1, &val2);
27960 if (!SWIG_IsOK(ecode2)) {
27961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27962 }
27963 arg2 = static_cast< int >(val2);
27964 {
27965 PyThreadState* __tstate = wxPyBeginAllowThreads();
27966 (arg1)->SetAssertMode(arg2);
27967 wxPyEndAllowThreads(__tstate);
27968 if (PyErr_Occurred()) SWIG_fail;
27969 }
27970 resultobj = SWIG_Py_Void();
27971 return resultobj;
27972 fail:
27973 return NULL;
27974 }
27975
27976
27977 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27978 PyObject *resultobj = 0;
27979 wxPyApp *arg1 = (wxPyApp *) 0 ;
27980 int result;
27981 void *argp1 = 0 ;
27982 int res1 = 0 ;
27983 PyObject *swig_obj[1] ;
27984
27985 if (!args) SWIG_fail;
27986 swig_obj[0] = args;
27987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27988 if (!SWIG_IsOK(res1)) {
27989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27990 }
27991 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27992 {
27993 PyThreadState* __tstate = wxPyBeginAllowThreads();
27994 result = (int)(arg1)->GetAssertMode();
27995 wxPyEndAllowThreads(__tstate);
27996 if (PyErr_Occurred()) SWIG_fail;
27997 }
27998 resultobj = SWIG_From_int(static_cast< int >(result));
27999 return resultobj;
28000 fail:
28001 return NULL;
28002 }
28003
28004
28005 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28006 PyObject *resultobj = 0;
28007 bool result;
28008
28009 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28010 {
28011 PyThreadState* __tstate = wxPyBeginAllowThreads();
28012 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28013 wxPyEndAllowThreads(__tstate);
28014 if (PyErr_Occurred()) SWIG_fail;
28015 }
28016 {
28017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28018 }
28019 return resultobj;
28020 fail:
28021 return NULL;
28022 }
28023
28024
28025 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28026 PyObject *resultobj = 0;
28027 long result;
28028
28029 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28030 {
28031 PyThreadState* __tstate = wxPyBeginAllowThreads();
28032 result = (long)wxPyApp::GetMacAboutMenuItemId();
28033 wxPyEndAllowThreads(__tstate);
28034 if (PyErr_Occurred()) SWIG_fail;
28035 }
28036 resultobj = SWIG_From_long(static_cast< long >(result));
28037 return resultobj;
28038 fail:
28039 return NULL;
28040 }
28041
28042
28043 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28044 PyObject *resultobj = 0;
28045 long result;
28046
28047 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28048 {
28049 PyThreadState* __tstate = wxPyBeginAllowThreads();
28050 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28051 wxPyEndAllowThreads(__tstate);
28052 if (PyErr_Occurred()) SWIG_fail;
28053 }
28054 resultobj = SWIG_From_long(static_cast< long >(result));
28055 return resultobj;
28056 fail:
28057 return NULL;
28058 }
28059
28060
28061 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28062 PyObject *resultobj = 0;
28063 long result;
28064
28065 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28066 {
28067 PyThreadState* __tstate = wxPyBeginAllowThreads();
28068 result = (long)wxPyApp::GetMacExitMenuItemId();
28069 wxPyEndAllowThreads(__tstate);
28070 if (PyErr_Occurred()) SWIG_fail;
28071 }
28072 resultobj = SWIG_From_long(static_cast< long >(result));
28073 return resultobj;
28074 fail:
28075 return NULL;
28076 }
28077
28078
28079 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28080 PyObject *resultobj = 0;
28081 wxString result;
28082
28083 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28084 {
28085 PyThreadState* __tstate = wxPyBeginAllowThreads();
28086 result = wxPyApp::GetMacHelpMenuTitleName();
28087 wxPyEndAllowThreads(__tstate);
28088 if (PyErr_Occurred()) SWIG_fail;
28089 }
28090 {
28091 #if wxUSE_UNICODE
28092 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28093 #else
28094 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28095 #endif
28096 }
28097 return resultobj;
28098 fail:
28099 return NULL;
28100 }
28101
28102
28103 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28104 PyObject *resultobj = 0;
28105 bool arg1 ;
28106 bool val1 ;
28107 int ecode1 = 0 ;
28108 PyObject * obj0 = 0 ;
28109 char * kwnames[] = {
28110 (char *) "val", NULL
28111 };
28112
28113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28114 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28115 if (!SWIG_IsOK(ecode1)) {
28116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28117 }
28118 arg1 = static_cast< bool >(val1);
28119 {
28120 PyThreadState* __tstate = wxPyBeginAllowThreads();
28121 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28122 wxPyEndAllowThreads(__tstate);
28123 if (PyErr_Occurred()) SWIG_fail;
28124 }
28125 resultobj = SWIG_Py_Void();
28126 return resultobj;
28127 fail:
28128 return NULL;
28129 }
28130
28131
28132 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28133 PyObject *resultobj = 0;
28134 long arg1 ;
28135 long val1 ;
28136 int ecode1 = 0 ;
28137 PyObject * obj0 = 0 ;
28138 char * kwnames[] = {
28139 (char *) "val", NULL
28140 };
28141
28142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28143 ecode1 = SWIG_AsVal_long(obj0, &val1);
28144 if (!SWIG_IsOK(ecode1)) {
28145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28146 }
28147 arg1 = static_cast< long >(val1);
28148 {
28149 PyThreadState* __tstate = wxPyBeginAllowThreads();
28150 wxPyApp::SetMacAboutMenuItemId(arg1);
28151 wxPyEndAllowThreads(__tstate);
28152 if (PyErr_Occurred()) SWIG_fail;
28153 }
28154 resultobj = SWIG_Py_Void();
28155 return resultobj;
28156 fail:
28157 return NULL;
28158 }
28159
28160
28161 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28162 PyObject *resultobj = 0;
28163 long arg1 ;
28164 long val1 ;
28165 int ecode1 = 0 ;
28166 PyObject * obj0 = 0 ;
28167 char * kwnames[] = {
28168 (char *) "val", NULL
28169 };
28170
28171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28172 ecode1 = SWIG_AsVal_long(obj0, &val1);
28173 if (!SWIG_IsOK(ecode1)) {
28174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28175 }
28176 arg1 = static_cast< long >(val1);
28177 {
28178 PyThreadState* __tstate = wxPyBeginAllowThreads();
28179 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28180 wxPyEndAllowThreads(__tstate);
28181 if (PyErr_Occurred()) SWIG_fail;
28182 }
28183 resultobj = SWIG_Py_Void();
28184 return resultobj;
28185 fail:
28186 return NULL;
28187 }
28188
28189
28190 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28191 PyObject *resultobj = 0;
28192 long arg1 ;
28193 long val1 ;
28194 int ecode1 = 0 ;
28195 PyObject * obj0 = 0 ;
28196 char * kwnames[] = {
28197 (char *) "val", NULL
28198 };
28199
28200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28201 ecode1 = SWIG_AsVal_long(obj0, &val1);
28202 if (!SWIG_IsOK(ecode1)) {
28203 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28204 }
28205 arg1 = static_cast< long >(val1);
28206 {
28207 PyThreadState* __tstate = wxPyBeginAllowThreads();
28208 wxPyApp::SetMacExitMenuItemId(arg1);
28209 wxPyEndAllowThreads(__tstate);
28210 if (PyErr_Occurred()) SWIG_fail;
28211 }
28212 resultobj = SWIG_Py_Void();
28213 return resultobj;
28214 fail:
28215 return NULL;
28216 }
28217
28218
28219 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28220 PyObject *resultobj = 0;
28221 wxString *arg1 = 0 ;
28222 bool temp1 = false ;
28223 PyObject * obj0 = 0 ;
28224 char * kwnames[] = {
28225 (char *) "val", NULL
28226 };
28227
28228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28229 {
28230 arg1 = wxString_in_helper(obj0);
28231 if (arg1 == NULL) SWIG_fail;
28232 temp1 = true;
28233 }
28234 {
28235 PyThreadState* __tstate = wxPyBeginAllowThreads();
28236 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28237 wxPyEndAllowThreads(__tstate);
28238 if (PyErr_Occurred()) SWIG_fail;
28239 }
28240 resultobj = SWIG_Py_Void();
28241 {
28242 if (temp1)
28243 delete arg1;
28244 }
28245 return resultobj;
28246 fail:
28247 {
28248 if (temp1)
28249 delete arg1;
28250 }
28251 return NULL;
28252 }
28253
28254
28255 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28256 PyObject *resultobj = 0;
28257 wxPyApp *arg1 = (wxPyApp *) 0 ;
28258 void *argp1 = 0 ;
28259 int res1 = 0 ;
28260 PyObject *swig_obj[1] ;
28261
28262 if (!args) SWIG_fail;
28263 swig_obj[0] = args;
28264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28265 if (!SWIG_IsOK(res1)) {
28266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28267 }
28268 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28269 {
28270 PyThreadState* __tstate = wxPyBeginAllowThreads();
28271 (arg1)->_BootstrapApp();
28272 wxPyEndAllowThreads(__tstate);
28273 if (PyErr_Occurred()) SWIG_fail;
28274 }
28275 resultobj = SWIG_Py_Void();
28276 return resultobj;
28277 fail:
28278 return NULL;
28279 }
28280
28281
28282 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28283 PyObject *resultobj = 0;
28284 int result;
28285
28286 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28287 {
28288 PyThreadState* __tstate = wxPyBeginAllowThreads();
28289 result = (int)wxPyApp::GetComCtl32Version();
28290 wxPyEndAllowThreads(__tstate);
28291 if (PyErr_Occurred()) SWIG_fail;
28292 }
28293 resultobj = SWIG_From_int(static_cast< int >(result));
28294 return resultobj;
28295 fail:
28296 return NULL;
28297 }
28298
28299
28300 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28301 PyObject *obj;
28302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28303 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28304 return SWIG_Py_Void();
28305 }
28306
28307 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28308 return SWIG_Python_InitShadowInstance(args);
28309 }
28310
28311 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28312 PyObject *resultobj = 0;
28313
28314 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28315 {
28316 PyThreadState* __tstate = wxPyBeginAllowThreads();
28317 wxExit();
28318 wxPyEndAllowThreads(__tstate);
28319 if (PyErr_Occurred()) SWIG_fail;
28320 }
28321 resultobj = SWIG_Py_Void();
28322 return resultobj;
28323 fail:
28324 return NULL;
28325 }
28326
28327
28328 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28329 PyObject *resultobj = 0;
28330 bool result;
28331
28332 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28333 {
28334 PyThreadState* __tstate = wxPyBeginAllowThreads();
28335 result = (bool)wxYield();
28336 wxPyEndAllowThreads(__tstate);
28337 if (PyErr_Occurred()) SWIG_fail;
28338 }
28339 {
28340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28341 }
28342 return resultobj;
28343 fail:
28344 return NULL;
28345 }
28346
28347
28348 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28349 PyObject *resultobj = 0;
28350 bool result;
28351
28352 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28353 {
28354 PyThreadState* __tstate = wxPyBeginAllowThreads();
28355 result = (bool)wxYieldIfNeeded();
28356 wxPyEndAllowThreads(__tstate);
28357 if (PyErr_Occurred()) SWIG_fail;
28358 }
28359 {
28360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28361 }
28362 return resultobj;
28363 fail:
28364 return NULL;
28365 }
28366
28367
28368 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28369 PyObject *resultobj = 0;
28370 wxWindow *arg1 = (wxWindow *) NULL ;
28371 bool arg2 = (bool) false ;
28372 bool result;
28373 void *argp1 = 0 ;
28374 int res1 = 0 ;
28375 bool val2 ;
28376 int ecode2 = 0 ;
28377 PyObject * obj0 = 0 ;
28378 PyObject * obj1 = 0 ;
28379 char * kwnames[] = {
28380 (char *) "win",(char *) "onlyIfNeeded", NULL
28381 };
28382
28383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28384 if (obj0) {
28385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28386 if (!SWIG_IsOK(res1)) {
28387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28388 }
28389 arg1 = reinterpret_cast< wxWindow * >(argp1);
28390 }
28391 if (obj1) {
28392 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28393 if (!SWIG_IsOK(ecode2)) {
28394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28395 }
28396 arg2 = static_cast< bool >(val2);
28397 }
28398 {
28399 PyThreadState* __tstate = wxPyBeginAllowThreads();
28400 result = (bool)wxSafeYield(arg1,arg2);
28401 wxPyEndAllowThreads(__tstate);
28402 if (PyErr_Occurred()) SWIG_fail;
28403 }
28404 {
28405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28406 }
28407 return resultobj;
28408 fail:
28409 return NULL;
28410 }
28411
28412
28413 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28414 PyObject *resultobj = 0;
28415
28416 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28417 {
28418 PyThreadState* __tstate = wxPyBeginAllowThreads();
28419 wxWakeUpIdle();
28420 wxPyEndAllowThreads(__tstate);
28421 if (PyErr_Occurred()) SWIG_fail;
28422 }
28423 resultobj = SWIG_Py_Void();
28424 return resultobj;
28425 fail:
28426 return NULL;
28427 }
28428
28429
28430 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28431 PyObject *resultobj = 0;
28432 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28433 wxEvent *arg2 = 0 ;
28434 void *argp1 = 0 ;
28435 int res1 = 0 ;
28436 void *argp2 = 0 ;
28437 int res2 = 0 ;
28438 PyObject * obj0 = 0 ;
28439 PyObject * obj1 = 0 ;
28440 char * kwnames[] = {
28441 (char *) "dest",(char *) "event", NULL
28442 };
28443
28444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28446 if (!SWIG_IsOK(res1)) {
28447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28448 }
28449 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28450 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28451 if (!SWIG_IsOK(res2)) {
28452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28453 }
28454 if (!argp2) {
28455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28456 }
28457 arg2 = reinterpret_cast< wxEvent * >(argp2);
28458 {
28459 PyThreadState* __tstate = wxPyBeginAllowThreads();
28460 wxPostEvent(arg1,*arg2);
28461 wxPyEndAllowThreads(__tstate);
28462 if (PyErr_Occurred()) SWIG_fail;
28463 }
28464 resultobj = SWIG_Py_Void();
28465 return resultobj;
28466 fail:
28467 return NULL;
28468 }
28469
28470
28471 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28472 PyObject *resultobj = 0;
28473
28474 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28475 {
28476 PyThreadState* __tstate = wxPyBeginAllowThreads();
28477 wxApp_CleanUp();
28478 wxPyEndAllowThreads(__tstate);
28479 if (PyErr_Occurred()) SWIG_fail;
28480 }
28481 resultobj = SWIG_Py_Void();
28482 return resultobj;
28483 fail:
28484 return NULL;
28485 }
28486
28487
28488 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28489 PyObject *resultobj = 0;
28490 wxPyApp *result = 0 ;
28491
28492 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28493 {
28494 PyThreadState* __tstate = wxPyBeginAllowThreads();
28495 result = (wxPyApp *)wxPyGetApp();
28496 wxPyEndAllowThreads(__tstate);
28497 if (PyErr_Occurred()) SWIG_fail;
28498 }
28499 {
28500 resultobj = wxPyMake_wxObject(result, 0);
28501 }
28502 return resultobj;
28503 fail:
28504 return NULL;
28505 }
28506
28507
28508 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28509 PyObject *resultobj = 0;
28510 char *arg1 = (char *) 0 ;
28511 int res1 ;
28512 char *buf1 = 0 ;
28513 int alloc1 = 0 ;
28514 PyObject * obj0 = 0 ;
28515 char * kwnames[] = {
28516 (char *) "encoding", NULL
28517 };
28518
28519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28520 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28521 if (!SWIG_IsOK(res1)) {
28522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28523 }
28524 arg1 = buf1;
28525 {
28526 PyThreadState* __tstate = wxPyBeginAllowThreads();
28527 wxSetDefaultPyEncoding((char const *)arg1);
28528 wxPyEndAllowThreads(__tstate);
28529 if (PyErr_Occurred()) SWIG_fail;
28530 }
28531 resultobj = SWIG_Py_Void();
28532 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28533 return resultobj;
28534 fail:
28535 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28536 return NULL;
28537 }
28538
28539
28540 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28541 PyObject *resultobj = 0;
28542 char *result = 0 ;
28543
28544 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28545 {
28546 PyThreadState* __tstate = wxPyBeginAllowThreads();
28547 result = (char *)wxGetDefaultPyEncoding();
28548 wxPyEndAllowThreads(__tstate);
28549 if (PyErr_Occurred()) SWIG_fail;
28550 }
28551 resultobj = SWIG_FromCharPtr(result);
28552 return resultobj;
28553 fail:
28554 return NULL;
28555 }
28556
28557
28558 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28559 PyObject *resultobj = 0;
28560 wxEventLoop *result = 0 ;
28561
28562 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28563 {
28564 PyThreadState* __tstate = wxPyBeginAllowThreads();
28565 result = (wxEventLoop *)new wxEventLoop();
28566 wxPyEndAllowThreads(__tstate);
28567 if (PyErr_Occurred()) SWIG_fail;
28568 }
28569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28570 return resultobj;
28571 fail:
28572 return NULL;
28573 }
28574
28575
28576 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28577 PyObject *resultobj = 0;
28578 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28579 void *argp1 = 0 ;
28580 int res1 = 0 ;
28581 PyObject *swig_obj[1] ;
28582
28583 if (!args) SWIG_fail;
28584 swig_obj[0] = args;
28585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28586 if (!SWIG_IsOK(res1)) {
28587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28588 }
28589 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28590 {
28591 PyThreadState* __tstate = wxPyBeginAllowThreads();
28592 delete arg1;
28593
28594 wxPyEndAllowThreads(__tstate);
28595 if (PyErr_Occurred()) SWIG_fail;
28596 }
28597 resultobj = SWIG_Py_Void();
28598 return resultobj;
28599 fail:
28600 return NULL;
28601 }
28602
28603
28604 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28605 PyObject *resultobj = 0;
28606 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28607 int result;
28608 void *argp1 = 0 ;
28609 int res1 = 0 ;
28610 PyObject *swig_obj[1] ;
28611
28612 if (!args) SWIG_fail;
28613 swig_obj[0] = args;
28614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28615 if (!SWIG_IsOK(res1)) {
28616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28617 }
28618 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28619 {
28620 PyThreadState* __tstate = wxPyBeginAllowThreads();
28621 result = (int)(arg1)->Run();
28622 wxPyEndAllowThreads(__tstate);
28623 if (PyErr_Occurred()) SWIG_fail;
28624 }
28625 resultobj = SWIG_From_int(static_cast< int >(result));
28626 return resultobj;
28627 fail:
28628 return NULL;
28629 }
28630
28631
28632 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28633 PyObject *resultobj = 0;
28634 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28635 int arg2 = (int) 0 ;
28636 void *argp1 = 0 ;
28637 int res1 = 0 ;
28638 int val2 ;
28639 int ecode2 = 0 ;
28640 PyObject * obj0 = 0 ;
28641 PyObject * obj1 = 0 ;
28642 char * kwnames[] = {
28643 (char *) "self",(char *) "rc", NULL
28644 };
28645
28646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28648 if (!SWIG_IsOK(res1)) {
28649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28650 }
28651 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28652 if (obj1) {
28653 ecode2 = SWIG_AsVal_int(obj1, &val2);
28654 if (!SWIG_IsOK(ecode2)) {
28655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28656 }
28657 arg2 = static_cast< int >(val2);
28658 }
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 (arg1)->Exit(arg2);
28662 wxPyEndAllowThreads(__tstate);
28663 if (PyErr_Occurred()) SWIG_fail;
28664 }
28665 resultobj = SWIG_Py_Void();
28666 return resultobj;
28667 fail:
28668 return NULL;
28669 }
28670
28671
28672 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28673 PyObject *resultobj = 0;
28674 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28675 bool result;
28676 void *argp1 = 0 ;
28677 int res1 = 0 ;
28678 PyObject *swig_obj[1] ;
28679
28680 if (!args) SWIG_fail;
28681 swig_obj[0] = args;
28682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28683 if (!SWIG_IsOK(res1)) {
28684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28685 }
28686 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28687 {
28688 PyThreadState* __tstate = wxPyBeginAllowThreads();
28689 result = (bool)((wxEventLoop const *)arg1)->Pending();
28690 wxPyEndAllowThreads(__tstate);
28691 if (PyErr_Occurred()) SWIG_fail;
28692 }
28693 {
28694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28695 }
28696 return resultobj;
28697 fail:
28698 return NULL;
28699 }
28700
28701
28702 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28703 PyObject *resultobj = 0;
28704 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28705 bool result;
28706 void *argp1 = 0 ;
28707 int res1 = 0 ;
28708 PyObject *swig_obj[1] ;
28709
28710 if (!args) SWIG_fail;
28711 swig_obj[0] = args;
28712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28713 if (!SWIG_IsOK(res1)) {
28714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28715 }
28716 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28717 {
28718 PyThreadState* __tstate = wxPyBeginAllowThreads();
28719 result = (bool)(arg1)->Dispatch();
28720 wxPyEndAllowThreads(__tstate);
28721 if (PyErr_Occurred()) SWIG_fail;
28722 }
28723 {
28724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28725 }
28726 return resultobj;
28727 fail:
28728 return NULL;
28729 }
28730
28731
28732 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28733 PyObject *resultobj = 0;
28734 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28735 bool result;
28736 void *argp1 = 0 ;
28737 int res1 = 0 ;
28738 PyObject *swig_obj[1] ;
28739
28740 if (!args) SWIG_fail;
28741 swig_obj[0] = args;
28742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28743 if (!SWIG_IsOK(res1)) {
28744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28745 }
28746 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28747 {
28748 PyThreadState* __tstate = wxPyBeginAllowThreads();
28749 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28750 wxPyEndAllowThreads(__tstate);
28751 if (PyErr_Occurred()) SWIG_fail;
28752 }
28753 {
28754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28755 }
28756 return resultobj;
28757 fail:
28758 return NULL;
28759 }
28760
28761
28762 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28763 PyObject *resultobj = 0;
28764 wxEventLoop *result = 0 ;
28765
28766 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28767 {
28768 PyThreadState* __tstate = wxPyBeginAllowThreads();
28769 result = (wxEventLoop *)wxEventLoop::GetActive();
28770 wxPyEndAllowThreads(__tstate);
28771 if (PyErr_Occurred()) SWIG_fail;
28772 }
28773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28774 return resultobj;
28775 fail:
28776 return NULL;
28777 }
28778
28779
28780 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28781 PyObject *resultobj = 0;
28782 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28783 void *argp1 = 0 ;
28784 int res1 = 0 ;
28785 PyObject * obj0 = 0 ;
28786 char * kwnames[] = {
28787 (char *) "loop", NULL
28788 };
28789
28790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28792 if (!SWIG_IsOK(res1)) {
28793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28794 }
28795 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28796 {
28797 PyThreadState* __tstate = wxPyBeginAllowThreads();
28798 wxEventLoop::SetActive(arg1);
28799 wxPyEndAllowThreads(__tstate);
28800 if (PyErr_Occurred()) SWIG_fail;
28801 }
28802 resultobj = SWIG_Py_Void();
28803 return resultobj;
28804 fail:
28805 return NULL;
28806 }
28807
28808
28809 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28810 PyObject *obj;
28811 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28812 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28813 return SWIG_Py_Void();
28814 }
28815
28816 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28817 return SWIG_Python_InitShadowInstance(args);
28818 }
28819
28820 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28821 PyObject *resultobj = 0;
28822 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28823 wxEventLoopActivator *result = 0 ;
28824 void *argp1 = 0 ;
28825 int res1 = 0 ;
28826 PyObject * obj0 = 0 ;
28827 char * kwnames[] = {
28828 (char *) "evtLoop", NULL
28829 };
28830
28831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28833 if (!SWIG_IsOK(res1)) {
28834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28835 }
28836 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28837 {
28838 PyThreadState* __tstate = wxPyBeginAllowThreads();
28839 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28840 wxPyEndAllowThreads(__tstate);
28841 if (PyErr_Occurred()) SWIG_fail;
28842 }
28843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28844 return resultobj;
28845 fail:
28846 return NULL;
28847 }
28848
28849
28850 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28851 PyObject *resultobj = 0;
28852 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28853 void *argp1 = 0 ;
28854 int res1 = 0 ;
28855 PyObject *swig_obj[1] ;
28856
28857 if (!args) SWIG_fail;
28858 swig_obj[0] = args;
28859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28860 if (!SWIG_IsOK(res1)) {
28861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28862 }
28863 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28864 {
28865 PyThreadState* __tstate = wxPyBeginAllowThreads();
28866 delete arg1;
28867
28868 wxPyEndAllowThreads(__tstate);
28869 if (PyErr_Occurred()) SWIG_fail;
28870 }
28871 resultobj = SWIG_Py_Void();
28872 return resultobj;
28873 fail:
28874 return NULL;
28875 }
28876
28877
28878 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28879 PyObject *obj;
28880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28881 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28882 return SWIG_Py_Void();
28883 }
28884
28885 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28886 return SWIG_Python_InitShadowInstance(args);
28887 }
28888
28889 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28890 PyObject *resultobj = 0;
28891 int arg1 = (int) 0 ;
28892 int arg2 = (int) 0 ;
28893 int arg3 = (int) 0 ;
28894 wxAcceleratorEntry *result = 0 ;
28895 int val1 ;
28896 int ecode1 = 0 ;
28897 int val2 ;
28898 int ecode2 = 0 ;
28899 int val3 ;
28900 int ecode3 = 0 ;
28901 PyObject * obj0 = 0 ;
28902 PyObject * obj1 = 0 ;
28903 PyObject * obj2 = 0 ;
28904 char * kwnames[] = {
28905 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28906 };
28907
28908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28909 if (obj0) {
28910 ecode1 = SWIG_AsVal_int(obj0, &val1);
28911 if (!SWIG_IsOK(ecode1)) {
28912 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28913 }
28914 arg1 = static_cast< int >(val1);
28915 }
28916 if (obj1) {
28917 ecode2 = SWIG_AsVal_int(obj1, &val2);
28918 if (!SWIG_IsOK(ecode2)) {
28919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28920 }
28921 arg2 = static_cast< int >(val2);
28922 }
28923 if (obj2) {
28924 ecode3 = SWIG_AsVal_int(obj2, &val3);
28925 if (!SWIG_IsOK(ecode3)) {
28926 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28927 }
28928 arg3 = static_cast< int >(val3);
28929 }
28930 {
28931 PyThreadState* __tstate = wxPyBeginAllowThreads();
28932 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28933 wxPyEndAllowThreads(__tstate);
28934 if (PyErr_Occurred()) SWIG_fail;
28935 }
28936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28937 return resultobj;
28938 fail:
28939 return NULL;
28940 }
28941
28942
28943 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28944 PyObject *resultobj = 0;
28945 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28946 void *argp1 = 0 ;
28947 int res1 = 0 ;
28948 PyObject *swig_obj[1] ;
28949
28950 if (!args) SWIG_fail;
28951 swig_obj[0] = args;
28952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28953 if (!SWIG_IsOK(res1)) {
28954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28955 }
28956 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28957 {
28958 PyThreadState* __tstate = wxPyBeginAllowThreads();
28959 delete arg1;
28960
28961 wxPyEndAllowThreads(__tstate);
28962 if (PyErr_Occurred()) SWIG_fail;
28963 }
28964 resultobj = SWIG_Py_Void();
28965 return resultobj;
28966 fail:
28967 return NULL;
28968 }
28969
28970
28971 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28972 PyObject *resultobj = 0;
28973 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28974 int arg2 ;
28975 int arg3 ;
28976 int arg4 ;
28977 void *argp1 = 0 ;
28978 int res1 = 0 ;
28979 int val2 ;
28980 int ecode2 = 0 ;
28981 int val3 ;
28982 int ecode3 = 0 ;
28983 int val4 ;
28984 int ecode4 = 0 ;
28985 PyObject * obj0 = 0 ;
28986 PyObject * obj1 = 0 ;
28987 PyObject * obj2 = 0 ;
28988 PyObject * obj3 = 0 ;
28989 char * kwnames[] = {
28990 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28991 };
28992
28993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28995 if (!SWIG_IsOK(res1)) {
28996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28997 }
28998 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28999 ecode2 = SWIG_AsVal_int(obj1, &val2);
29000 if (!SWIG_IsOK(ecode2)) {
29001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29002 }
29003 arg2 = static_cast< int >(val2);
29004 ecode3 = SWIG_AsVal_int(obj2, &val3);
29005 if (!SWIG_IsOK(ecode3)) {
29006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29007 }
29008 arg3 = static_cast< int >(val3);
29009 ecode4 = SWIG_AsVal_int(obj3, &val4);
29010 if (!SWIG_IsOK(ecode4)) {
29011 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29012 }
29013 arg4 = static_cast< int >(val4);
29014 {
29015 PyThreadState* __tstate = wxPyBeginAllowThreads();
29016 (arg1)->Set(arg2,arg3,arg4);
29017 wxPyEndAllowThreads(__tstate);
29018 if (PyErr_Occurred()) SWIG_fail;
29019 }
29020 resultobj = SWIG_Py_Void();
29021 return resultobj;
29022 fail:
29023 return NULL;
29024 }
29025
29026
29027 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29028 PyObject *resultobj = 0;
29029 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29030 int result;
29031 void *argp1 = 0 ;
29032 int res1 = 0 ;
29033 PyObject *swig_obj[1] ;
29034
29035 if (!args) SWIG_fail;
29036 swig_obj[0] = args;
29037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29038 if (!SWIG_IsOK(res1)) {
29039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29040 }
29041 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29042 {
29043 PyThreadState* __tstate = wxPyBeginAllowThreads();
29044 result = (int)(arg1)->GetFlags();
29045 wxPyEndAllowThreads(__tstate);
29046 if (PyErr_Occurred()) SWIG_fail;
29047 }
29048 resultobj = SWIG_From_int(static_cast< int >(result));
29049 return resultobj;
29050 fail:
29051 return NULL;
29052 }
29053
29054
29055 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29056 PyObject *resultobj = 0;
29057 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29058 int result;
29059 void *argp1 = 0 ;
29060 int res1 = 0 ;
29061 PyObject *swig_obj[1] ;
29062
29063 if (!args) SWIG_fail;
29064 swig_obj[0] = args;
29065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29066 if (!SWIG_IsOK(res1)) {
29067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29068 }
29069 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29070 {
29071 PyThreadState* __tstate = wxPyBeginAllowThreads();
29072 result = (int)(arg1)->GetKeyCode();
29073 wxPyEndAllowThreads(__tstate);
29074 if (PyErr_Occurred()) SWIG_fail;
29075 }
29076 resultobj = SWIG_From_int(static_cast< int >(result));
29077 return resultobj;
29078 fail:
29079 return NULL;
29080 }
29081
29082
29083 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29084 PyObject *resultobj = 0;
29085 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29086 int result;
29087 void *argp1 = 0 ;
29088 int res1 = 0 ;
29089 PyObject *swig_obj[1] ;
29090
29091 if (!args) SWIG_fail;
29092 swig_obj[0] = args;
29093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29094 if (!SWIG_IsOK(res1)) {
29095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29096 }
29097 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29098 {
29099 PyThreadState* __tstate = wxPyBeginAllowThreads();
29100 result = (int)(arg1)->GetCommand();
29101 wxPyEndAllowThreads(__tstate);
29102 if (PyErr_Occurred()) SWIG_fail;
29103 }
29104 resultobj = SWIG_From_int(static_cast< int >(result));
29105 return resultobj;
29106 fail:
29107 return NULL;
29108 }
29109
29110
29111 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29112 PyObject *obj;
29113 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29114 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29115 return SWIG_Py_Void();
29116 }
29117
29118 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29119 return SWIG_Python_InitShadowInstance(args);
29120 }
29121
29122 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29123 PyObject *resultobj = 0;
29124 int arg1 ;
29125 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29126 wxAcceleratorTable *result = 0 ;
29127 PyObject * obj0 = 0 ;
29128 char * kwnames[] = {
29129 (char *) "n", NULL
29130 };
29131
29132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29133 {
29134 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29135 if (arg2) arg1 = PyList_Size(obj0);
29136 else arg1 = 0;
29137 }
29138 {
29139 PyThreadState* __tstate = wxPyBeginAllowThreads();
29140 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29141 wxPyEndAllowThreads(__tstate);
29142 if (PyErr_Occurred()) SWIG_fail;
29143 }
29144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29145 return resultobj;
29146 fail:
29147 return NULL;
29148 }
29149
29150
29151 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29152 PyObject *resultobj = 0;
29153 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29154 void *argp1 = 0 ;
29155 int res1 = 0 ;
29156 PyObject *swig_obj[1] ;
29157
29158 if (!args) SWIG_fail;
29159 swig_obj[0] = args;
29160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29161 if (!SWIG_IsOK(res1)) {
29162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29163 }
29164 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29165 {
29166 PyThreadState* __tstate = wxPyBeginAllowThreads();
29167 delete arg1;
29168
29169 wxPyEndAllowThreads(__tstate);
29170 if (PyErr_Occurred()) SWIG_fail;
29171 }
29172 resultobj = SWIG_Py_Void();
29173 return resultobj;
29174 fail:
29175 return NULL;
29176 }
29177
29178
29179 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29180 PyObject *resultobj = 0;
29181 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29182 bool result;
29183 void *argp1 = 0 ;
29184 int res1 = 0 ;
29185 PyObject *swig_obj[1] ;
29186
29187 if (!args) SWIG_fail;
29188 swig_obj[0] = args;
29189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29190 if (!SWIG_IsOK(res1)) {
29191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29192 }
29193 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29194 {
29195 PyThreadState* __tstate = wxPyBeginAllowThreads();
29196 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29197 wxPyEndAllowThreads(__tstate);
29198 if (PyErr_Occurred()) SWIG_fail;
29199 }
29200 {
29201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29202 }
29203 return resultobj;
29204 fail:
29205 return NULL;
29206 }
29207
29208
29209 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29210 PyObject *obj;
29211 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29212 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29213 return SWIG_Py_Void();
29214 }
29215
29216 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29217 return SWIG_Python_InitShadowInstance(args);
29218 }
29219
29220 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29221 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29222 return 1;
29223 }
29224
29225
29226 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29227 PyObject *pyobj = 0;
29228
29229 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29230 return pyobj;
29231 }
29232
29233
29234 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29235 PyObject *resultobj = 0;
29236 wxString *arg1 = 0 ;
29237 wxAcceleratorEntry *result = 0 ;
29238 bool temp1 = false ;
29239 PyObject * obj0 = 0 ;
29240 char * kwnames[] = {
29241 (char *) "label", NULL
29242 };
29243
29244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29245 {
29246 arg1 = wxString_in_helper(obj0);
29247 if (arg1 == NULL) SWIG_fail;
29248 temp1 = true;
29249 }
29250 {
29251 PyThreadState* __tstate = wxPyBeginAllowThreads();
29252 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29253 wxPyEndAllowThreads(__tstate);
29254 if (PyErr_Occurred()) SWIG_fail;
29255 }
29256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29257 {
29258 if (temp1)
29259 delete arg1;
29260 }
29261 return resultobj;
29262 fail:
29263 {
29264 if (temp1)
29265 delete arg1;
29266 }
29267 return NULL;
29268 }
29269
29270
29271 SWIGINTERN int PanelNameStr_set(PyObject *) {
29272 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29273 return 1;
29274 }
29275
29276
29277 SWIGINTERN PyObject *PanelNameStr_get(void) {
29278 PyObject *pyobj = 0;
29279
29280 {
29281 #if wxUSE_UNICODE
29282 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29283 #else
29284 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29285 #endif
29286 }
29287 return pyobj;
29288 }
29289
29290
29291 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29292 PyObject *resultobj = 0;
29293 wxVisualAttributes *result = 0 ;
29294
29295 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29296 {
29297 PyThreadState* __tstate = wxPyBeginAllowThreads();
29298 result = (wxVisualAttributes *)new_wxVisualAttributes();
29299 wxPyEndAllowThreads(__tstate);
29300 if (PyErr_Occurred()) SWIG_fail;
29301 }
29302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29303 return resultobj;
29304 fail:
29305 return NULL;
29306 }
29307
29308
29309 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29310 PyObject *resultobj = 0;
29311 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29312 void *argp1 = 0 ;
29313 int res1 = 0 ;
29314 PyObject *swig_obj[1] ;
29315
29316 if (!args) SWIG_fail;
29317 swig_obj[0] = args;
29318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29319 if (!SWIG_IsOK(res1)) {
29320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29321 }
29322 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29323 {
29324 PyThreadState* __tstate = wxPyBeginAllowThreads();
29325 delete_wxVisualAttributes(arg1);
29326
29327 wxPyEndAllowThreads(__tstate);
29328 if (PyErr_Occurred()) SWIG_fail;
29329 }
29330 resultobj = SWIG_Py_Void();
29331 return resultobj;
29332 fail:
29333 return NULL;
29334 }
29335
29336
29337 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29338 PyObject *resultobj = 0;
29339 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29340 wxFont *arg2 = (wxFont *) 0 ;
29341 void *argp1 = 0 ;
29342 int res1 = 0 ;
29343 void *argp2 = 0 ;
29344 int res2 = 0 ;
29345 PyObject *swig_obj[2] ;
29346
29347 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29349 if (!SWIG_IsOK(res1)) {
29350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29351 }
29352 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29353 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29354 if (!SWIG_IsOK(res2)) {
29355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29356 }
29357 arg2 = reinterpret_cast< wxFont * >(argp2);
29358 if (arg1) (arg1)->font = *arg2;
29359
29360 resultobj = SWIG_Py_Void();
29361 return resultobj;
29362 fail:
29363 return NULL;
29364 }
29365
29366
29367 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29368 PyObject *resultobj = 0;
29369 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29370 wxFont *result = 0 ;
29371 void *argp1 = 0 ;
29372 int res1 = 0 ;
29373 PyObject *swig_obj[1] ;
29374
29375 if (!args) SWIG_fail;
29376 swig_obj[0] = args;
29377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29378 if (!SWIG_IsOK(res1)) {
29379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29380 }
29381 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29382 result = (wxFont *)& ((arg1)->font);
29383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29384 return resultobj;
29385 fail:
29386 return NULL;
29387 }
29388
29389
29390 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29391 PyObject *resultobj = 0;
29392 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29393 wxColour *arg2 = (wxColour *) 0 ;
29394 void *argp1 = 0 ;
29395 int res1 = 0 ;
29396 void *argp2 = 0 ;
29397 int res2 = 0 ;
29398 PyObject *swig_obj[2] ;
29399
29400 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29402 if (!SWIG_IsOK(res1)) {
29403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29404 }
29405 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29406 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29407 if (!SWIG_IsOK(res2)) {
29408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29409 }
29410 arg2 = reinterpret_cast< wxColour * >(argp2);
29411 if (arg1) (arg1)->colFg = *arg2;
29412
29413 resultobj = SWIG_Py_Void();
29414 return resultobj;
29415 fail:
29416 return NULL;
29417 }
29418
29419
29420 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29421 PyObject *resultobj = 0;
29422 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29423 wxColour *result = 0 ;
29424 void *argp1 = 0 ;
29425 int res1 = 0 ;
29426 PyObject *swig_obj[1] ;
29427
29428 if (!args) SWIG_fail;
29429 swig_obj[0] = args;
29430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29431 if (!SWIG_IsOK(res1)) {
29432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29433 }
29434 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29435 result = (wxColour *)& ((arg1)->colFg);
29436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29437 return resultobj;
29438 fail:
29439 return NULL;
29440 }
29441
29442
29443 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29444 PyObject *resultobj = 0;
29445 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29446 wxColour *arg2 = (wxColour *) 0 ;
29447 void *argp1 = 0 ;
29448 int res1 = 0 ;
29449 void *argp2 = 0 ;
29450 int res2 = 0 ;
29451 PyObject *swig_obj[2] ;
29452
29453 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29455 if (!SWIG_IsOK(res1)) {
29456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29457 }
29458 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29459 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29460 if (!SWIG_IsOK(res2)) {
29461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29462 }
29463 arg2 = reinterpret_cast< wxColour * >(argp2);
29464 if (arg1) (arg1)->colBg = *arg2;
29465
29466 resultobj = SWIG_Py_Void();
29467 return resultobj;
29468 fail:
29469 return NULL;
29470 }
29471
29472
29473 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29474 PyObject *resultobj = 0;
29475 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29476 wxColour *result = 0 ;
29477 void *argp1 = 0 ;
29478 int res1 = 0 ;
29479 PyObject *swig_obj[1] ;
29480
29481 if (!args) SWIG_fail;
29482 swig_obj[0] = args;
29483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29484 if (!SWIG_IsOK(res1)) {
29485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29486 }
29487 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29488 result = (wxColour *)& ((arg1)->colBg);
29489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29490 return resultobj;
29491 fail:
29492 return NULL;
29493 }
29494
29495
29496 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29497 PyObject *obj;
29498 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29499 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29500 return SWIG_Py_Void();
29501 }
29502
29503 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29504 return SWIG_Python_InitShadowInstance(args);
29505 }
29506
29507 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29508 PyObject *resultobj = 0;
29509 wxWindow *arg1 = (wxWindow *) 0 ;
29510 int arg2 = (int) (int)-1 ;
29511 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29512 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29513 wxSize const &arg4_defvalue = wxDefaultSize ;
29514 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29515 long arg5 = (long) 0 ;
29516 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29517 wxString *arg6 = (wxString *) &arg6_defvalue ;
29518 wxWindow *result = 0 ;
29519 void *argp1 = 0 ;
29520 int res1 = 0 ;
29521 int val2 ;
29522 int ecode2 = 0 ;
29523 wxPoint temp3 ;
29524 wxSize temp4 ;
29525 long val5 ;
29526 int ecode5 = 0 ;
29527 bool temp6 = false ;
29528 PyObject * obj0 = 0 ;
29529 PyObject * obj1 = 0 ;
29530 PyObject * obj2 = 0 ;
29531 PyObject * obj3 = 0 ;
29532 PyObject * obj4 = 0 ;
29533 PyObject * obj5 = 0 ;
29534 char * kwnames[] = {
29535 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29536 };
29537
29538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29540 if (!SWIG_IsOK(res1)) {
29541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29542 }
29543 arg1 = reinterpret_cast< wxWindow * >(argp1);
29544 if (obj1) {
29545 ecode2 = SWIG_AsVal_int(obj1, &val2);
29546 if (!SWIG_IsOK(ecode2)) {
29547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29548 }
29549 arg2 = static_cast< int >(val2);
29550 }
29551 if (obj2) {
29552 {
29553 arg3 = &temp3;
29554 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29555 }
29556 }
29557 if (obj3) {
29558 {
29559 arg4 = &temp4;
29560 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29561 }
29562 }
29563 if (obj4) {
29564 ecode5 = SWIG_AsVal_long(obj4, &val5);
29565 if (!SWIG_IsOK(ecode5)) {
29566 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29567 }
29568 arg5 = static_cast< long >(val5);
29569 }
29570 if (obj5) {
29571 {
29572 arg6 = wxString_in_helper(obj5);
29573 if (arg6 == NULL) SWIG_fail;
29574 temp6 = true;
29575 }
29576 }
29577 {
29578 if (!wxPyCheckForApp()) SWIG_fail;
29579 PyThreadState* __tstate = wxPyBeginAllowThreads();
29580 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29581 wxPyEndAllowThreads(__tstate);
29582 if (PyErr_Occurred()) SWIG_fail;
29583 }
29584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29585 {
29586 if (temp6)
29587 delete arg6;
29588 }
29589 return resultobj;
29590 fail:
29591 {
29592 if (temp6)
29593 delete arg6;
29594 }
29595 return NULL;
29596 }
29597
29598
29599 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29600 PyObject *resultobj = 0;
29601 wxWindow *result = 0 ;
29602
29603 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29604 {
29605 if (!wxPyCheckForApp()) SWIG_fail;
29606 PyThreadState* __tstate = wxPyBeginAllowThreads();
29607 result = (wxWindow *)new wxWindow();
29608 wxPyEndAllowThreads(__tstate);
29609 if (PyErr_Occurred()) SWIG_fail;
29610 }
29611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29612 return resultobj;
29613 fail:
29614 return NULL;
29615 }
29616
29617
29618 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29619 PyObject *resultobj = 0;
29620 wxWindow *arg1 = (wxWindow *) 0 ;
29621 wxWindow *arg2 = (wxWindow *) 0 ;
29622 int arg3 = (int) (int)-1 ;
29623 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29624 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29625 wxSize const &arg5_defvalue = wxDefaultSize ;
29626 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29627 long arg6 = (long) 0 ;
29628 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29629 wxString *arg7 = (wxString *) &arg7_defvalue ;
29630 bool result;
29631 void *argp1 = 0 ;
29632 int res1 = 0 ;
29633 void *argp2 = 0 ;
29634 int res2 = 0 ;
29635 int val3 ;
29636 int ecode3 = 0 ;
29637 wxPoint temp4 ;
29638 wxSize temp5 ;
29639 long val6 ;
29640 int ecode6 = 0 ;
29641 bool temp7 = false ;
29642 PyObject * obj0 = 0 ;
29643 PyObject * obj1 = 0 ;
29644 PyObject * obj2 = 0 ;
29645 PyObject * obj3 = 0 ;
29646 PyObject * obj4 = 0 ;
29647 PyObject * obj5 = 0 ;
29648 PyObject * obj6 = 0 ;
29649 char * kwnames[] = {
29650 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29651 };
29652
29653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29655 if (!SWIG_IsOK(res1)) {
29656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29657 }
29658 arg1 = reinterpret_cast< wxWindow * >(argp1);
29659 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29660 if (!SWIG_IsOK(res2)) {
29661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29662 }
29663 arg2 = reinterpret_cast< wxWindow * >(argp2);
29664 if (obj2) {
29665 ecode3 = SWIG_AsVal_int(obj2, &val3);
29666 if (!SWIG_IsOK(ecode3)) {
29667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29668 }
29669 arg3 = static_cast< int >(val3);
29670 }
29671 if (obj3) {
29672 {
29673 arg4 = &temp4;
29674 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29675 }
29676 }
29677 if (obj4) {
29678 {
29679 arg5 = &temp5;
29680 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29681 }
29682 }
29683 if (obj5) {
29684 ecode6 = SWIG_AsVal_long(obj5, &val6);
29685 if (!SWIG_IsOK(ecode6)) {
29686 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29687 }
29688 arg6 = static_cast< long >(val6);
29689 }
29690 if (obj6) {
29691 {
29692 arg7 = wxString_in_helper(obj6);
29693 if (arg7 == NULL) SWIG_fail;
29694 temp7 = true;
29695 }
29696 }
29697 {
29698 PyThreadState* __tstate = wxPyBeginAllowThreads();
29699 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29700 wxPyEndAllowThreads(__tstate);
29701 if (PyErr_Occurred()) SWIG_fail;
29702 }
29703 {
29704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29705 }
29706 {
29707 if (temp7)
29708 delete arg7;
29709 }
29710 return resultobj;
29711 fail:
29712 {
29713 if (temp7)
29714 delete arg7;
29715 }
29716 return NULL;
29717 }
29718
29719
29720 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29721 PyObject *resultobj = 0;
29722 wxWindow *arg1 = (wxWindow *) 0 ;
29723 bool arg2 = (bool) false ;
29724 bool result;
29725 void *argp1 = 0 ;
29726 int res1 = 0 ;
29727 bool val2 ;
29728 int ecode2 = 0 ;
29729 PyObject * obj0 = 0 ;
29730 PyObject * obj1 = 0 ;
29731 char * kwnames[] = {
29732 (char *) "self",(char *) "force", NULL
29733 };
29734
29735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29737 if (!SWIG_IsOK(res1)) {
29738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29739 }
29740 arg1 = reinterpret_cast< wxWindow * >(argp1);
29741 if (obj1) {
29742 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29743 if (!SWIG_IsOK(ecode2)) {
29744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29745 }
29746 arg2 = static_cast< bool >(val2);
29747 }
29748 {
29749 PyThreadState* __tstate = wxPyBeginAllowThreads();
29750 result = (bool)(arg1)->Close(arg2);
29751 wxPyEndAllowThreads(__tstate);
29752 if (PyErr_Occurred()) SWIG_fail;
29753 }
29754 {
29755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29756 }
29757 return resultobj;
29758 fail:
29759 return NULL;
29760 }
29761
29762
29763 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29764 PyObject *resultobj = 0;
29765 wxWindow *arg1 = (wxWindow *) 0 ;
29766 bool result;
29767 void *argp1 = 0 ;
29768 int res1 = 0 ;
29769 PyObject *swig_obj[1] ;
29770
29771 if (!args) SWIG_fail;
29772 swig_obj[0] = args;
29773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29774 if (!SWIG_IsOK(res1)) {
29775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29776 }
29777 arg1 = reinterpret_cast< wxWindow * >(argp1);
29778 {
29779 PyThreadState* __tstate = wxPyBeginAllowThreads();
29780 result = (bool)(arg1)->Destroy();
29781 wxPyEndAllowThreads(__tstate);
29782 if (PyErr_Occurred()) SWIG_fail;
29783 }
29784 {
29785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29786 }
29787 return resultobj;
29788 fail:
29789 return NULL;
29790 }
29791
29792
29793 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29794 PyObject *resultobj = 0;
29795 wxWindow *arg1 = (wxWindow *) 0 ;
29796 bool result;
29797 void *argp1 = 0 ;
29798 int res1 = 0 ;
29799 PyObject *swig_obj[1] ;
29800
29801 if (!args) SWIG_fail;
29802 swig_obj[0] = args;
29803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29804 if (!SWIG_IsOK(res1)) {
29805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29806 }
29807 arg1 = reinterpret_cast< wxWindow * >(argp1);
29808 {
29809 PyThreadState* __tstate = wxPyBeginAllowThreads();
29810 result = (bool)(arg1)->DestroyChildren();
29811 wxPyEndAllowThreads(__tstate);
29812 if (PyErr_Occurred()) SWIG_fail;
29813 }
29814 {
29815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29816 }
29817 return resultobj;
29818 fail:
29819 return NULL;
29820 }
29821
29822
29823 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29824 PyObject *resultobj = 0;
29825 wxWindow *arg1 = (wxWindow *) 0 ;
29826 bool result;
29827 void *argp1 = 0 ;
29828 int res1 = 0 ;
29829 PyObject *swig_obj[1] ;
29830
29831 if (!args) SWIG_fail;
29832 swig_obj[0] = args;
29833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29834 if (!SWIG_IsOK(res1)) {
29835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29836 }
29837 arg1 = reinterpret_cast< wxWindow * >(argp1);
29838 {
29839 PyThreadState* __tstate = wxPyBeginAllowThreads();
29840 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29841 wxPyEndAllowThreads(__tstate);
29842 if (PyErr_Occurred()) SWIG_fail;
29843 }
29844 {
29845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29846 }
29847 return resultobj;
29848 fail:
29849 return NULL;
29850 }
29851
29852
29853 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29854 PyObject *resultobj = 0;
29855 wxWindow *arg1 = (wxWindow *) 0 ;
29856 wxString *arg2 = 0 ;
29857 void *argp1 = 0 ;
29858 int res1 = 0 ;
29859 bool temp2 = false ;
29860 PyObject * obj0 = 0 ;
29861 PyObject * obj1 = 0 ;
29862 char * kwnames[] = {
29863 (char *) "self",(char *) "label", NULL
29864 };
29865
29866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29868 if (!SWIG_IsOK(res1)) {
29869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29870 }
29871 arg1 = reinterpret_cast< wxWindow * >(argp1);
29872 {
29873 arg2 = wxString_in_helper(obj1);
29874 if (arg2 == NULL) SWIG_fail;
29875 temp2 = true;
29876 }
29877 {
29878 PyThreadState* __tstate = wxPyBeginAllowThreads();
29879 (arg1)->SetLabel((wxString const &)*arg2);
29880 wxPyEndAllowThreads(__tstate);
29881 if (PyErr_Occurred()) SWIG_fail;
29882 }
29883 resultobj = SWIG_Py_Void();
29884 {
29885 if (temp2)
29886 delete arg2;
29887 }
29888 return resultobj;
29889 fail:
29890 {
29891 if (temp2)
29892 delete arg2;
29893 }
29894 return NULL;
29895 }
29896
29897
29898 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29899 PyObject *resultobj = 0;
29900 wxWindow *arg1 = (wxWindow *) 0 ;
29901 wxString result;
29902 void *argp1 = 0 ;
29903 int res1 = 0 ;
29904 PyObject *swig_obj[1] ;
29905
29906 if (!args) SWIG_fail;
29907 swig_obj[0] = args;
29908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29909 if (!SWIG_IsOK(res1)) {
29910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29911 }
29912 arg1 = reinterpret_cast< wxWindow * >(argp1);
29913 {
29914 PyThreadState* __tstate = wxPyBeginAllowThreads();
29915 result = ((wxWindow const *)arg1)->GetLabel();
29916 wxPyEndAllowThreads(__tstate);
29917 if (PyErr_Occurred()) SWIG_fail;
29918 }
29919 {
29920 #if wxUSE_UNICODE
29921 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29922 #else
29923 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29924 #endif
29925 }
29926 return resultobj;
29927 fail:
29928 return NULL;
29929 }
29930
29931
29932 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29933 PyObject *resultobj = 0;
29934 wxWindow *arg1 = (wxWindow *) 0 ;
29935 wxString *arg2 = 0 ;
29936 void *argp1 = 0 ;
29937 int res1 = 0 ;
29938 bool temp2 = false ;
29939 PyObject * obj0 = 0 ;
29940 PyObject * obj1 = 0 ;
29941 char * kwnames[] = {
29942 (char *) "self",(char *) "name", NULL
29943 };
29944
29945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29947 if (!SWIG_IsOK(res1)) {
29948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29949 }
29950 arg1 = reinterpret_cast< wxWindow * >(argp1);
29951 {
29952 arg2 = wxString_in_helper(obj1);
29953 if (arg2 == NULL) SWIG_fail;
29954 temp2 = true;
29955 }
29956 {
29957 PyThreadState* __tstate = wxPyBeginAllowThreads();
29958 (arg1)->SetName((wxString const &)*arg2);
29959 wxPyEndAllowThreads(__tstate);
29960 if (PyErr_Occurred()) SWIG_fail;
29961 }
29962 resultobj = SWIG_Py_Void();
29963 {
29964 if (temp2)
29965 delete arg2;
29966 }
29967 return resultobj;
29968 fail:
29969 {
29970 if (temp2)
29971 delete arg2;
29972 }
29973 return NULL;
29974 }
29975
29976
29977 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29978 PyObject *resultobj = 0;
29979 wxWindow *arg1 = (wxWindow *) 0 ;
29980 wxString result;
29981 void *argp1 = 0 ;
29982 int res1 = 0 ;
29983 PyObject *swig_obj[1] ;
29984
29985 if (!args) SWIG_fail;
29986 swig_obj[0] = args;
29987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29988 if (!SWIG_IsOK(res1)) {
29989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29990 }
29991 arg1 = reinterpret_cast< wxWindow * >(argp1);
29992 {
29993 PyThreadState* __tstate = wxPyBeginAllowThreads();
29994 result = ((wxWindow const *)arg1)->GetName();
29995 wxPyEndAllowThreads(__tstate);
29996 if (PyErr_Occurred()) SWIG_fail;
29997 }
29998 {
29999 #if wxUSE_UNICODE
30000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30001 #else
30002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30003 #endif
30004 }
30005 return resultobj;
30006 fail:
30007 return NULL;
30008 }
30009
30010
30011 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30012 PyObject *resultobj = 0;
30013 wxWindow *arg1 = (wxWindow *) 0 ;
30014 wxWindowVariant arg2 ;
30015 void *argp1 = 0 ;
30016 int res1 = 0 ;
30017 int val2 ;
30018 int ecode2 = 0 ;
30019 PyObject * obj0 = 0 ;
30020 PyObject * obj1 = 0 ;
30021 char * kwnames[] = {
30022 (char *) "self",(char *) "variant", NULL
30023 };
30024
30025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30027 if (!SWIG_IsOK(res1)) {
30028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30029 }
30030 arg1 = reinterpret_cast< wxWindow * >(argp1);
30031 ecode2 = SWIG_AsVal_int(obj1, &val2);
30032 if (!SWIG_IsOK(ecode2)) {
30033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30034 }
30035 arg2 = static_cast< wxWindowVariant >(val2);
30036 {
30037 PyThreadState* __tstate = wxPyBeginAllowThreads();
30038 (arg1)->SetWindowVariant(arg2);
30039 wxPyEndAllowThreads(__tstate);
30040 if (PyErr_Occurred()) SWIG_fail;
30041 }
30042 resultobj = SWIG_Py_Void();
30043 return resultobj;
30044 fail:
30045 return NULL;
30046 }
30047
30048
30049 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30050 PyObject *resultobj = 0;
30051 wxWindow *arg1 = (wxWindow *) 0 ;
30052 wxWindowVariant result;
30053 void *argp1 = 0 ;
30054 int res1 = 0 ;
30055 PyObject *swig_obj[1] ;
30056
30057 if (!args) SWIG_fail;
30058 swig_obj[0] = args;
30059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30060 if (!SWIG_IsOK(res1)) {
30061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30062 }
30063 arg1 = reinterpret_cast< wxWindow * >(argp1);
30064 {
30065 PyThreadState* __tstate = wxPyBeginAllowThreads();
30066 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30067 wxPyEndAllowThreads(__tstate);
30068 if (PyErr_Occurred()) SWIG_fail;
30069 }
30070 resultobj = SWIG_From_int(static_cast< int >(result));
30071 return resultobj;
30072 fail:
30073 return NULL;
30074 }
30075
30076
30077 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30078 PyObject *resultobj = 0;
30079 wxWindow *arg1 = (wxWindow *) 0 ;
30080 int arg2 ;
30081 void *argp1 = 0 ;
30082 int res1 = 0 ;
30083 int val2 ;
30084 int ecode2 = 0 ;
30085 PyObject * obj0 = 0 ;
30086 PyObject * obj1 = 0 ;
30087 char * kwnames[] = {
30088 (char *) "self",(char *) "winid", NULL
30089 };
30090
30091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30093 if (!SWIG_IsOK(res1)) {
30094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30095 }
30096 arg1 = reinterpret_cast< wxWindow * >(argp1);
30097 ecode2 = SWIG_AsVal_int(obj1, &val2);
30098 if (!SWIG_IsOK(ecode2)) {
30099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30100 }
30101 arg2 = static_cast< int >(val2);
30102 {
30103 PyThreadState* __tstate = wxPyBeginAllowThreads();
30104 (arg1)->SetId(arg2);
30105 wxPyEndAllowThreads(__tstate);
30106 if (PyErr_Occurred()) SWIG_fail;
30107 }
30108 resultobj = SWIG_Py_Void();
30109 return resultobj;
30110 fail:
30111 return NULL;
30112 }
30113
30114
30115 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30116 PyObject *resultobj = 0;
30117 wxWindow *arg1 = (wxWindow *) 0 ;
30118 int result;
30119 void *argp1 = 0 ;
30120 int res1 = 0 ;
30121 PyObject *swig_obj[1] ;
30122
30123 if (!args) SWIG_fail;
30124 swig_obj[0] = args;
30125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30126 if (!SWIG_IsOK(res1)) {
30127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30128 }
30129 arg1 = reinterpret_cast< wxWindow * >(argp1);
30130 {
30131 PyThreadState* __tstate = wxPyBeginAllowThreads();
30132 result = (int)((wxWindow const *)arg1)->GetId();
30133 wxPyEndAllowThreads(__tstate);
30134 if (PyErr_Occurred()) SWIG_fail;
30135 }
30136 resultobj = SWIG_From_int(static_cast< int >(result));
30137 return resultobj;
30138 fail:
30139 return NULL;
30140 }
30141
30142
30143 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30144 PyObject *resultobj = 0;
30145 int result;
30146
30147 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30148 {
30149 PyThreadState* __tstate = wxPyBeginAllowThreads();
30150 result = (int)wxWindow::NewControlId();
30151 wxPyEndAllowThreads(__tstate);
30152 if (PyErr_Occurred()) SWIG_fail;
30153 }
30154 resultobj = SWIG_From_int(static_cast< int >(result));
30155 return resultobj;
30156 fail:
30157 return NULL;
30158 }
30159
30160
30161 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30162 PyObject *resultobj = 0;
30163 int arg1 ;
30164 int result;
30165 int val1 ;
30166 int ecode1 = 0 ;
30167 PyObject * obj0 = 0 ;
30168 char * kwnames[] = {
30169 (char *) "winid", NULL
30170 };
30171
30172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30173 ecode1 = SWIG_AsVal_int(obj0, &val1);
30174 if (!SWIG_IsOK(ecode1)) {
30175 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30176 }
30177 arg1 = static_cast< int >(val1);
30178 {
30179 PyThreadState* __tstate = wxPyBeginAllowThreads();
30180 result = (int)wxWindow::NextControlId(arg1);
30181 wxPyEndAllowThreads(__tstate);
30182 if (PyErr_Occurred()) SWIG_fail;
30183 }
30184 resultobj = SWIG_From_int(static_cast< int >(result));
30185 return resultobj;
30186 fail:
30187 return NULL;
30188 }
30189
30190
30191 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30192 PyObject *resultobj = 0;
30193 int arg1 ;
30194 int result;
30195 int val1 ;
30196 int ecode1 = 0 ;
30197 PyObject * obj0 = 0 ;
30198 char * kwnames[] = {
30199 (char *) "winid", NULL
30200 };
30201
30202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30203 ecode1 = SWIG_AsVal_int(obj0, &val1);
30204 if (!SWIG_IsOK(ecode1)) {
30205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30206 }
30207 arg1 = static_cast< int >(val1);
30208 {
30209 PyThreadState* __tstate = wxPyBeginAllowThreads();
30210 result = (int)wxWindow::PrevControlId(arg1);
30211 wxPyEndAllowThreads(__tstate);
30212 if (PyErr_Occurred()) SWIG_fail;
30213 }
30214 resultobj = SWIG_From_int(static_cast< int >(result));
30215 return resultobj;
30216 fail:
30217 return NULL;
30218 }
30219
30220
30221 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30222 PyObject *resultobj = 0;
30223 wxWindow *arg1 = (wxWindow *) 0 ;
30224 wxSize *arg2 = 0 ;
30225 void *argp1 = 0 ;
30226 int res1 = 0 ;
30227 wxSize temp2 ;
30228 PyObject * obj0 = 0 ;
30229 PyObject * obj1 = 0 ;
30230 char * kwnames[] = {
30231 (char *) "self",(char *) "size", NULL
30232 };
30233
30234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30236 if (!SWIG_IsOK(res1)) {
30237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30238 }
30239 arg1 = reinterpret_cast< wxWindow * >(argp1);
30240 {
30241 arg2 = &temp2;
30242 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30243 }
30244 {
30245 PyThreadState* __tstate = wxPyBeginAllowThreads();
30246 (arg1)->SetSize((wxSize const &)*arg2);
30247 wxPyEndAllowThreads(__tstate);
30248 if (PyErr_Occurred()) SWIG_fail;
30249 }
30250 resultobj = SWIG_Py_Void();
30251 return resultobj;
30252 fail:
30253 return NULL;
30254 }
30255
30256
30257 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30258 PyObject *resultobj = 0;
30259 wxWindow *arg1 = (wxWindow *) 0 ;
30260 int arg2 ;
30261 int arg3 ;
30262 int arg4 ;
30263 int arg5 ;
30264 int arg6 = (int) wxSIZE_AUTO ;
30265 void *argp1 = 0 ;
30266 int res1 = 0 ;
30267 int val2 ;
30268 int ecode2 = 0 ;
30269 int val3 ;
30270 int ecode3 = 0 ;
30271 int val4 ;
30272 int ecode4 = 0 ;
30273 int val5 ;
30274 int ecode5 = 0 ;
30275 int val6 ;
30276 int ecode6 = 0 ;
30277 PyObject * obj0 = 0 ;
30278 PyObject * obj1 = 0 ;
30279 PyObject * obj2 = 0 ;
30280 PyObject * obj3 = 0 ;
30281 PyObject * obj4 = 0 ;
30282 PyObject * obj5 = 0 ;
30283 char * kwnames[] = {
30284 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30285 };
30286
30287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30289 if (!SWIG_IsOK(res1)) {
30290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30291 }
30292 arg1 = reinterpret_cast< wxWindow * >(argp1);
30293 ecode2 = SWIG_AsVal_int(obj1, &val2);
30294 if (!SWIG_IsOK(ecode2)) {
30295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30296 }
30297 arg2 = static_cast< int >(val2);
30298 ecode3 = SWIG_AsVal_int(obj2, &val3);
30299 if (!SWIG_IsOK(ecode3)) {
30300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30301 }
30302 arg3 = static_cast< int >(val3);
30303 ecode4 = SWIG_AsVal_int(obj3, &val4);
30304 if (!SWIG_IsOK(ecode4)) {
30305 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30306 }
30307 arg4 = static_cast< int >(val4);
30308 ecode5 = SWIG_AsVal_int(obj4, &val5);
30309 if (!SWIG_IsOK(ecode5)) {
30310 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30311 }
30312 arg5 = static_cast< int >(val5);
30313 if (obj5) {
30314 ecode6 = SWIG_AsVal_int(obj5, &val6);
30315 if (!SWIG_IsOK(ecode6)) {
30316 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30317 }
30318 arg6 = static_cast< int >(val6);
30319 }
30320 {
30321 PyThreadState* __tstate = wxPyBeginAllowThreads();
30322 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30323 wxPyEndAllowThreads(__tstate);
30324 if (PyErr_Occurred()) SWIG_fail;
30325 }
30326 resultobj = SWIG_Py_Void();
30327 return resultobj;
30328 fail:
30329 return NULL;
30330 }
30331
30332
30333 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30334 PyObject *resultobj = 0;
30335 wxWindow *arg1 = (wxWindow *) 0 ;
30336 wxRect *arg2 = 0 ;
30337 int arg3 = (int) wxSIZE_AUTO ;
30338 void *argp1 = 0 ;
30339 int res1 = 0 ;
30340 wxRect temp2 ;
30341 int val3 ;
30342 int ecode3 = 0 ;
30343 PyObject * obj0 = 0 ;
30344 PyObject * obj1 = 0 ;
30345 PyObject * obj2 = 0 ;
30346 char * kwnames[] = {
30347 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30348 };
30349
30350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30352 if (!SWIG_IsOK(res1)) {
30353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30354 }
30355 arg1 = reinterpret_cast< wxWindow * >(argp1);
30356 {
30357 arg2 = &temp2;
30358 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30359 }
30360 if (obj2) {
30361 ecode3 = SWIG_AsVal_int(obj2, &val3);
30362 if (!SWIG_IsOK(ecode3)) {
30363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30364 }
30365 arg3 = static_cast< int >(val3);
30366 }
30367 {
30368 PyThreadState* __tstate = wxPyBeginAllowThreads();
30369 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30370 wxPyEndAllowThreads(__tstate);
30371 if (PyErr_Occurred()) SWIG_fail;
30372 }
30373 resultobj = SWIG_Py_Void();
30374 return resultobj;
30375 fail:
30376 return NULL;
30377 }
30378
30379
30380 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30381 PyObject *resultobj = 0;
30382 wxWindow *arg1 = (wxWindow *) 0 ;
30383 int arg2 ;
30384 int arg3 ;
30385 void *argp1 = 0 ;
30386 int res1 = 0 ;
30387 int val2 ;
30388 int ecode2 = 0 ;
30389 int val3 ;
30390 int ecode3 = 0 ;
30391 PyObject * obj0 = 0 ;
30392 PyObject * obj1 = 0 ;
30393 PyObject * obj2 = 0 ;
30394 char * kwnames[] = {
30395 (char *) "self",(char *) "width",(char *) "height", NULL
30396 };
30397
30398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30400 if (!SWIG_IsOK(res1)) {
30401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30402 }
30403 arg1 = reinterpret_cast< wxWindow * >(argp1);
30404 ecode2 = SWIG_AsVal_int(obj1, &val2);
30405 if (!SWIG_IsOK(ecode2)) {
30406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30407 }
30408 arg2 = static_cast< int >(val2);
30409 ecode3 = SWIG_AsVal_int(obj2, &val3);
30410 if (!SWIG_IsOK(ecode3)) {
30411 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30412 }
30413 arg3 = static_cast< int >(val3);
30414 {
30415 PyThreadState* __tstate = wxPyBeginAllowThreads();
30416 (arg1)->SetSize(arg2,arg3);
30417 wxPyEndAllowThreads(__tstate);
30418 if (PyErr_Occurred()) SWIG_fail;
30419 }
30420 resultobj = SWIG_Py_Void();
30421 return resultobj;
30422 fail:
30423 return NULL;
30424 }
30425
30426
30427 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30428 PyObject *resultobj = 0;
30429 wxWindow *arg1 = (wxWindow *) 0 ;
30430 wxPoint *arg2 = 0 ;
30431 int arg3 = (int) wxSIZE_USE_EXISTING ;
30432 void *argp1 = 0 ;
30433 int res1 = 0 ;
30434 wxPoint temp2 ;
30435 int val3 ;
30436 int ecode3 = 0 ;
30437 PyObject * obj0 = 0 ;
30438 PyObject * obj1 = 0 ;
30439 PyObject * obj2 = 0 ;
30440 char * kwnames[] = {
30441 (char *) "self",(char *) "pt",(char *) "flags", NULL
30442 };
30443
30444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30446 if (!SWIG_IsOK(res1)) {
30447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30448 }
30449 arg1 = reinterpret_cast< wxWindow * >(argp1);
30450 {
30451 arg2 = &temp2;
30452 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30453 }
30454 if (obj2) {
30455 ecode3 = SWIG_AsVal_int(obj2, &val3);
30456 if (!SWIG_IsOK(ecode3)) {
30457 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30458 }
30459 arg3 = static_cast< int >(val3);
30460 }
30461 {
30462 PyThreadState* __tstate = wxPyBeginAllowThreads();
30463 (arg1)->Move((wxPoint const &)*arg2,arg3);
30464 wxPyEndAllowThreads(__tstate);
30465 if (PyErr_Occurred()) SWIG_fail;
30466 }
30467 resultobj = SWIG_Py_Void();
30468 return resultobj;
30469 fail:
30470 return NULL;
30471 }
30472
30473
30474 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30475 PyObject *resultobj = 0;
30476 wxWindow *arg1 = (wxWindow *) 0 ;
30477 int arg2 ;
30478 int arg3 ;
30479 int arg4 = (int) wxSIZE_USE_EXISTING ;
30480 void *argp1 = 0 ;
30481 int res1 = 0 ;
30482 int val2 ;
30483 int ecode2 = 0 ;
30484 int val3 ;
30485 int ecode3 = 0 ;
30486 int val4 ;
30487 int ecode4 = 0 ;
30488 PyObject * obj0 = 0 ;
30489 PyObject * obj1 = 0 ;
30490 PyObject * obj2 = 0 ;
30491 PyObject * obj3 = 0 ;
30492 char * kwnames[] = {
30493 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30494 };
30495
30496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30498 if (!SWIG_IsOK(res1)) {
30499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30500 }
30501 arg1 = reinterpret_cast< wxWindow * >(argp1);
30502 ecode2 = SWIG_AsVal_int(obj1, &val2);
30503 if (!SWIG_IsOK(ecode2)) {
30504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30505 }
30506 arg2 = static_cast< int >(val2);
30507 ecode3 = SWIG_AsVal_int(obj2, &val3);
30508 if (!SWIG_IsOK(ecode3)) {
30509 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30510 }
30511 arg3 = static_cast< int >(val3);
30512 if (obj3) {
30513 ecode4 = SWIG_AsVal_int(obj3, &val4);
30514 if (!SWIG_IsOK(ecode4)) {
30515 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30516 }
30517 arg4 = static_cast< int >(val4);
30518 }
30519 {
30520 PyThreadState* __tstate = wxPyBeginAllowThreads();
30521 (arg1)->Move(arg2,arg3,arg4);
30522 wxPyEndAllowThreads(__tstate);
30523 if (PyErr_Occurred()) SWIG_fail;
30524 }
30525 resultobj = SWIG_Py_Void();
30526 return resultobj;
30527 fail:
30528 return NULL;
30529 }
30530
30531
30532 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30533 PyObject *resultobj = 0;
30534 wxWindow *arg1 = (wxWindow *) 0 ;
30535 wxSize const &arg2_defvalue = wxDefaultSize ;
30536 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30537 void *argp1 = 0 ;
30538 int res1 = 0 ;
30539 wxSize temp2 ;
30540 PyObject * obj0 = 0 ;
30541 PyObject * obj1 = 0 ;
30542 char * kwnames[] = {
30543 (char *) "self",(char *) "size", NULL
30544 };
30545
30546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30548 if (!SWIG_IsOK(res1)) {
30549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30550 }
30551 arg1 = reinterpret_cast< wxWindow * >(argp1);
30552 if (obj1) {
30553 {
30554 arg2 = &temp2;
30555 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30556 }
30557 }
30558 {
30559 PyThreadState* __tstate = wxPyBeginAllowThreads();
30560 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30561 wxPyEndAllowThreads(__tstate);
30562 if (PyErr_Occurred()) SWIG_fail;
30563 }
30564 resultobj = SWIG_Py_Void();
30565 return resultobj;
30566 fail:
30567 return NULL;
30568 }
30569
30570
30571 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30572 PyObject *resultobj = 0;
30573 wxWindow *arg1 = (wxWindow *) 0 ;
30574 void *argp1 = 0 ;
30575 int res1 = 0 ;
30576 PyObject *swig_obj[1] ;
30577
30578 if (!args) SWIG_fail;
30579 swig_obj[0] = args;
30580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30581 if (!SWIG_IsOK(res1)) {
30582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30583 }
30584 arg1 = reinterpret_cast< wxWindow * >(argp1);
30585 {
30586 PyThreadState* __tstate = wxPyBeginAllowThreads();
30587 (arg1)->Raise();
30588 wxPyEndAllowThreads(__tstate);
30589 if (PyErr_Occurred()) SWIG_fail;
30590 }
30591 resultobj = SWIG_Py_Void();
30592 return resultobj;
30593 fail:
30594 return NULL;
30595 }
30596
30597
30598 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30599 PyObject *resultobj = 0;
30600 wxWindow *arg1 = (wxWindow *) 0 ;
30601 void *argp1 = 0 ;
30602 int res1 = 0 ;
30603 PyObject *swig_obj[1] ;
30604
30605 if (!args) SWIG_fail;
30606 swig_obj[0] = args;
30607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30608 if (!SWIG_IsOK(res1)) {
30609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30610 }
30611 arg1 = reinterpret_cast< wxWindow * >(argp1);
30612 {
30613 PyThreadState* __tstate = wxPyBeginAllowThreads();
30614 (arg1)->Lower();
30615 wxPyEndAllowThreads(__tstate);
30616 if (PyErr_Occurred()) SWIG_fail;
30617 }
30618 resultobj = SWIG_Py_Void();
30619 return resultobj;
30620 fail:
30621 return NULL;
30622 }
30623
30624
30625 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30626 PyObject *resultobj = 0;
30627 wxWindow *arg1 = (wxWindow *) 0 ;
30628 wxSize *arg2 = 0 ;
30629 void *argp1 = 0 ;
30630 int res1 = 0 ;
30631 wxSize temp2 ;
30632 PyObject * obj0 = 0 ;
30633 PyObject * obj1 = 0 ;
30634 char * kwnames[] = {
30635 (char *) "self",(char *) "size", NULL
30636 };
30637
30638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30640 if (!SWIG_IsOK(res1)) {
30641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30642 }
30643 arg1 = reinterpret_cast< wxWindow * >(argp1);
30644 {
30645 arg2 = &temp2;
30646 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30647 }
30648 {
30649 PyThreadState* __tstate = wxPyBeginAllowThreads();
30650 (arg1)->SetClientSize((wxSize const &)*arg2);
30651 wxPyEndAllowThreads(__tstate);
30652 if (PyErr_Occurred()) SWIG_fail;
30653 }
30654 resultobj = SWIG_Py_Void();
30655 return resultobj;
30656 fail:
30657 return NULL;
30658 }
30659
30660
30661 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30662 PyObject *resultobj = 0;
30663 wxWindow *arg1 = (wxWindow *) 0 ;
30664 int arg2 ;
30665 int arg3 ;
30666 void *argp1 = 0 ;
30667 int res1 = 0 ;
30668 int val2 ;
30669 int ecode2 = 0 ;
30670 int val3 ;
30671 int ecode3 = 0 ;
30672 PyObject * obj0 = 0 ;
30673 PyObject * obj1 = 0 ;
30674 PyObject * obj2 = 0 ;
30675 char * kwnames[] = {
30676 (char *) "self",(char *) "width",(char *) "height", NULL
30677 };
30678
30679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30681 if (!SWIG_IsOK(res1)) {
30682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30683 }
30684 arg1 = reinterpret_cast< wxWindow * >(argp1);
30685 ecode2 = SWIG_AsVal_int(obj1, &val2);
30686 if (!SWIG_IsOK(ecode2)) {
30687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30688 }
30689 arg2 = static_cast< int >(val2);
30690 ecode3 = SWIG_AsVal_int(obj2, &val3);
30691 if (!SWIG_IsOK(ecode3)) {
30692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30693 }
30694 arg3 = static_cast< int >(val3);
30695 {
30696 PyThreadState* __tstate = wxPyBeginAllowThreads();
30697 (arg1)->SetClientSize(arg2,arg3);
30698 wxPyEndAllowThreads(__tstate);
30699 if (PyErr_Occurred()) SWIG_fail;
30700 }
30701 resultobj = SWIG_Py_Void();
30702 return resultobj;
30703 fail:
30704 return NULL;
30705 }
30706
30707
30708 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30709 PyObject *resultobj = 0;
30710 wxWindow *arg1 = (wxWindow *) 0 ;
30711 wxRect *arg2 = 0 ;
30712 void *argp1 = 0 ;
30713 int res1 = 0 ;
30714 wxRect temp2 ;
30715 PyObject * obj0 = 0 ;
30716 PyObject * obj1 = 0 ;
30717 char * kwnames[] = {
30718 (char *) "self",(char *) "rect", NULL
30719 };
30720
30721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30723 if (!SWIG_IsOK(res1)) {
30724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30725 }
30726 arg1 = reinterpret_cast< wxWindow * >(argp1);
30727 {
30728 arg2 = &temp2;
30729 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30730 }
30731 {
30732 PyThreadState* __tstate = wxPyBeginAllowThreads();
30733 (arg1)->SetClientSize((wxRect const &)*arg2);
30734 wxPyEndAllowThreads(__tstate);
30735 if (PyErr_Occurred()) SWIG_fail;
30736 }
30737 resultobj = SWIG_Py_Void();
30738 return resultobj;
30739 fail:
30740 return NULL;
30741 }
30742
30743
30744 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30745 PyObject *resultobj = 0;
30746 wxWindow *arg1 = (wxWindow *) 0 ;
30747 wxPoint result;
30748 void *argp1 = 0 ;
30749 int res1 = 0 ;
30750 PyObject *swig_obj[1] ;
30751
30752 if (!args) SWIG_fail;
30753 swig_obj[0] = args;
30754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30755 if (!SWIG_IsOK(res1)) {
30756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30757 }
30758 arg1 = reinterpret_cast< wxWindow * >(argp1);
30759 {
30760 PyThreadState* __tstate = wxPyBeginAllowThreads();
30761 result = ((wxWindow const *)arg1)->GetPosition();
30762 wxPyEndAllowThreads(__tstate);
30763 if (PyErr_Occurred()) SWIG_fail;
30764 }
30765 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30766 return resultobj;
30767 fail:
30768 return NULL;
30769 }
30770
30771
30772 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30773 PyObject *resultobj = 0;
30774 wxWindow *arg1 = (wxWindow *) 0 ;
30775 int *arg2 = (int *) 0 ;
30776 int *arg3 = (int *) 0 ;
30777 void *argp1 = 0 ;
30778 int res1 = 0 ;
30779 int temp2 ;
30780 int res2 = SWIG_TMPOBJ ;
30781 int temp3 ;
30782 int res3 = SWIG_TMPOBJ ;
30783 PyObject *swig_obj[1] ;
30784
30785 arg2 = &temp2;
30786 arg3 = &temp3;
30787 if (!args) SWIG_fail;
30788 swig_obj[0] = args;
30789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30790 if (!SWIG_IsOK(res1)) {
30791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30792 }
30793 arg1 = reinterpret_cast< wxWindow * >(argp1);
30794 {
30795 PyThreadState* __tstate = wxPyBeginAllowThreads();
30796 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30797 wxPyEndAllowThreads(__tstate);
30798 if (PyErr_Occurred()) SWIG_fail;
30799 }
30800 resultobj = SWIG_Py_Void();
30801 if (SWIG_IsTmpObj(res2)) {
30802 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30803 } else {
30804 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30806 }
30807 if (SWIG_IsTmpObj(res3)) {
30808 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30809 } else {
30810 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30811 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30812 }
30813 return resultobj;
30814 fail:
30815 return NULL;
30816 }
30817
30818
30819 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30820 PyObject *resultobj = 0;
30821 wxWindow *arg1 = (wxWindow *) 0 ;
30822 wxPoint result;
30823 void *argp1 = 0 ;
30824 int res1 = 0 ;
30825 PyObject *swig_obj[1] ;
30826
30827 if (!args) SWIG_fail;
30828 swig_obj[0] = args;
30829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30830 if (!SWIG_IsOK(res1)) {
30831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30832 }
30833 arg1 = reinterpret_cast< wxWindow * >(argp1);
30834 {
30835 PyThreadState* __tstate = wxPyBeginAllowThreads();
30836 result = ((wxWindow const *)arg1)->GetScreenPosition();
30837 wxPyEndAllowThreads(__tstate);
30838 if (PyErr_Occurred()) SWIG_fail;
30839 }
30840 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30841 return resultobj;
30842 fail:
30843 return NULL;
30844 }
30845
30846
30847 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30848 PyObject *resultobj = 0;
30849 wxWindow *arg1 = (wxWindow *) 0 ;
30850 int *arg2 = (int *) 0 ;
30851 int *arg3 = (int *) 0 ;
30852 void *argp1 = 0 ;
30853 int res1 = 0 ;
30854 int temp2 ;
30855 int res2 = SWIG_TMPOBJ ;
30856 int temp3 ;
30857 int res3 = SWIG_TMPOBJ ;
30858 PyObject *swig_obj[1] ;
30859
30860 arg2 = &temp2;
30861 arg3 = &temp3;
30862 if (!args) SWIG_fail;
30863 swig_obj[0] = args;
30864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30865 if (!SWIG_IsOK(res1)) {
30866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30867 }
30868 arg1 = reinterpret_cast< wxWindow * >(argp1);
30869 {
30870 PyThreadState* __tstate = wxPyBeginAllowThreads();
30871 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30872 wxPyEndAllowThreads(__tstate);
30873 if (PyErr_Occurred()) SWIG_fail;
30874 }
30875 resultobj = SWIG_Py_Void();
30876 if (SWIG_IsTmpObj(res2)) {
30877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30878 } else {
30879 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30881 }
30882 if (SWIG_IsTmpObj(res3)) {
30883 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30884 } else {
30885 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30886 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30887 }
30888 return resultobj;
30889 fail:
30890 return NULL;
30891 }
30892
30893
30894 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30895 PyObject *resultobj = 0;
30896 wxWindow *arg1 = (wxWindow *) 0 ;
30897 wxRect result;
30898 void *argp1 = 0 ;
30899 int res1 = 0 ;
30900 PyObject *swig_obj[1] ;
30901
30902 if (!args) SWIG_fail;
30903 swig_obj[0] = args;
30904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30905 if (!SWIG_IsOK(res1)) {
30906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30907 }
30908 arg1 = reinterpret_cast< wxWindow * >(argp1);
30909 {
30910 PyThreadState* __tstate = wxPyBeginAllowThreads();
30911 result = ((wxWindow const *)arg1)->GetScreenRect();
30912 wxPyEndAllowThreads(__tstate);
30913 if (PyErr_Occurred()) SWIG_fail;
30914 }
30915 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30916 return resultobj;
30917 fail:
30918 return NULL;
30919 }
30920
30921
30922 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30923 PyObject *resultobj = 0;
30924 wxWindow *arg1 = (wxWindow *) 0 ;
30925 wxSize result;
30926 void *argp1 = 0 ;
30927 int res1 = 0 ;
30928 PyObject *swig_obj[1] ;
30929
30930 if (!args) SWIG_fail;
30931 swig_obj[0] = args;
30932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30933 if (!SWIG_IsOK(res1)) {
30934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30935 }
30936 arg1 = reinterpret_cast< wxWindow * >(argp1);
30937 {
30938 PyThreadState* __tstate = wxPyBeginAllowThreads();
30939 result = ((wxWindow const *)arg1)->GetSize();
30940 wxPyEndAllowThreads(__tstate);
30941 if (PyErr_Occurred()) SWIG_fail;
30942 }
30943 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30944 return resultobj;
30945 fail:
30946 return NULL;
30947 }
30948
30949
30950 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30951 PyObject *resultobj = 0;
30952 wxWindow *arg1 = (wxWindow *) 0 ;
30953 int *arg2 = (int *) 0 ;
30954 int *arg3 = (int *) 0 ;
30955 void *argp1 = 0 ;
30956 int res1 = 0 ;
30957 int temp2 ;
30958 int res2 = SWIG_TMPOBJ ;
30959 int temp3 ;
30960 int res3 = SWIG_TMPOBJ ;
30961 PyObject *swig_obj[1] ;
30962
30963 arg2 = &temp2;
30964 arg3 = &temp3;
30965 if (!args) SWIG_fail;
30966 swig_obj[0] = args;
30967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30968 if (!SWIG_IsOK(res1)) {
30969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30970 }
30971 arg1 = reinterpret_cast< wxWindow * >(argp1);
30972 {
30973 PyThreadState* __tstate = wxPyBeginAllowThreads();
30974 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30975 wxPyEndAllowThreads(__tstate);
30976 if (PyErr_Occurred()) SWIG_fail;
30977 }
30978 resultobj = SWIG_Py_Void();
30979 if (SWIG_IsTmpObj(res2)) {
30980 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30981 } else {
30982 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30984 }
30985 if (SWIG_IsTmpObj(res3)) {
30986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30987 } else {
30988 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30990 }
30991 return resultobj;
30992 fail:
30993 return NULL;
30994 }
30995
30996
30997 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30998 PyObject *resultobj = 0;
30999 wxWindow *arg1 = (wxWindow *) 0 ;
31000 wxRect result;
31001 void *argp1 = 0 ;
31002 int res1 = 0 ;
31003 PyObject *swig_obj[1] ;
31004
31005 if (!args) SWIG_fail;
31006 swig_obj[0] = args;
31007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31008 if (!SWIG_IsOK(res1)) {
31009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31010 }
31011 arg1 = reinterpret_cast< wxWindow * >(argp1);
31012 {
31013 PyThreadState* __tstate = wxPyBeginAllowThreads();
31014 result = ((wxWindow const *)arg1)->GetRect();
31015 wxPyEndAllowThreads(__tstate);
31016 if (PyErr_Occurred()) SWIG_fail;
31017 }
31018 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31019 return resultobj;
31020 fail:
31021 return NULL;
31022 }
31023
31024
31025 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31026 PyObject *resultobj = 0;
31027 wxWindow *arg1 = (wxWindow *) 0 ;
31028 wxSize result;
31029 void *argp1 = 0 ;
31030 int res1 = 0 ;
31031 PyObject *swig_obj[1] ;
31032
31033 if (!args) SWIG_fail;
31034 swig_obj[0] = args;
31035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31036 if (!SWIG_IsOK(res1)) {
31037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31038 }
31039 arg1 = reinterpret_cast< wxWindow * >(argp1);
31040 {
31041 PyThreadState* __tstate = wxPyBeginAllowThreads();
31042 result = ((wxWindow const *)arg1)->GetClientSize();
31043 wxPyEndAllowThreads(__tstate);
31044 if (PyErr_Occurred()) SWIG_fail;
31045 }
31046 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31047 return resultobj;
31048 fail:
31049 return NULL;
31050 }
31051
31052
31053 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31054 PyObject *resultobj = 0;
31055 wxWindow *arg1 = (wxWindow *) 0 ;
31056 int *arg2 = (int *) 0 ;
31057 int *arg3 = (int *) 0 ;
31058 void *argp1 = 0 ;
31059 int res1 = 0 ;
31060 int temp2 ;
31061 int res2 = SWIG_TMPOBJ ;
31062 int temp3 ;
31063 int res3 = SWIG_TMPOBJ ;
31064 PyObject *swig_obj[1] ;
31065
31066 arg2 = &temp2;
31067 arg3 = &temp3;
31068 if (!args) SWIG_fail;
31069 swig_obj[0] = args;
31070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31071 if (!SWIG_IsOK(res1)) {
31072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31073 }
31074 arg1 = reinterpret_cast< wxWindow * >(argp1);
31075 {
31076 PyThreadState* __tstate = wxPyBeginAllowThreads();
31077 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31078 wxPyEndAllowThreads(__tstate);
31079 if (PyErr_Occurred()) SWIG_fail;
31080 }
31081 resultobj = SWIG_Py_Void();
31082 if (SWIG_IsTmpObj(res2)) {
31083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31084 } else {
31085 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31087 }
31088 if (SWIG_IsTmpObj(res3)) {
31089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31090 } else {
31091 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31093 }
31094 return resultobj;
31095 fail:
31096 return NULL;
31097 }
31098
31099
31100 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31101 PyObject *resultobj = 0;
31102 wxWindow *arg1 = (wxWindow *) 0 ;
31103 wxPoint result;
31104 void *argp1 = 0 ;
31105 int res1 = 0 ;
31106 PyObject *swig_obj[1] ;
31107
31108 if (!args) SWIG_fail;
31109 swig_obj[0] = args;
31110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31111 if (!SWIG_IsOK(res1)) {
31112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31113 }
31114 arg1 = reinterpret_cast< wxWindow * >(argp1);
31115 {
31116 PyThreadState* __tstate = wxPyBeginAllowThreads();
31117 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31118 wxPyEndAllowThreads(__tstate);
31119 if (PyErr_Occurred()) SWIG_fail;
31120 }
31121 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31122 return resultobj;
31123 fail:
31124 return NULL;
31125 }
31126
31127
31128 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31129 PyObject *resultobj = 0;
31130 wxWindow *arg1 = (wxWindow *) 0 ;
31131 wxRect result;
31132 void *argp1 = 0 ;
31133 int res1 = 0 ;
31134 PyObject *swig_obj[1] ;
31135
31136 if (!args) SWIG_fail;
31137 swig_obj[0] = args;
31138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31139 if (!SWIG_IsOK(res1)) {
31140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31141 }
31142 arg1 = reinterpret_cast< wxWindow * >(argp1);
31143 {
31144 PyThreadState* __tstate = wxPyBeginAllowThreads();
31145 result = ((wxWindow const *)arg1)->GetClientRect();
31146 wxPyEndAllowThreads(__tstate);
31147 if (PyErr_Occurred()) SWIG_fail;
31148 }
31149 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31150 return resultobj;
31151 fail:
31152 return NULL;
31153 }
31154
31155
31156 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31157 PyObject *resultobj = 0;
31158 wxWindow *arg1 = (wxWindow *) 0 ;
31159 wxSize result;
31160 void *argp1 = 0 ;
31161 int res1 = 0 ;
31162 PyObject *swig_obj[1] ;
31163
31164 if (!args) SWIG_fail;
31165 swig_obj[0] = args;
31166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31167 if (!SWIG_IsOK(res1)) {
31168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31169 }
31170 arg1 = reinterpret_cast< wxWindow * >(argp1);
31171 {
31172 PyThreadState* __tstate = wxPyBeginAllowThreads();
31173 result = ((wxWindow const *)arg1)->GetBestSize();
31174 wxPyEndAllowThreads(__tstate);
31175 if (PyErr_Occurred()) SWIG_fail;
31176 }
31177 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31178 return resultobj;
31179 fail:
31180 return NULL;
31181 }
31182
31183
31184 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31185 PyObject *resultobj = 0;
31186 wxWindow *arg1 = (wxWindow *) 0 ;
31187 int *arg2 = (int *) 0 ;
31188 int *arg3 = (int *) 0 ;
31189 void *argp1 = 0 ;
31190 int res1 = 0 ;
31191 int temp2 ;
31192 int res2 = SWIG_TMPOBJ ;
31193 int temp3 ;
31194 int res3 = SWIG_TMPOBJ ;
31195 PyObject *swig_obj[1] ;
31196
31197 arg2 = &temp2;
31198 arg3 = &temp3;
31199 if (!args) SWIG_fail;
31200 swig_obj[0] = args;
31201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31202 if (!SWIG_IsOK(res1)) {
31203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31204 }
31205 arg1 = reinterpret_cast< wxWindow * >(argp1);
31206 {
31207 PyThreadState* __tstate = wxPyBeginAllowThreads();
31208 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31209 wxPyEndAllowThreads(__tstate);
31210 if (PyErr_Occurred()) SWIG_fail;
31211 }
31212 resultobj = SWIG_Py_Void();
31213 if (SWIG_IsTmpObj(res2)) {
31214 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31215 } else {
31216 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31217 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31218 }
31219 if (SWIG_IsTmpObj(res3)) {
31220 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31221 } else {
31222 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31223 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31224 }
31225 return resultobj;
31226 fail:
31227 return NULL;
31228 }
31229
31230
31231 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31232 PyObject *resultobj = 0;
31233 wxWindow *arg1 = (wxWindow *) 0 ;
31234 void *argp1 = 0 ;
31235 int res1 = 0 ;
31236 PyObject *swig_obj[1] ;
31237
31238 if (!args) SWIG_fail;
31239 swig_obj[0] = args;
31240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31241 if (!SWIG_IsOK(res1)) {
31242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31243 }
31244 arg1 = reinterpret_cast< wxWindow * >(argp1);
31245 {
31246 PyThreadState* __tstate = wxPyBeginAllowThreads();
31247 (arg1)->InvalidateBestSize();
31248 wxPyEndAllowThreads(__tstate);
31249 if (PyErr_Occurred()) SWIG_fail;
31250 }
31251 resultobj = SWIG_Py_Void();
31252 return resultobj;
31253 fail:
31254 return NULL;
31255 }
31256
31257
31258 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31259 PyObject *resultobj = 0;
31260 wxWindow *arg1 = (wxWindow *) 0 ;
31261 wxSize *arg2 = 0 ;
31262 void *argp1 = 0 ;
31263 int res1 = 0 ;
31264 wxSize temp2 ;
31265 PyObject * obj0 = 0 ;
31266 PyObject * obj1 = 0 ;
31267 char * kwnames[] = {
31268 (char *) "self",(char *) "size", NULL
31269 };
31270
31271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31273 if (!SWIG_IsOK(res1)) {
31274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31275 }
31276 arg1 = reinterpret_cast< wxWindow * >(argp1);
31277 {
31278 arg2 = &temp2;
31279 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31280 }
31281 {
31282 PyThreadState* __tstate = wxPyBeginAllowThreads();
31283 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31284 wxPyEndAllowThreads(__tstate);
31285 if (PyErr_Occurred()) SWIG_fail;
31286 }
31287 resultobj = SWIG_Py_Void();
31288 return resultobj;
31289 fail:
31290 return NULL;
31291 }
31292
31293
31294 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31295 PyObject *resultobj = 0;
31296 wxWindow *arg1 = (wxWindow *) 0 ;
31297 wxSize result;
31298 void *argp1 = 0 ;
31299 int res1 = 0 ;
31300 PyObject *swig_obj[1] ;
31301
31302 if (!args) SWIG_fail;
31303 swig_obj[0] = args;
31304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31305 if (!SWIG_IsOK(res1)) {
31306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31307 }
31308 arg1 = reinterpret_cast< wxWindow * >(argp1);
31309 {
31310 PyThreadState* __tstate = wxPyBeginAllowThreads();
31311 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31312 wxPyEndAllowThreads(__tstate);
31313 if (PyErr_Occurred()) SWIG_fail;
31314 }
31315 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31316 return resultobj;
31317 fail:
31318 return NULL;
31319 }
31320
31321
31322 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31323 PyObject *resultobj = 0;
31324 wxWindow *arg1 = (wxWindow *) 0 ;
31325 wxSize result;
31326 void *argp1 = 0 ;
31327 int res1 = 0 ;
31328 PyObject *swig_obj[1] ;
31329
31330 if (!args) SWIG_fail;
31331 swig_obj[0] = args;
31332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31333 if (!SWIG_IsOK(res1)) {
31334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31335 }
31336 arg1 = reinterpret_cast< wxWindow * >(argp1);
31337 {
31338 PyThreadState* __tstate = wxPyBeginAllowThreads();
31339 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31340 wxPyEndAllowThreads(__tstate);
31341 if (PyErr_Occurred()) SWIG_fail;
31342 }
31343 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31344 return resultobj;
31345 fail:
31346 return NULL;
31347 }
31348
31349
31350 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31351 PyObject *resultobj = 0;
31352 wxWindow *arg1 = (wxWindow *) 0 ;
31353 int arg2 = (int) wxBOTH ;
31354 void *argp1 = 0 ;
31355 int res1 = 0 ;
31356 int val2 ;
31357 int ecode2 = 0 ;
31358 PyObject * obj0 = 0 ;
31359 PyObject * obj1 = 0 ;
31360 char * kwnames[] = {
31361 (char *) "self",(char *) "direction", NULL
31362 };
31363
31364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31366 if (!SWIG_IsOK(res1)) {
31367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31368 }
31369 arg1 = reinterpret_cast< wxWindow * >(argp1);
31370 if (obj1) {
31371 ecode2 = SWIG_AsVal_int(obj1, &val2);
31372 if (!SWIG_IsOK(ecode2)) {
31373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31374 }
31375 arg2 = static_cast< int >(val2);
31376 }
31377 {
31378 PyThreadState* __tstate = wxPyBeginAllowThreads();
31379 (arg1)->Center(arg2);
31380 wxPyEndAllowThreads(__tstate);
31381 if (PyErr_Occurred()) SWIG_fail;
31382 }
31383 resultobj = SWIG_Py_Void();
31384 return resultobj;
31385 fail:
31386 return NULL;
31387 }
31388
31389
31390 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31391 PyObject *resultobj = 0;
31392 wxWindow *arg1 = (wxWindow *) 0 ;
31393 int arg2 = (int) wxBOTH ;
31394 void *argp1 = 0 ;
31395 int res1 = 0 ;
31396 int val2 ;
31397 int ecode2 = 0 ;
31398 PyObject * obj0 = 0 ;
31399 PyObject * obj1 = 0 ;
31400 char * kwnames[] = {
31401 (char *) "self",(char *) "dir", NULL
31402 };
31403
31404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31406 if (!SWIG_IsOK(res1)) {
31407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31408 }
31409 arg1 = reinterpret_cast< wxWindow * >(argp1);
31410 if (obj1) {
31411 ecode2 = SWIG_AsVal_int(obj1, &val2);
31412 if (!SWIG_IsOK(ecode2)) {
31413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31414 }
31415 arg2 = static_cast< int >(val2);
31416 }
31417 {
31418 PyThreadState* __tstate = wxPyBeginAllowThreads();
31419 (arg1)->CenterOnParent(arg2);
31420 wxPyEndAllowThreads(__tstate);
31421 if (PyErr_Occurred()) SWIG_fail;
31422 }
31423 resultobj = SWIG_Py_Void();
31424 return resultobj;
31425 fail:
31426 return NULL;
31427 }
31428
31429
31430 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31431 PyObject *resultobj = 0;
31432 wxWindow *arg1 = (wxWindow *) 0 ;
31433 void *argp1 = 0 ;
31434 int res1 = 0 ;
31435 PyObject *swig_obj[1] ;
31436
31437 if (!args) SWIG_fail;
31438 swig_obj[0] = args;
31439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31440 if (!SWIG_IsOK(res1)) {
31441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31442 }
31443 arg1 = reinterpret_cast< wxWindow * >(argp1);
31444 {
31445 PyThreadState* __tstate = wxPyBeginAllowThreads();
31446 (arg1)->Fit();
31447 wxPyEndAllowThreads(__tstate);
31448 if (PyErr_Occurred()) SWIG_fail;
31449 }
31450 resultobj = SWIG_Py_Void();
31451 return resultobj;
31452 fail:
31453 return NULL;
31454 }
31455
31456
31457 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31458 PyObject *resultobj = 0;
31459 wxWindow *arg1 = (wxWindow *) 0 ;
31460 void *argp1 = 0 ;
31461 int res1 = 0 ;
31462 PyObject *swig_obj[1] ;
31463
31464 if (!args) SWIG_fail;
31465 swig_obj[0] = args;
31466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31467 if (!SWIG_IsOK(res1)) {
31468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31469 }
31470 arg1 = reinterpret_cast< wxWindow * >(argp1);
31471 {
31472 PyThreadState* __tstate = wxPyBeginAllowThreads();
31473 (arg1)->FitInside();
31474 wxPyEndAllowThreads(__tstate);
31475 if (PyErr_Occurred()) SWIG_fail;
31476 }
31477 resultobj = SWIG_Py_Void();
31478 return resultobj;
31479 fail:
31480 return NULL;
31481 }
31482
31483
31484 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31485 PyObject *resultobj = 0;
31486 wxWindow *arg1 = (wxWindow *) 0 ;
31487 int arg2 ;
31488 int arg3 ;
31489 int arg4 = (int) -1 ;
31490 int arg5 = (int) -1 ;
31491 int arg6 = (int) -1 ;
31492 int arg7 = (int) -1 ;
31493 void *argp1 = 0 ;
31494 int res1 = 0 ;
31495 int val2 ;
31496 int ecode2 = 0 ;
31497 int val3 ;
31498 int ecode3 = 0 ;
31499 int val4 ;
31500 int ecode4 = 0 ;
31501 int val5 ;
31502 int ecode5 = 0 ;
31503 int val6 ;
31504 int ecode6 = 0 ;
31505 int val7 ;
31506 int ecode7 = 0 ;
31507 PyObject * obj0 = 0 ;
31508 PyObject * obj1 = 0 ;
31509 PyObject * obj2 = 0 ;
31510 PyObject * obj3 = 0 ;
31511 PyObject * obj4 = 0 ;
31512 PyObject * obj5 = 0 ;
31513 PyObject * obj6 = 0 ;
31514 char * kwnames[] = {
31515 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31516 };
31517
31518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31520 if (!SWIG_IsOK(res1)) {
31521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31522 }
31523 arg1 = reinterpret_cast< wxWindow * >(argp1);
31524 ecode2 = SWIG_AsVal_int(obj1, &val2);
31525 if (!SWIG_IsOK(ecode2)) {
31526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31527 }
31528 arg2 = static_cast< int >(val2);
31529 ecode3 = SWIG_AsVal_int(obj2, &val3);
31530 if (!SWIG_IsOK(ecode3)) {
31531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31532 }
31533 arg3 = static_cast< int >(val3);
31534 if (obj3) {
31535 ecode4 = SWIG_AsVal_int(obj3, &val4);
31536 if (!SWIG_IsOK(ecode4)) {
31537 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31538 }
31539 arg4 = static_cast< int >(val4);
31540 }
31541 if (obj4) {
31542 ecode5 = SWIG_AsVal_int(obj4, &val5);
31543 if (!SWIG_IsOK(ecode5)) {
31544 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31545 }
31546 arg5 = static_cast< int >(val5);
31547 }
31548 if (obj5) {
31549 ecode6 = SWIG_AsVal_int(obj5, &val6);
31550 if (!SWIG_IsOK(ecode6)) {
31551 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31552 }
31553 arg6 = static_cast< int >(val6);
31554 }
31555 if (obj6) {
31556 ecode7 = SWIG_AsVal_int(obj6, &val7);
31557 if (!SWIG_IsOK(ecode7)) {
31558 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31559 }
31560 arg7 = static_cast< int >(val7);
31561 }
31562 {
31563 PyThreadState* __tstate = wxPyBeginAllowThreads();
31564 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31565 wxPyEndAllowThreads(__tstate);
31566 if (PyErr_Occurred()) SWIG_fail;
31567 }
31568 resultobj = SWIG_Py_Void();
31569 return resultobj;
31570 fail:
31571 return NULL;
31572 }
31573
31574
31575 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31576 PyObject *resultobj = 0;
31577 wxWindow *arg1 = (wxWindow *) 0 ;
31578 wxSize *arg2 = 0 ;
31579 wxSize const &arg3_defvalue = wxDefaultSize ;
31580 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31581 wxSize const &arg4_defvalue = wxDefaultSize ;
31582 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31583 void *argp1 = 0 ;
31584 int res1 = 0 ;
31585 wxSize temp2 ;
31586 wxSize temp3 ;
31587 wxSize temp4 ;
31588 PyObject * obj0 = 0 ;
31589 PyObject * obj1 = 0 ;
31590 PyObject * obj2 = 0 ;
31591 PyObject * obj3 = 0 ;
31592 char * kwnames[] = {
31593 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31594 };
31595
31596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31598 if (!SWIG_IsOK(res1)) {
31599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31600 }
31601 arg1 = reinterpret_cast< wxWindow * >(argp1);
31602 {
31603 arg2 = &temp2;
31604 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31605 }
31606 if (obj2) {
31607 {
31608 arg3 = &temp3;
31609 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31610 }
31611 }
31612 if (obj3) {
31613 {
31614 arg4 = &temp4;
31615 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31616 }
31617 }
31618 {
31619 PyThreadState* __tstate = wxPyBeginAllowThreads();
31620 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31621 wxPyEndAllowThreads(__tstate);
31622 if (PyErr_Occurred()) SWIG_fail;
31623 }
31624 resultobj = SWIG_Py_Void();
31625 return resultobj;
31626 fail:
31627 return NULL;
31628 }
31629
31630
31631 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31632 PyObject *resultobj = 0;
31633 wxWindow *arg1 = (wxWindow *) 0 ;
31634 int arg2 ;
31635 int arg3 ;
31636 int arg4 = (int) -1 ;
31637 int arg5 = (int) -1 ;
31638 void *argp1 = 0 ;
31639 int res1 = 0 ;
31640 int val2 ;
31641 int ecode2 = 0 ;
31642 int val3 ;
31643 int ecode3 = 0 ;
31644 int val4 ;
31645 int ecode4 = 0 ;
31646 int val5 ;
31647 int ecode5 = 0 ;
31648 PyObject * obj0 = 0 ;
31649 PyObject * obj1 = 0 ;
31650 PyObject * obj2 = 0 ;
31651 PyObject * obj3 = 0 ;
31652 PyObject * obj4 = 0 ;
31653 char * kwnames[] = {
31654 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31655 };
31656
31657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31659 if (!SWIG_IsOK(res1)) {
31660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31661 }
31662 arg1 = reinterpret_cast< wxWindow * >(argp1);
31663 ecode2 = SWIG_AsVal_int(obj1, &val2);
31664 if (!SWIG_IsOK(ecode2)) {
31665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31666 }
31667 arg2 = static_cast< int >(val2);
31668 ecode3 = SWIG_AsVal_int(obj2, &val3);
31669 if (!SWIG_IsOK(ecode3)) {
31670 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31671 }
31672 arg3 = static_cast< int >(val3);
31673 if (obj3) {
31674 ecode4 = SWIG_AsVal_int(obj3, &val4);
31675 if (!SWIG_IsOK(ecode4)) {
31676 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31677 }
31678 arg4 = static_cast< int >(val4);
31679 }
31680 if (obj4) {
31681 ecode5 = SWIG_AsVal_int(obj4, &val5);
31682 if (!SWIG_IsOK(ecode5)) {
31683 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31684 }
31685 arg5 = static_cast< int >(val5);
31686 }
31687 {
31688 PyThreadState* __tstate = wxPyBeginAllowThreads();
31689 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31690 wxPyEndAllowThreads(__tstate);
31691 if (PyErr_Occurred()) SWIG_fail;
31692 }
31693 resultobj = SWIG_Py_Void();
31694 return resultobj;
31695 fail:
31696 return NULL;
31697 }
31698
31699
31700 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31701 PyObject *resultobj = 0;
31702 wxWindow *arg1 = (wxWindow *) 0 ;
31703 wxSize *arg2 = 0 ;
31704 wxSize const &arg3_defvalue = wxDefaultSize ;
31705 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31706 void *argp1 = 0 ;
31707 int res1 = 0 ;
31708 wxSize temp2 ;
31709 wxSize temp3 ;
31710 PyObject * obj0 = 0 ;
31711 PyObject * obj1 = 0 ;
31712 PyObject * obj2 = 0 ;
31713 char * kwnames[] = {
31714 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31715 };
31716
31717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31719 if (!SWIG_IsOK(res1)) {
31720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31721 }
31722 arg1 = reinterpret_cast< wxWindow * >(argp1);
31723 {
31724 arg2 = &temp2;
31725 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31726 }
31727 if (obj2) {
31728 {
31729 arg3 = &temp3;
31730 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31731 }
31732 }
31733 {
31734 PyThreadState* __tstate = wxPyBeginAllowThreads();
31735 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31736 wxPyEndAllowThreads(__tstate);
31737 if (PyErr_Occurred()) SWIG_fail;
31738 }
31739 resultobj = SWIG_Py_Void();
31740 return resultobj;
31741 fail:
31742 return NULL;
31743 }
31744
31745
31746 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31747 PyObject *resultobj = 0;
31748 wxWindow *arg1 = (wxWindow *) 0 ;
31749 wxSize result;
31750 void *argp1 = 0 ;
31751 int res1 = 0 ;
31752 PyObject *swig_obj[1] ;
31753
31754 if (!args) SWIG_fail;
31755 swig_obj[0] = args;
31756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31757 if (!SWIG_IsOK(res1)) {
31758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31759 }
31760 arg1 = reinterpret_cast< wxWindow * >(argp1);
31761 {
31762 PyThreadState* __tstate = wxPyBeginAllowThreads();
31763 result = ((wxWindow const *)arg1)->GetMaxSize();
31764 wxPyEndAllowThreads(__tstate);
31765 if (PyErr_Occurred()) SWIG_fail;
31766 }
31767 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31768 return resultobj;
31769 fail:
31770 return NULL;
31771 }
31772
31773
31774 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31775 PyObject *resultobj = 0;
31776 wxWindow *arg1 = (wxWindow *) 0 ;
31777 wxSize result;
31778 void *argp1 = 0 ;
31779 int res1 = 0 ;
31780 PyObject *swig_obj[1] ;
31781
31782 if (!args) SWIG_fail;
31783 swig_obj[0] = args;
31784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31785 if (!SWIG_IsOK(res1)) {
31786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31787 }
31788 arg1 = reinterpret_cast< wxWindow * >(argp1);
31789 {
31790 PyThreadState* __tstate = wxPyBeginAllowThreads();
31791 result = ((wxWindow const *)arg1)->GetMinSize();
31792 wxPyEndAllowThreads(__tstate);
31793 if (PyErr_Occurred()) SWIG_fail;
31794 }
31795 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31796 return resultobj;
31797 fail:
31798 return NULL;
31799 }
31800
31801
31802 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31803 PyObject *resultobj = 0;
31804 wxWindow *arg1 = (wxWindow *) 0 ;
31805 wxSize *arg2 = 0 ;
31806 void *argp1 = 0 ;
31807 int res1 = 0 ;
31808 wxSize temp2 ;
31809 PyObject * obj0 = 0 ;
31810 PyObject * obj1 = 0 ;
31811 char * kwnames[] = {
31812 (char *) "self",(char *) "minSize", NULL
31813 };
31814
31815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31817 if (!SWIG_IsOK(res1)) {
31818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31819 }
31820 arg1 = reinterpret_cast< wxWindow * >(argp1);
31821 {
31822 arg2 = &temp2;
31823 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31824 }
31825 {
31826 PyThreadState* __tstate = wxPyBeginAllowThreads();
31827 (arg1)->SetMinSize((wxSize const &)*arg2);
31828 wxPyEndAllowThreads(__tstate);
31829 if (PyErr_Occurred()) SWIG_fail;
31830 }
31831 resultobj = SWIG_Py_Void();
31832 return resultobj;
31833 fail:
31834 return NULL;
31835 }
31836
31837
31838 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31839 PyObject *resultobj = 0;
31840 wxWindow *arg1 = (wxWindow *) 0 ;
31841 wxSize *arg2 = 0 ;
31842 void *argp1 = 0 ;
31843 int res1 = 0 ;
31844 wxSize temp2 ;
31845 PyObject * obj0 = 0 ;
31846 PyObject * obj1 = 0 ;
31847 char * kwnames[] = {
31848 (char *) "self",(char *) "maxSize", NULL
31849 };
31850
31851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31853 if (!SWIG_IsOK(res1)) {
31854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31855 }
31856 arg1 = reinterpret_cast< wxWindow * >(argp1);
31857 {
31858 arg2 = &temp2;
31859 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31860 }
31861 {
31862 PyThreadState* __tstate = wxPyBeginAllowThreads();
31863 (arg1)->SetMaxSize((wxSize const &)*arg2);
31864 wxPyEndAllowThreads(__tstate);
31865 if (PyErr_Occurred()) SWIG_fail;
31866 }
31867 resultobj = SWIG_Py_Void();
31868 return resultobj;
31869 fail:
31870 return NULL;
31871 }
31872
31873
31874 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31875 PyObject *resultobj = 0;
31876 wxWindow *arg1 = (wxWindow *) 0 ;
31877 int result;
31878 void *argp1 = 0 ;
31879 int res1 = 0 ;
31880 PyObject *swig_obj[1] ;
31881
31882 if (!args) SWIG_fail;
31883 swig_obj[0] = args;
31884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31885 if (!SWIG_IsOK(res1)) {
31886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31887 }
31888 arg1 = reinterpret_cast< wxWindow * >(argp1);
31889 {
31890 PyThreadState* __tstate = wxPyBeginAllowThreads();
31891 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31892 wxPyEndAllowThreads(__tstate);
31893 if (PyErr_Occurred()) SWIG_fail;
31894 }
31895 resultobj = SWIG_From_int(static_cast< int >(result));
31896 return resultobj;
31897 fail:
31898 return NULL;
31899 }
31900
31901
31902 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31903 PyObject *resultobj = 0;
31904 wxWindow *arg1 = (wxWindow *) 0 ;
31905 int result;
31906 void *argp1 = 0 ;
31907 int res1 = 0 ;
31908 PyObject *swig_obj[1] ;
31909
31910 if (!args) SWIG_fail;
31911 swig_obj[0] = args;
31912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31913 if (!SWIG_IsOK(res1)) {
31914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31915 }
31916 arg1 = reinterpret_cast< wxWindow * >(argp1);
31917 {
31918 PyThreadState* __tstate = wxPyBeginAllowThreads();
31919 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31920 wxPyEndAllowThreads(__tstate);
31921 if (PyErr_Occurred()) SWIG_fail;
31922 }
31923 resultobj = SWIG_From_int(static_cast< int >(result));
31924 return resultobj;
31925 fail:
31926 return NULL;
31927 }
31928
31929
31930 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31931 PyObject *resultobj = 0;
31932 wxWindow *arg1 = (wxWindow *) 0 ;
31933 int result;
31934 void *argp1 = 0 ;
31935 int res1 = 0 ;
31936 PyObject *swig_obj[1] ;
31937
31938 if (!args) SWIG_fail;
31939 swig_obj[0] = args;
31940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31941 if (!SWIG_IsOK(res1)) {
31942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31943 }
31944 arg1 = reinterpret_cast< wxWindow * >(argp1);
31945 {
31946 PyThreadState* __tstate = wxPyBeginAllowThreads();
31947 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31948 wxPyEndAllowThreads(__tstate);
31949 if (PyErr_Occurred()) SWIG_fail;
31950 }
31951 resultobj = SWIG_From_int(static_cast< int >(result));
31952 return resultobj;
31953 fail:
31954 return NULL;
31955 }
31956
31957
31958 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31959 PyObject *resultobj = 0;
31960 wxWindow *arg1 = (wxWindow *) 0 ;
31961 int result;
31962 void *argp1 = 0 ;
31963 int res1 = 0 ;
31964 PyObject *swig_obj[1] ;
31965
31966 if (!args) SWIG_fail;
31967 swig_obj[0] = args;
31968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31969 if (!SWIG_IsOK(res1)) {
31970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31971 }
31972 arg1 = reinterpret_cast< wxWindow * >(argp1);
31973 {
31974 PyThreadState* __tstate = wxPyBeginAllowThreads();
31975 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31976 wxPyEndAllowThreads(__tstate);
31977 if (PyErr_Occurred()) SWIG_fail;
31978 }
31979 resultobj = SWIG_From_int(static_cast< int >(result));
31980 return resultobj;
31981 fail:
31982 return NULL;
31983 }
31984
31985
31986 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31987 PyObject *resultobj = 0;
31988 wxWindow *arg1 = (wxWindow *) 0 ;
31989 wxSize *arg2 = 0 ;
31990 void *argp1 = 0 ;
31991 int res1 = 0 ;
31992 wxSize temp2 ;
31993 PyObject * obj0 = 0 ;
31994 PyObject * obj1 = 0 ;
31995 char * kwnames[] = {
31996 (char *) "self",(char *) "size", NULL
31997 };
31998
31999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32001 if (!SWIG_IsOK(res1)) {
32002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32003 }
32004 arg1 = reinterpret_cast< wxWindow * >(argp1);
32005 {
32006 arg2 = &temp2;
32007 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32008 }
32009 {
32010 PyThreadState* __tstate = wxPyBeginAllowThreads();
32011 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32012 wxPyEndAllowThreads(__tstate);
32013 if (PyErr_Occurred()) SWIG_fail;
32014 }
32015 resultobj = SWIG_Py_Void();
32016 return resultobj;
32017 fail:
32018 return NULL;
32019 }
32020
32021
32022 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32023 PyObject *resultobj = 0;
32024 wxWindow *arg1 = (wxWindow *) 0 ;
32025 int arg2 ;
32026 int arg3 ;
32027 void *argp1 = 0 ;
32028 int res1 = 0 ;
32029 int val2 ;
32030 int ecode2 = 0 ;
32031 int val3 ;
32032 int ecode3 = 0 ;
32033 PyObject * obj0 = 0 ;
32034 PyObject * obj1 = 0 ;
32035 PyObject * obj2 = 0 ;
32036 char * kwnames[] = {
32037 (char *) "self",(char *) "w",(char *) "h", NULL
32038 };
32039
32040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32042 if (!SWIG_IsOK(res1)) {
32043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32044 }
32045 arg1 = reinterpret_cast< wxWindow * >(argp1);
32046 ecode2 = SWIG_AsVal_int(obj1, &val2);
32047 if (!SWIG_IsOK(ecode2)) {
32048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32049 }
32050 arg2 = static_cast< int >(val2);
32051 ecode3 = SWIG_AsVal_int(obj2, &val3);
32052 if (!SWIG_IsOK(ecode3)) {
32053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32054 }
32055 arg3 = static_cast< int >(val3);
32056 {
32057 PyThreadState* __tstate = wxPyBeginAllowThreads();
32058 (arg1)->SetVirtualSize(arg2,arg3);
32059 wxPyEndAllowThreads(__tstate);
32060 if (PyErr_Occurred()) SWIG_fail;
32061 }
32062 resultobj = SWIG_Py_Void();
32063 return resultobj;
32064 fail:
32065 return NULL;
32066 }
32067
32068
32069 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32070 PyObject *resultobj = 0;
32071 wxWindow *arg1 = (wxWindow *) 0 ;
32072 wxSize result;
32073 void *argp1 = 0 ;
32074 int res1 = 0 ;
32075 PyObject *swig_obj[1] ;
32076
32077 if (!args) SWIG_fail;
32078 swig_obj[0] = args;
32079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32080 if (!SWIG_IsOK(res1)) {
32081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32082 }
32083 arg1 = reinterpret_cast< wxWindow * >(argp1);
32084 {
32085 PyThreadState* __tstate = wxPyBeginAllowThreads();
32086 result = ((wxWindow const *)arg1)->GetVirtualSize();
32087 wxPyEndAllowThreads(__tstate);
32088 if (PyErr_Occurred()) SWIG_fail;
32089 }
32090 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32091 return resultobj;
32092 fail:
32093 return NULL;
32094 }
32095
32096
32097 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32098 PyObject *resultobj = 0;
32099 wxWindow *arg1 = (wxWindow *) 0 ;
32100 int *arg2 = (int *) 0 ;
32101 int *arg3 = (int *) 0 ;
32102 void *argp1 = 0 ;
32103 int res1 = 0 ;
32104 int temp2 ;
32105 int res2 = SWIG_TMPOBJ ;
32106 int temp3 ;
32107 int res3 = SWIG_TMPOBJ ;
32108 PyObject *swig_obj[1] ;
32109
32110 arg2 = &temp2;
32111 arg3 = &temp3;
32112 if (!args) SWIG_fail;
32113 swig_obj[0] = args;
32114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32115 if (!SWIG_IsOK(res1)) {
32116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32117 }
32118 arg1 = reinterpret_cast< wxWindow * >(argp1);
32119 {
32120 PyThreadState* __tstate = wxPyBeginAllowThreads();
32121 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32122 wxPyEndAllowThreads(__tstate);
32123 if (PyErr_Occurred()) SWIG_fail;
32124 }
32125 resultobj = SWIG_Py_Void();
32126 if (SWIG_IsTmpObj(res2)) {
32127 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32128 } else {
32129 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32130 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32131 }
32132 if (SWIG_IsTmpObj(res3)) {
32133 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32134 } else {
32135 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32136 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32137 }
32138 return resultobj;
32139 fail:
32140 return NULL;
32141 }
32142
32143
32144 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32145 PyObject *resultobj = 0;
32146 wxWindow *arg1 = (wxWindow *) 0 ;
32147 wxSize result;
32148 void *argp1 = 0 ;
32149 int res1 = 0 ;
32150 PyObject *swig_obj[1] ;
32151
32152 if (!args) SWIG_fail;
32153 swig_obj[0] = args;
32154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32155 if (!SWIG_IsOK(res1)) {
32156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32157 }
32158 arg1 = reinterpret_cast< wxWindow * >(argp1);
32159 {
32160 PyThreadState* __tstate = wxPyBeginAllowThreads();
32161 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32162 wxPyEndAllowThreads(__tstate);
32163 if (PyErr_Occurred()) SWIG_fail;
32164 }
32165 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32166 return resultobj;
32167 fail:
32168 return NULL;
32169 }
32170
32171
32172 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32173 PyObject *resultobj = 0;
32174 wxWindow *arg1 = (wxWindow *) 0 ;
32175 bool arg2 = (bool) true ;
32176 bool result;
32177 void *argp1 = 0 ;
32178 int res1 = 0 ;
32179 bool val2 ;
32180 int ecode2 = 0 ;
32181 PyObject * obj0 = 0 ;
32182 PyObject * obj1 = 0 ;
32183 char * kwnames[] = {
32184 (char *) "self",(char *) "show", NULL
32185 };
32186
32187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32189 if (!SWIG_IsOK(res1)) {
32190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32191 }
32192 arg1 = reinterpret_cast< wxWindow * >(argp1);
32193 if (obj1) {
32194 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32195 if (!SWIG_IsOK(ecode2)) {
32196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32197 }
32198 arg2 = static_cast< bool >(val2);
32199 }
32200 {
32201 PyThreadState* __tstate = wxPyBeginAllowThreads();
32202 result = (bool)(arg1)->Show(arg2);
32203 wxPyEndAllowThreads(__tstate);
32204 if (PyErr_Occurred()) SWIG_fail;
32205 }
32206 {
32207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32208 }
32209 return resultobj;
32210 fail:
32211 return NULL;
32212 }
32213
32214
32215 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32216 PyObject *resultobj = 0;
32217 wxWindow *arg1 = (wxWindow *) 0 ;
32218 bool result;
32219 void *argp1 = 0 ;
32220 int res1 = 0 ;
32221 PyObject *swig_obj[1] ;
32222
32223 if (!args) SWIG_fail;
32224 swig_obj[0] = args;
32225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32226 if (!SWIG_IsOK(res1)) {
32227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32228 }
32229 arg1 = reinterpret_cast< wxWindow * >(argp1);
32230 {
32231 PyThreadState* __tstate = wxPyBeginAllowThreads();
32232 result = (bool)(arg1)->Hide();
32233 wxPyEndAllowThreads(__tstate);
32234 if (PyErr_Occurred()) SWIG_fail;
32235 }
32236 {
32237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32238 }
32239 return resultobj;
32240 fail:
32241 return NULL;
32242 }
32243
32244
32245 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32246 PyObject *resultobj = 0;
32247 wxWindow *arg1 = (wxWindow *) 0 ;
32248 bool arg2 = (bool) true ;
32249 bool result;
32250 void *argp1 = 0 ;
32251 int res1 = 0 ;
32252 bool val2 ;
32253 int ecode2 = 0 ;
32254 PyObject * obj0 = 0 ;
32255 PyObject * obj1 = 0 ;
32256 char * kwnames[] = {
32257 (char *) "self",(char *) "enable", NULL
32258 };
32259
32260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32262 if (!SWIG_IsOK(res1)) {
32263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32264 }
32265 arg1 = reinterpret_cast< wxWindow * >(argp1);
32266 if (obj1) {
32267 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32268 if (!SWIG_IsOK(ecode2)) {
32269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32270 }
32271 arg2 = static_cast< bool >(val2);
32272 }
32273 {
32274 PyThreadState* __tstate = wxPyBeginAllowThreads();
32275 result = (bool)(arg1)->Enable(arg2);
32276 wxPyEndAllowThreads(__tstate);
32277 if (PyErr_Occurred()) SWIG_fail;
32278 }
32279 {
32280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32281 }
32282 return resultobj;
32283 fail:
32284 return NULL;
32285 }
32286
32287
32288 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32289 PyObject *resultobj = 0;
32290 wxWindow *arg1 = (wxWindow *) 0 ;
32291 bool result;
32292 void *argp1 = 0 ;
32293 int res1 = 0 ;
32294 PyObject *swig_obj[1] ;
32295
32296 if (!args) SWIG_fail;
32297 swig_obj[0] = args;
32298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32299 if (!SWIG_IsOK(res1)) {
32300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32301 }
32302 arg1 = reinterpret_cast< wxWindow * >(argp1);
32303 {
32304 PyThreadState* __tstate = wxPyBeginAllowThreads();
32305 result = (bool)(arg1)->Disable();
32306 wxPyEndAllowThreads(__tstate);
32307 if (PyErr_Occurred()) SWIG_fail;
32308 }
32309 {
32310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32311 }
32312 return resultobj;
32313 fail:
32314 return NULL;
32315 }
32316
32317
32318 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32319 PyObject *resultobj = 0;
32320 wxWindow *arg1 = (wxWindow *) 0 ;
32321 bool result;
32322 void *argp1 = 0 ;
32323 int res1 = 0 ;
32324 PyObject *swig_obj[1] ;
32325
32326 if (!args) SWIG_fail;
32327 swig_obj[0] = args;
32328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32329 if (!SWIG_IsOK(res1)) {
32330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32331 }
32332 arg1 = reinterpret_cast< wxWindow * >(argp1);
32333 {
32334 PyThreadState* __tstate = wxPyBeginAllowThreads();
32335 result = (bool)((wxWindow const *)arg1)->IsShown();
32336 wxPyEndAllowThreads(__tstate);
32337 if (PyErr_Occurred()) SWIG_fail;
32338 }
32339 {
32340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32341 }
32342 return resultobj;
32343 fail:
32344 return NULL;
32345 }
32346
32347
32348 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32349 PyObject *resultobj = 0;
32350 wxWindow *arg1 = (wxWindow *) 0 ;
32351 bool result;
32352 void *argp1 = 0 ;
32353 int res1 = 0 ;
32354 PyObject *swig_obj[1] ;
32355
32356 if (!args) SWIG_fail;
32357 swig_obj[0] = args;
32358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32359 if (!SWIG_IsOK(res1)) {
32360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32361 }
32362 arg1 = reinterpret_cast< wxWindow * >(argp1);
32363 {
32364 PyThreadState* __tstate = wxPyBeginAllowThreads();
32365 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32366 wxPyEndAllowThreads(__tstate);
32367 if (PyErr_Occurred()) SWIG_fail;
32368 }
32369 {
32370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32371 }
32372 return resultobj;
32373 fail:
32374 return NULL;
32375 }
32376
32377
32378 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32379 PyObject *resultobj = 0;
32380 wxWindow *arg1 = (wxWindow *) 0 ;
32381 long arg2 ;
32382 void *argp1 = 0 ;
32383 int res1 = 0 ;
32384 long val2 ;
32385 int ecode2 = 0 ;
32386 PyObject * obj0 = 0 ;
32387 PyObject * obj1 = 0 ;
32388 char * kwnames[] = {
32389 (char *) "self",(char *) "style", NULL
32390 };
32391
32392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32394 if (!SWIG_IsOK(res1)) {
32395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32396 }
32397 arg1 = reinterpret_cast< wxWindow * >(argp1);
32398 ecode2 = SWIG_AsVal_long(obj1, &val2);
32399 if (!SWIG_IsOK(ecode2)) {
32400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32401 }
32402 arg2 = static_cast< long >(val2);
32403 {
32404 PyThreadState* __tstate = wxPyBeginAllowThreads();
32405 (arg1)->SetWindowStyleFlag(arg2);
32406 wxPyEndAllowThreads(__tstate);
32407 if (PyErr_Occurred()) SWIG_fail;
32408 }
32409 resultobj = SWIG_Py_Void();
32410 return resultobj;
32411 fail:
32412 return NULL;
32413 }
32414
32415
32416 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32417 PyObject *resultobj = 0;
32418 wxWindow *arg1 = (wxWindow *) 0 ;
32419 long result;
32420 void *argp1 = 0 ;
32421 int res1 = 0 ;
32422 PyObject *swig_obj[1] ;
32423
32424 if (!args) SWIG_fail;
32425 swig_obj[0] = args;
32426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32427 if (!SWIG_IsOK(res1)) {
32428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32429 }
32430 arg1 = reinterpret_cast< wxWindow * >(argp1);
32431 {
32432 PyThreadState* __tstate = wxPyBeginAllowThreads();
32433 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32434 wxPyEndAllowThreads(__tstate);
32435 if (PyErr_Occurred()) SWIG_fail;
32436 }
32437 resultobj = SWIG_From_long(static_cast< long >(result));
32438 return resultobj;
32439 fail:
32440 return NULL;
32441 }
32442
32443
32444 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32445 PyObject *resultobj = 0;
32446 wxWindow *arg1 = (wxWindow *) 0 ;
32447 int arg2 ;
32448 bool result;
32449 void *argp1 = 0 ;
32450 int res1 = 0 ;
32451 int val2 ;
32452 int ecode2 = 0 ;
32453 PyObject * obj0 = 0 ;
32454 PyObject * obj1 = 0 ;
32455 char * kwnames[] = {
32456 (char *) "self",(char *) "flag", NULL
32457 };
32458
32459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32461 if (!SWIG_IsOK(res1)) {
32462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32463 }
32464 arg1 = reinterpret_cast< wxWindow * >(argp1);
32465 ecode2 = SWIG_AsVal_int(obj1, &val2);
32466 if (!SWIG_IsOK(ecode2)) {
32467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32468 }
32469 arg2 = static_cast< int >(val2);
32470 {
32471 PyThreadState* __tstate = wxPyBeginAllowThreads();
32472 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32473 wxPyEndAllowThreads(__tstate);
32474 if (PyErr_Occurred()) SWIG_fail;
32475 }
32476 {
32477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32478 }
32479 return resultobj;
32480 fail:
32481 return NULL;
32482 }
32483
32484
32485 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32486 PyObject *resultobj = 0;
32487 wxWindow *arg1 = (wxWindow *) 0 ;
32488 bool result;
32489 void *argp1 = 0 ;
32490 int res1 = 0 ;
32491 PyObject *swig_obj[1] ;
32492
32493 if (!args) SWIG_fail;
32494 swig_obj[0] = args;
32495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32496 if (!SWIG_IsOK(res1)) {
32497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32498 }
32499 arg1 = reinterpret_cast< wxWindow * >(argp1);
32500 {
32501 PyThreadState* __tstate = wxPyBeginAllowThreads();
32502 result = (bool)((wxWindow const *)arg1)->IsRetained();
32503 wxPyEndAllowThreads(__tstate);
32504 if (PyErr_Occurred()) SWIG_fail;
32505 }
32506 {
32507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32508 }
32509 return resultobj;
32510 fail:
32511 return NULL;
32512 }
32513
32514
32515 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32516 PyObject *resultobj = 0;
32517 wxWindow *arg1 = (wxWindow *) 0 ;
32518 long arg2 ;
32519 void *argp1 = 0 ;
32520 int res1 = 0 ;
32521 long val2 ;
32522 int ecode2 = 0 ;
32523 PyObject * obj0 = 0 ;
32524 PyObject * obj1 = 0 ;
32525 char * kwnames[] = {
32526 (char *) "self",(char *) "exStyle", NULL
32527 };
32528
32529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32531 if (!SWIG_IsOK(res1)) {
32532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32533 }
32534 arg1 = reinterpret_cast< wxWindow * >(argp1);
32535 ecode2 = SWIG_AsVal_long(obj1, &val2);
32536 if (!SWIG_IsOK(ecode2)) {
32537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32538 }
32539 arg2 = static_cast< long >(val2);
32540 {
32541 PyThreadState* __tstate = wxPyBeginAllowThreads();
32542 (arg1)->SetExtraStyle(arg2);
32543 wxPyEndAllowThreads(__tstate);
32544 if (PyErr_Occurred()) SWIG_fail;
32545 }
32546 resultobj = SWIG_Py_Void();
32547 return resultobj;
32548 fail:
32549 return NULL;
32550 }
32551
32552
32553 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32554 PyObject *resultobj = 0;
32555 wxWindow *arg1 = (wxWindow *) 0 ;
32556 long result;
32557 void *argp1 = 0 ;
32558 int res1 = 0 ;
32559 PyObject *swig_obj[1] ;
32560
32561 if (!args) SWIG_fail;
32562 swig_obj[0] = args;
32563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32564 if (!SWIG_IsOK(res1)) {
32565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32566 }
32567 arg1 = reinterpret_cast< wxWindow * >(argp1);
32568 {
32569 PyThreadState* __tstate = wxPyBeginAllowThreads();
32570 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32571 wxPyEndAllowThreads(__tstate);
32572 if (PyErr_Occurred()) SWIG_fail;
32573 }
32574 resultobj = SWIG_From_long(static_cast< long >(result));
32575 return resultobj;
32576 fail:
32577 return NULL;
32578 }
32579
32580
32581 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32582 PyObject *resultobj = 0;
32583 wxWindow *arg1 = (wxWindow *) 0 ;
32584 bool arg2 = (bool) true ;
32585 void *argp1 = 0 ;
32586 int res1 = 0 ;
32587 bool val2 ;
32588 int ecode2 = 0 ;
32589 PyObject * obj0 = 0 ;
32590 PyObject * obj1 = 0 ;
32591 char * kwnames[] = {
32592 (char *) "self",(char *) "modal", NULL
32593 };
32594
32595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32597 if (!SWIG_IsOK(res1)) {
32598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32599 }
32600 arg1 = reinterpret_cast< wxWindow * >(argp1);
32601 if (obj1) {
32602 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32603 if (!SWIG_IsOK(ecode2)) {
32604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32605 }
32606 arg2 = static_cast< bool >(val2);
32607 }
32608 {
32609 PyThreadState* __tstate = wxPyBeginAllowThreads();
32610 (arg1)->MakeModal(arg2);
32611 wxPyEndAllowThreads(__tstate);
32612 if (PyErr_Occurred()) SWIG_fail;
32613 }
32614 resultobj = SWIG_Py_Void();
32615 return resultobj;
32616 fail:
32617 return NULL;
32618 }
32619
32620
32621 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32622 PyObject *resultobj = 0;
32623 wxWindow *arg1 = (wxWindow *) 0 ;
32624 bool arg2 ;
32625 void *argp1 = 0 ;
32626 int res1 = 0 ;
32627 bool val2 ;
32628 int ecode2 = 0 ;
32629 PyObject * obj0 = 0 ;
32630 PyObject * obj1 = 0 ;
32631 char * kwnames[] = {
32632 (char *) "self",(char *) "enableTheme", NULL
32633 };
32634
32635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32637 if (!SWIG_IsOK(res1)) {
32638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32639 }
32640 arg1 = reinterpret_cast< wxWindow * >(argp1);
32641 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32642 if (!SWIG_IsOK(ecode2)) {
32643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32644 }
32645 arg2 = static_cast< bool >(val2);
32646 {
32647 PyThreadState* __tstate = wxPyBeginAllowThreads();
32648 (arg1)->SetThemeEnabled(arg2);
32649 wxPyEndAllowThreads(__tstate);
32650 if (PyErr_Occurred()) SWIG_fail;
32651 }
32652 resultobj = SWIG_Py_Void();
32653 return resultobj;
32654 fail:
32655 return NULL;
32656 }
32657
32658
32659 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32660 PyObject *resultobj = 0;
32661 wxWindow *arg1 = (wxWindow *) 0 ;
32662 bool result;
32663 void *argp1 = 0 ;
32664 int res1 = 0 ;
32665 PyObject *swig_obj[1] ;
32666
32667 if (!args) SWIG_fail;
32668 swig_obj[0] = args;
32669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32670 if (!SWIG_IsOK(res1)) {
32671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32672 }
32673 arg1 = reinterpret_cast< wxWindow * >(argp1);
32674 {
32675 PyThreadState* __tstate = wxPyBeginAllowThreads();
32676 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32677 wxPyEndAllowThreads(__tstate);
32678 if (PyErr_Occurred()) SWIG_fail;
32679 }
32680 {
32681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32682 }
32683 return resultobj;
32684 fail:
32685 return NULL;
32686 }
32687
32688
32689 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32690 PyObject *resultobj = 0;
32691 wxWindow *arg1 = (wxWindow *) 0 ;
32692 void *argp1 = 0 ;
32693 int res1 = 0 ;
32694 PyObject *swig_obj[1] ;
32695
32696 if (!args) SWIG_fail;
32697 swig_obj[0] = args;
32698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32699 if (!SWIG_IsOK(res1)) {
32700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32701 }
32702 arg1 = reinterpret_cast< wxWindow * >(argp1);
32703 {
32704 PyThreadState* __tstate = wxPyBeginAllowThreads();
32705 (arg1)->SetFocus();
32706 wxPyEndAllowThreads(__tstate);
32707 if (PyErr_Occurred()) SWIG_fail;
32708 }
32709 resultobj = SWIG_Py_Void();
32710 return resultobj;
32711 fail:
32712 return NULL;
32713 }
32714
32715
32716 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32717 PyObject *resultobj = 0;
32718 wxWindow *arg1 = (wxWindow *) 0 ;
32719 void *argp1 = 0 ;
32720 int res1 = 0 ;
32721 PyObject *swig_obj[1] ;
32722
32723 if (!args) SWIG_fail;
32724 swig_obj[0] = args;
32725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32726 if (!SWIG_IsOK(res1)) {
32727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32728 }
32729 arg1 = reinterpret_cast< wxWindow * >(argp1);
32730 {
32731 PyThreadState* __tstate = wxPyBeginAllowThreads();
32732 (arg1)->SetFocusFromKbd();
32733 wxPyEndAllowThreads(__tstate);
32734 if (PyErr_Occurred()) SWIG_fail;
32735 }
32736 resultobj = SWIG_Py_Void();
32737 return resultobj;
32738 fail:
32739 return NULL;
32740 }
32741
32742
32743 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32744 PyObject *resultobj = 0;
32745 wxWindow *result = 0 ;
32746
32747 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32748 {
32749 if (!wxPyCheckForApp()) SWIG_fail;
32750 PyThreadState* __tstate = wxPyBeginAllowThreads();
32751 result = (wxWindow *)wxWindow::FindFocus();
32752 wxPyEndAllowThreads(__tstate);
32753 if (PyErr_Occurred()) SWIG_fail;
32754 }
32755 {
32756 resultobj = wxPyMake_wxObject(result, 0);
32757 }
32758 return resultobj;
32759 fail:
32760 return NULL;
32761 }
32762
32763
32764 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32765 PyObject *resultobj = 0;
32766 wxWindow *arg1 = (wxWindow *) 0 ;
32767 bool result;
32768 void *argp1 = 0 ;
32769 int res1 = 0 ;
32770 PyObject *swig_obj[1] ;
32771
32772 if (!args) SWIG_fail;
32773 swig_obj[0] = args;
32774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32775 if (!SWIG_IsOK(res1)) {
32776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32777 }
32778 arg1 = reinterpret_cast< wxWindow * >(argp1);
32779 {
32780 PyThreadState* __tstate = wxPyBeginAllowThreads();
32781 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32782 wxPyEndAllowThreads(__tstate);
32783 if (PyErr_Occurred()) SWIG_fail;
32784 }
32785 {
32786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32787 }
32788 return resultobj;
32789 fail:
32790 return NULL;
32791 }
32792
32793
32794 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32795 PyObject *resultobj = 0;
32796 wxWindow *arg1 = (wxWindow *) 0 ;
32797 bool result;
32798 void *argp1 = 0 ;
32799 int res1 = 0 ;
32800 PyObject *swig_obj[1] ;
32801
32802 if (!args) SWIG_fail;
32803 swig_obj[0] = args;
32804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32805 if (!SWIG_IsOK(res1)) {
32806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32807 }
32808 arg1 = reinterpret_cast< wxWindow * >(argp1);
32809 {
32810 PyThreadState* __tstate = wxPyBeginAllowThreads();
32811 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32812 wxPyEndAllowThreads(__tstate);
32813 if (PyErr_Occurred()) SWIG_fail;
32814 }
32815 {
32816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32817 }
32818 return resultobj;
32819 fail:
32820 return NULL;
32821 }
32822
32823
32824 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32825 PyObject *resultobj = 0;
32826 wxWindow *arg1 = (wxWindow *) 0 ;
32827 wxWindow *result = 0 ;
32828 void *argp1 = 0 ;
32829 int res1 = 0 ;
32830 PyObject *swig_obj[1] ;
32831
32832 if (!args) SWIG_fail;
32833 swig_obj[0] = args;
32834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32835 if (!SWIG_IsOK(res1)) {
32836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32837 }
32838 arg1 = reinterpret_cast< wxWindow * >(argp1);
32839 {
32840 PyThreadState* __tstate = wxPyBeginAllowThreads();
32841 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32842 wxPyEndAllowThreads(__tstate);
32843 if (PyErr_Occurred()) SWIG_fail;
32844 }
32845 {
32846 resultobj = wxPyMake_wxObject(result, 0);
32847 }
32848 return resultobj;
32849 fail:
32850 return NULL;
32851 }
32852
32853
32854 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32855 PyObject *resultobj = 0;
32856 wxWindow *arg1 = (wxWindow *) 0 ;
32857 wxWindow *arg2 = (wxWindow *) 0 ;
32858 wxWindow *result = 0 ;
32859 void *argp1 = 0 ;
32860 int res1 = 0 ;
32861 void *argp2 = 0 ;
32862 int res2 = 0 ;
32863 PyObject * obj0 = 0 ;
32864 PyObject * obj1 = 0 ;
32865 char * kwnames[] = {
32866 (char *) "self",(char *) "child", NULL
32867 };
32868
32869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32871 if (!SWIG_IsOK(res1)) {
32872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32873 }
32874 arg1 = reinterpret_cast< wxWindow * >(argp1);
32875 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32876 if (!SWIG_IsOK(res2)) {
32877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32878 }
32879 arg2 = reinterpret_cast< wxWindow * >(argp2);
32880 {
32881 PyThreadState* __tstate = wxPyBeginAllowThreads();
32882 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32883 wxPyEndAllowThreads(__tstate);
32884 if (PyErr_Occurred()) SWIG_fail;
32885 }
32886 {
32887 resultobj = wxPyMake_wxObject(result, 0);
32888 }
32889 return resultobj;
32890 fail:
32891 return NULL;
32892 }
32893
32894
32895 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32896 PyObject *resultobj = 0;
32897 wxWindow *arg1 = (wxWindow *) 0 ;
32898 wxWindow *arg2 = (wxWindow *) 0 ;
32899 void *argp1 = 0 ;
32900 int res1 = 0 ;
32901 void *argp2 = 0 ;
32902 int res2 = 0 ;
32903 PyObject * obj0 = 0 ;
32904 PyObject * obj1 = 0 ;
32905 char * kwnames[] = {
32906 (char *) "self",(char *) "win", NULL
32907 };
32908
32909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32911 if (!SWIG_IsOK(res1)) {
32912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32913 }
32914 arg1 = reinterpret_cast< wxWindow * >(argp1);
32915 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32916 if (!SWIG_IsOK(res2)) {
32917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32918 }
32919 arg2 = reinterpret_cast< wxWindow * >(argp2);
32920 {
32921 PyThreadState* __tstate = wxPyBeginAllowThreads();
32922 (arg1)->SetTmpDefaultItem(arg2);
32923 wxPyEndAllowThreads(__tstate);
32924 if (PyErr_Occurred()) SWIG_fail;
32925 }
32926 resultobj = SWIG_Py_Void();
32927 return resultobj;
32928 fail:
32929 return NULL;
32930 }
32931
32932
32933 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32934 PyObject *resultobj = 0;
32935 wxWindow *arg1 = (wxWindow *) 0 ;
32936 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32937 bool result;
32938 void *argp1 = 0 ;
32939 int res1 = 0 ;
32940 int val2 ;
32941 int ecode2 = 0 ;
32942 PyObject * obj0 = 0 ;
32943 PyObject * obj1 = 0 ;
32944 char * kwnames[] = {
32945 (char *) "self",(char *) "flags", NULL
32946 };
32947
32948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32950 if (!SWIG_IsOK(res1)) {
32951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32952 }
32953 arg1 = reinterpret_cast< wxWindow * >(argp1);
32954 if (obj1) {
32955 ecode2 = SWIG_AsVal_int(obj1, &val2);
32956 if (!SWIG_IsOK(ecode2)) {
32957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32958 }
32959 arg2 = static_cast< int >(val2);
32960 }
32961 {
32962 PyThreadState* __tstate = wxPyBeginAllowThreads();
32963 result = (bool)(arg1)->Navigate(arg2);
32964 wxPyEndAllowThreads(__tstate);
32965 if (PyErr_Occurred()) SWIG_fail;
32966 }
32967 {
32968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32969 }
32970 return resultobj;
32971 fail:
32972 return NULL;
32973 }
32974
32975
32976 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32977 PyObject *resultobj = 0;
32978 wxWindow *arg1 = (wxWindow *) 0 ;
32979 wxWindow *arg2 = (wxWindow *) 0 ;
32980 void *argp1 = 0 ;
32981 int res1 = 0 ;
32982 void *argp2 = 0 ;
32983 int res2 = 0 ;
32984 PyObject * obj0 = 0 ;
32985 PyObject * obj1 = 0 ;
32986 char * kwnames[] = {
32987 (char *) "self",(char *) "win", NULL
32988 };
32989
32990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32992 if (!SWIG_IsOK(res1)) {
32993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32994 }
32995 arg1 = reinterpret_cast< wxWindow * >(argp1);
32996 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32997 if (!SWIG_IsOK(res2)) {
32998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32999 }
33000 arg2 = reinterpret_cast< wxWindow * >(argp2);
33001 {
33002 PyThreadState* __tstate = wxPyBeginAllowThreads();
33003 (arg1)->MoveAfterInTabOrder(arg2);
33004 wxPyEndAllowThreads(__tstate);
33005 if (PyErr_Occurred()) SWIG_fail;
33006 }
33007 resultobj = SWIG_Py_Void();
33008 return resultobj;
33009 fail:
33010 return NULL;
33011 }
33012
33013
33014 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33015 PyObject *resultobj = 0;
33016 wxWindow *arg1 = (wxWindow *) 0 ;
33017 wxWindow *arg2 = (wxWindow *) 0 ;
33018 void *argp1 = 0 ;
33019 int res1 = 0 ;
33020 void *argp2 = 0 ;
33021 int res2 = 0 ;
33022 PyObject * obj0 = 0 ;
33023 PyObject * obj1 = 0 ;
33024 char * kwnames[] = {
33025 (char *) "self",(char *) "win", NULL
33026 };
33027
33028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33030 if (!SWIG_IsOK(res1)) {
33031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33032 }
33033 arg1 = reinterpret_cast< wxWindow * >(argp1);
33034 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33035 if (!SWIG_IsOK(res2)) {
33036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33037 }
33038 arg2 = reinterpret_cast< wxWindow * >(argp2);
33039 {
33040 PyThreadState* __tstate = wxPyBeginAllowThreads();
33041 (arg1)->MoveBeforeInTabOrder(arg2);
33042 wxPyEndAllowThreads(__tstate);
33043 if (PyErr_Occurred()) SWIG_fail;
33044 }
33045 resultobj = SWIG_Py_Void();
33046 return resultobj;
33047 fail:
33048 return NULL;
33049 }
33050
33051
33052 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33053 PyObject *resultobj = 0;
33054 wxWindow *arg1 = (wxWindow *) 0 ;
33055 PyObject *result = 0 ;
33056 void *argp1 = 0 ;
33057 int res1 = 0 ;
33058 PyObject *swig_obj[1] ;
33059
33060 if (!args) SWIG_fail;
33061 swig_obj[0] = args;
33062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33063 if (!SWIG_IsOK(res1)) {
33064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33065 }
33066 arg1 = reinterpret_cast< wxWindow * >(argp1);
33067 {
33068 PyThreadState* __tstate = wxPyBeginAllowThreads();
33069 result = (PyObject *)wxWindow_GetChildren(arg1);
33070 wxPyEndAllowThreads(__tstate);
33071 if (PyErr_Occurred()) SWIG_fail;
33072 }
33073 resultobj = result;
33074 return resultobj;
33075 fail:
33076 return NULL;
33077 }
33078
33079
33080 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33081 PyObject *resultobj = 0;
33082 wxWindow *arg1 = (wxWindow *) 0 ;
33083 wxWindow *result = 0 ;
33084 void *argp1 = 0 ;
33085 int res1 = 0 ;
33086 PyObject *swig_obj[1] ;
33087
33088 if (!args) SWIG_fail;
33089 swig_obj[0] = args;
33090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33091 if (!SWIG_IsOK(res1)) {
33092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33093 }
33094 arg1 = reinterpret_cast< wxWindow * >(argp1);
33095 {
33096 PyThreadState* __tstate = wxPyBeginAllowThreads();
33097 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33098 wxPyEndAllowThreads(__tstate);
33099 if (PyErr_Occurred()) SWIG_fail;
33100 }
33101 {
33102 resultobj = wxPyMake_wxObject(result, 0);
33103 }
33104 return resultobj;
33105 fail:
33106 return NULL;
33107 }
33108
33109
33110 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33111 PyObject *resultobj = 0;
33112 wxWindow *arg1 = (wxWindow *) 0 ;
33113 wxWindow *result = 0 ;
33114 void *argp1 = 0 ;
33115 int res1 = 0 ;
33116 PyObject *swig_obj[1] ;
33117
33118 if (!args) SWIG_fail;
33119 swig_obj[0] = args;
33120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33121 if (!SWIG_IsOK(res1)) {
33122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33123 }
33124 arg1 = reinterpret_cast< wxWindow * >(argp1);
33125 {
33126 PyThreadState* __tstate = wxPyBeginAllowThreads();
33127 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33128 wxPyEndAllowThreads(__tstate);
33129 if (PyErr_Occurred()) SWIG_fail;
33130 }
33131 {
33132 resultobj = wxPyMake_wxObject(result, 0);
33133 }
33134 return resultobj;
33135 fail:
33136 return NULL;
33137 }
33138
33139
33140 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33141 PyObject *resultobj = 0;
33142 wxWindow *arg1 = (wxWindow *) 0 ;
33143 bool result;
33144 void *argp1 = 0 ;
33145 int res1 = 0 ;
33146 PyObject *swig_obj[1] ;
33147
33148 if (!args) SWIG_fail;
33149 swig_obj[0] = args;
33150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33151 if (!SWIG_IsOK(res1)) {
33152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33153 }
33154 arg1 = reinterpret_cast< wxWindow * >(argp1);
33155 {
33156 PyThreadState* __tstate = wxPyBeginAllowThreads();
33157 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33158 wxPyEndAllowThreads(__tstate);
33159 if (PyErr_Occurred()) SWIG_fail;
33160 }
33161 {
33162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33163 }
33164 return resultobj;
33165 fail:
33166 return NULL;
33167 }
33168
33169
33170 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33171 PyObject *resultobj = 0;
33172 wxWindow *arg1 = (wxWindow *) 0 ;
33173 wxWindow *arg2 = (wxWindow *) 0 ;
33174 bool result;
33175 void *argp1 = 0 ;
33176 int res1 = 0 ;
33177 void *argp2 = 0 ;
33178 int res2 = 0 ;
33179 PyObject * obj0 = 0 ;
33180 PyObject * obj1 = 0 ;
33181 char * kwnames[] = {
33182 (char *) "self",(char *) "newParent", NULL
33183 };
33184
33185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33187 if (!SWIG_IsOK(res1)) {
33188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33189 }
33190 arg1 = reinterpret_cast< wxWindow * >(argp1);
33191 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33192 if (!SWIG_IsOK(res2)) {
33193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33194 }
33195 arg2 = reinterpret_cast< wxWindow * >(argp2);
33196 {
33197 PyThreadState* __tstate = wxPyBeginAllowThreads();
33198 result = (bool)(arg1)->Reparent(arg2);
33199 wxPyEndAllowThreads(__tstate);
33200 if (PyErr_Occurred()) SWIG_fail;
33201 }
33202 {
33203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33204 }
33205 return resultobj;
33206 fail:
33207 return NULL;
33208 }
33209
33210
33211 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33212 PyObject *resultobj = 0;
33213 wxWindow *arg1 = (wxWindow *) 0 ;
33214 wxWindow *arg2 = (wxWindow *) 0 ;
33215 void *argp1 = 0 ;
33216 int res1 = 0 ;
33217 void *argp2 = 0 ;
33218 int res2 = 0 ;
33219 PyObject * obj0 = 0 ;
33220 PyObject * obj1 = 0 ;
33221 char * kwnames[] = {
33222 (char *) "self",(char *) "child", NULL
33223 };
33224
33225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",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_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33229 }
33230 arg1 = reinterpret_cast< wxWindow * >(argp1);
33231 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33232 if (!SWIG_IsOK(res2)) {
33233 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33234 }
33235 arg2 = reinterpret_cast< wxWindow * >(argp2);
33236 {
33237 PyThreadState* __tstate = wxPyBeginAllowThreads();
33238 (arg1)->AddChild(arg2);
33239 wxPyEndAllowThreads(__tstate);
33240 if (PyErr_Occurred()) SWIG_fail;
33241 }
33242 resultobj = SWIG_Py_Void();
33243 return resultobj;
33244 fail:
33245 return NULL;
33246 }
33247
33248
33249 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33250 PyObject *resultobj = 0;
33251 wxWindow *arg1 = (wxWindow *) 0 ;
33252 wxWindow *arg2 = (wxWindow *) 0 ;
33253 void *argp1 = 0 ;
33254 int res1 = 0 ;
33255 void *argp2 = 0 ;
33256 int res2 = 0 ;
33257 PyObject * obj0 = 0 ;
33258 PyObject * obj1 = 0 ;
33259 char * kwnames[] = {
33260 (char *) "self",(char *) "child", NULL
33261 };
33262
33263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33265 if (!SWIG_IsOK(res1)) {
33266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33267 }
33268 arg1 = reinterpret_cast< wxWindow * >(argp1);
33269 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33270 if (!SWIG_IsOK(res2)) {
33271 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33272 }
33273 arg2 = reinterpret_cast< wxWindow * >(argp2);
33274 {
33275 PyThreadState* __tstate = wxPyBeginAllowThreads();
33276 (arg1)->RemoveChild(arg2);
33277 wxPyEndAllowThreads(__tstate);
33278 if (PyErr_Occurred()) SWIG_fail;
33279 }
33280 resultobj = SWIG_Py_Void();
33281 return resultobj;
33282 fail:
33283 return NULL;
33284 }
33285
33286
33287 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33288 PyObject *resultobj = 0;
33289 wxWindow *arg1 = (wxWindow *) 0 ;
33290 bool arg2 ;
33291 void *argp1 = 0 ;
33292 int res1 = 0 ;
33293 bool val2 ;
33294 int ecode2 = 0 ;
33295 PyObject * obj0 = 0 ;
33296 PyObject * obj1 = 0 ;
33297 char * kwnames[] = {
33298 (char *) "self",(char *) "on", NULL
33299 };
33300
33301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33303 if (!SWIG_IsOK(res1)) {
33304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33305 }
33306 arg1 = reinterpret_cast< wxWindow * >(argp1);
33307 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33308 if (!SWIG_IsOK(ecode2)) {
33309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33310 }
33311 arg2 = static_cast< bool >(val2);
33312 {
33313 PyThreadState* __tstate = wxPyBeginAllowThreads();
33314 wxWindow_SetDoubleBuffered(arg1,arg2);
33315 wxPyEndAllowThreads(__tstate);
33316 if (PyErr_Occurred()) SWIG_fail;
33317 }
33318 resultobj = SWIG_Py_Void();
33319 return resultobj;
33320 fail:
33321 return NULL;
33322 }
33323
33324
33325 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33326 PyObject *resultobj = 0;
33327 wxWindow *arg1 = (wxWindow *) 0 ;
33328 long arg2 ;
33329 wxWindow *result = 0 ;
33330 void *argp1 = 0 ;
33331 int res1 = 0 ;
33332 long val2 ;
33333 int ecode2 = 0 ;
33334 PyObject * obj0 = 0 ;
33335 PyObject * obj1 = 0 ;
33336 char * kwnames[] = {
33337 (char *) "self",(char *) "winid", NULL
33338 };
33339
33340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33342 if (!SWIG_IsOK(res1)) {
33343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33344 }
33345 arg1 = reinterpret_cast< wxWindow * >(argp1);
33346 ecode2 = SWIG_AsVal_long(obj1, &val2);
33347 if (!SWIG_IsOK(ecode2)) {
33348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33349 }
33350 arg2 = static_cast< long >(val2);
33351 {
33352 PyThreadState* __tstate = wxPyBeginAllowThreads();
33353 result = (wxWindow *)(arg1)->FindWindow(arg2);
33354 wxPyEndAllowThreads(__tstate);
33355 if (PyErr_Occurred()) SWIG_fail;
33356 }
33357 {
33358 resultobj = wxPyMake_wxObject(result, 0);
33359 }
33360 return resultobj;
33361 fail:
33362 return NULL;
33363 }
33364
33365
33366 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33367 PyObject *resultobj = 0;
33368 wxWindow *arg1 = (wxWindow *) 0 ;
33369 wxString *arg2 = 0 ;
33370 wxWindow *result = 0 ;
33371 void *argp1 = 0 ;
33372 int res1 = 0 ;
33373 bool temp2 = false ;
33374 PyObject * obj0 = 0 ;
33375 PyObject * obj1 = 0 ;
33376 char * kwnames[] = {
33377 (char *) "self",(char *) "name", NULL
33378 };
33379
33380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33382 if (!SWIG_IsOK(res1)) {
33383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33384 }
33385 arg1 = reinterpret_cast< wxWindow * >(argp1);
33386 {
33387 arg2 = wxString_in_helper(obj1);
33388 if (arg2 == NULL) SWIG_fail;
33389 temp2 = true;
33390 }
33391 {
33392 PyThreadState* __tstate = wxPyBeginAllowThreads();
33393 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33394 wxPyEndAllowThreads(__tstate);
33395 if (PyErr_Occurred()) SWIG_fail;
33396 }
33397 {
33398 resultobj = wxPyMake_wxObject(result, 0);
33399 }
33400 {
33401 if (temp2)
33402 delete arg2;
33403 }
33404 return resultobj;
33405 fail:
33406 {
33407 if (temp2)
33408 delete arg2;
33409 }
33410 return NULL;
33411 }
33412
33413
33414 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33415 PyObject *resultobj = 0;
33416 wxWindow *arg1 = (wxWindow *) 0 ;
33417 wxEvtHandler *result = 0 ;
33418 void *argp1 = 0 ;
33419 int res1 = 0 ;
33420 PyObject *swig_obj[1] ;
33421
33422 if (!args) SWIG_fail;
33423 swig_obj[0] = args;
33424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33425 if (!SWIG_IsOK(res1)) {
33426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33427 }
33428 arg1 = reinterpret_cast< wxWindow * >(argp1);
33429 {
33430 PyThreadState* __tstate = wxPyBeginAllowThreads();
33431 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33432 wxPyEndAllowThreads(__tstate);
33433 if (PyErr_Occurred()) SWIG_fail;
33434 }
33435 {
33436 resultobj = wxPyMake_wxObject(result, 0);
33437 }
33438 return resultobj;
33439 fail:
33440 return NULL;
33441 }
33442
33443
33444 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33445 PyObject *resultobj = 0;
33446 wxWindow *arg1 = (wxWindow *) 0 ;
33447 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33448 void *argp1 = 0 ;
33449 int res1 = 0 ;
33450 void *argp2 = 0 ;
33451 int res2 = 0 ;
33452 PyObject * obj0 = 0 ;
33453 PyObject * obj1 = 0 ;
33454 char * kwnames[] = {
33455 (char *) "self",(char *) "handler", NULL
33456 };
33457
33458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33460 if (!SWIG_IsOK(res1)) {
33461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33462 }
33463 arg1 = reinterpret_cast< wxWindow * >(argp1);
33464 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33465 if (!SWIG_IsOK(res2)) {
33466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33467 }
33468 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33469 {
33470 PyThreadState* __tstate = wxPyBeginAllowThreads();
33471 (arg1)->SetEventHandler(arg2);
33472 wxPyEndAllowThreads(__tstate);
33473 if (PyErr_Occurred()) SWIG_fail;
33474 }
33475 resultobj = SWIG_Py_Void();
33476 return resultobj;
33477 fail:
33478 return NULL;
33479 }
33480
33481
33482 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33483 PyObject *resultobj = 0;
33484 wxWindow *arg1 = (wxWindow *) 0 ;
33485 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33486 void *argp1 = 0 ;
33487 int res1 = 0 ;
33488 void *argp2 = 0 ;
33489 int res2 = 0 ;
33490 PyObject * obj0 = 0 ;
33491 PyObject * obj1 = 0 ;
33492 char * kwnames[] = {
33493 (char *) "self",(char *) "handler", NULL
33494 };
33495
33496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33498 if (!SWIG_IsOK(res1)) {
33499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33500 }
33501 arg1 = reinterpret_cast< wxWindow * >(argp1);
33502 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33503 if (!SWIG_IsOK(res2)) {
33504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33505 }
33506 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33507 {
33508 PyThreadState* __tstate = wxPyBeginAllowThreads();
33509 (arg1)->PushEventHandler(arg2);
33510 wxPyEndAllowThreads(__tstate);
33511 if (PyErr_Occurred()) SWIG_fail;
33512 }
33513 resultobj = SWIG_Py_Void();
33514 return resultobj;
33515 fail:
33516 return NULL;
33517 }
33518
33519
33520 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33521 PyObject *resultobj = 0;
33522 wxWindow *arg1 = (wxWindow *) 0 ;
33523 bool arg2 = (bool) false ;
33524 wxEvtHandler *result = 0 ;
33525 void *argp1 = 0 ;
33526 int res1 = 0 ;
33527 bool val2 ;
33528 int ecode2 = 0 ;
33529 PyObject * obj0 = 0 ;
33530 PyObject * obj1 = 0 ;
33531 char * kwnames[] = {
33532 (char *) "self",(char *) "deleteHandler", NULL
33533 };
33534
33535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33537 if (!SWIG_IsOK(res1)) {
33538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33539 }
33540 arg1 = reinterpret_cast< wxWindow * >(argp1);
33541 if (obj1) {
33542 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33543 if (!SWIG_IsOK(ecode2)) {
33544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33545 }
33546 arg2 = static_cast< bool >(val2);
33547 }
33548 {
33549 PyThreadState* __tstate = wxPyBeginAllowThreads();
33550 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33551 wxPyEndAllowThreads(__tstate);
33552 if (PyErr_Occurred()) SWIG_fail;
33553 }
33554 {
33555 resultobj = wxPyMake_wxObject(result, 0);
33556 }
33557 return resultobj;
33558 fail:
33559 return NULL;
33560 }
33561
33562
33563 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33564 PyObject *resultobj = 0;
33565 wxWindow *arg1 = (wxWindow *) 0 ;
33566 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33567 bool result;
33568 void *argp1 = 0 ;
33569 int res1 = 0 ;
33570 void *argp2 = 0 ;
33571 int res2 = 0 ;
33572 PyObject * obj0 = 0 ;
33573 PyObject * obj1 = 0 ;
33574 char * kwnames[] = {
33575 (char *) "self",(char *) "handler", NULL
33576 };
33577
33578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33580 if (!SWIG_IsOK(res1)) {
33581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33582 }
33583 arg1 = reinterpret_cast< wxWindow * >(argp1);
33584 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33585 if (!SWIG_IsOK(res2)) {
33586 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33587 }
33588 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33589 {
33590 PyThreadState* __tstate = wxPyBeginAllowThreads();
33591 result = (bool)(arg1)->RemoveEventHandler(arg2);
33592 wxPyEndAllowThreads(__tstate);
33593 if (PyErr_Occurred()) SWIG_fail;
33594 }
33595 {
33596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33597 }
33598 return resultobj;
33599 fail:
33600 return NULL;
33601 }
33602
33603
33604 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33605 PyObject *resultobj = 0;
33606 wxWindow *arg1 = (wxWindow *) 0 ;
33607 wxValidator *arg2 = 0 ;
33608 void *argp1 = 0 ;
33609 int res1 = 0 ;
33610 void *argp2 = 0 ;
33611 int res2 = 0 ;
33612 PyObject * obj0 = 0 ;
33613 PyObject * obj1 = 0 ;
33614 char * kwnames[] = {
33615 (char *) "self",(char *) "validator", NULL
33616 };
33617
33618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33620 if (!SWIG_IsOK(res1)) {
33621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33622 }
33623 arg1 = reinterpret_cast< wxWindow * >(argp1);
33624 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33625 if (!SWIG_IsOK(res2)) {
33626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33627 }
33628 if (!argp2) {
33629 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33630 }
33631 arg2 = reinterpret_cast< wxValidator * >(argp2);
33632 {
33633 PyThreadState* __tstate = wxPyBeginAllowThreads();
33634 (arg1)->SetValidator((wxValidator const &)*arg2);
33635 wxPyEndAllowThreads(__tstate);
33636 if (PyErr_Occurred()) SWIG_fail;
33637 }
33638 resultobj = SWIG_Py_Void();
33639 return resultobj;
33640 fail:
33641 return NULL;
33642 }
33643
33644
33645 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33646 PyObject *resultobj = 0;
33647 wxWindow *arg1 = (wxWindow *) 0 ;
33648 wxValidator *result = 0 ;
33649 void *argp1 = 0 ;
33650 int res1 = 0 ;
33651 PyObject *swig_obj[1] ;
33652
33653 if (!args) SWIG_fail;
33654 swig_obj[0] = args;
33655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33656 if (!SWIG_IsOK(res1)) {
33657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33658 }
33659 arg1 = reinterpret_cast< wxWindow * >(argp1);
33660 {
33661 PyThreadState* __tstate = wxPyBeginAllowThreads();
33662 result = (wxValidator *)(arg1)->GetValidator();
33663 wxPyEndAllowThreads(__tstate);
33664 if (PyErr_Occurred()) SWIG_fail;
33665 }
33666 {
33667 resultobj = wxPyMake_wxObject(result, (bool)0);
33668 }
33669 return resultobj;
33670 fail:
33671 return NULL;
33672 }
33673
33674
33675 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33676 PyObject *resultobj = 0;
33677 wxWindow *arg1 = (wxWindow *) 0 ;
33678 bool result;
33679 void *argp1 = 0 ;
33680 int res1 = 0 ;
33681 PyObject *swig_obj[1] ;
33682
33683 if (!args) SWIG_fail;
33684 swig_obj[0] = args;
33685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33686 if (!SWIG_IsOK(res1)) {
33687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33688 }
33689 arg1 = reinterpret_cast< wxWindow * >(argp1);
33690 {
33691 PyThreadState* __tstate = wxPyBeginAllowThreads();
33692 result = (bool)(arg1)->Validate();
33693 wxPyEndAllowThreads(__tstate);
33694 if (PyErr_Occurred()) SWIG_fail;
33695 }
33696 {
33697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33698 }
33699 return resultobj;
33700 fail:
33701 return NULL;
33702 }
33703
33704
33705 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33706 PyObject *resultobj = 0;
33707 wxWindow *arg1 = (wxWindow *) 0 ;
33708 bool result;
33709 void *argp1 = 0 ;
33710 int res1 = 0 ;
33711 PyObject *swig_obj[1] ;
33712
33713 if (!args) SWIG_fail;
33714 swig_obj[0] = args;
33715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33716 if (!SWIG_IsOK(res1)) {
33717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33718 }
33719 arg1 = reinterpret_cast< wxWindow * >(argp1);
33720 {
33721 PyThreadState* __tstate = wxPyBeginAllowThreads();
33722 result = (bool)(arg1)->TransferDataToWindow();
33723 wxPyEndAllowThreads(__tstate);
33724 if (PyErr_Occurred()) SWIG_fail;
33725 }
33726 {
33727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33728 }
33729 return resultobj;
33730 fail:
33731 return NULL;
33732 }
33733
33734
33735 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33736 PyObject *resultobj = 0;
33737 wxWindow *arg1 = (wxWindow *) 0 ;
33738 bool result;
33739 void *argp1 = 0 ;
33740 int res1 = 0 ;
33741 PyObject *swig_obj[1] ;
33742
33743 if (!args) SWIG_fail;
33744 swig_obj[0] = args;
33745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33746 if (!SWIG_IsOK(res1)) {
33747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33748 }
33749 arg1 = reinterpret_cast< wxWindow * >(argp1);
33750 {
33751 PyThreadState* __tstate = wxPyBeginAllowThreads();
33752 result = (bool)(arg1)->TransferDataFromWindow();
33753 wxPyEndAllowThreads(__tstate);
33754 if (PyErr_Occurred()) SWIG_fail;
33755 }
33756 {
33757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33758 }
33759 return resultobj;
33760 fail:
33761 return NULL;
33762 }
33763
33764
33765 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33766 PyObject *resultobj = 0;
33767 wxWindow *arg1 = (wxWindow *) 0 ;
33768 void *argp1 = 0 ;
33769 int res1 = 0 ;
33770 PyObject *swig_obj[1] ;
33771
33772 if (!args) SWIG_fail;
33773 swig_obj[0] = args;
33774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33775 if (!SWIG_IsOK(res1)) {
33776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33777 }
33778 arg1 = reinterpret_cast< wxWindow * >(argp1);
33779 {
33780 PyThreadState* __tstate = wxPyBeginAllowThreads();
33781 (arg1)->InitDialog();
33782 wxPyEndAllowThreads(__tstate);
33783 if (PyErr_Occurred()) SWIG_fail;
33784 }
33785 resultobj = SWIG_Py_Void();
33786 return resultobj;
33787 fail:
33788 return NULL;
33789 }
33790
33791
33792 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33793 PyObject *resultobj = 0;
33794 wxWindow *arg1 = (wxWindow *) 0 ;
33795 wxAcceleratorTable *arg2 = 0 ;
33796 void *argp1 = 0 ;
33797 int res1 = 0 ;
33798 void *argp2 = 0 ;
33799 int res2 = 0 ;
33800 PyObject * obj0 = 0 ;
33801 PyObject * obj1 = 0 ;
33802 char * kwnames[] = {
33803 (char *) "self",(char *) "accel", NULL
33804 };
33805
33806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33808 if (!SWIG_IsOK(res1)) {
33809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33810 }
33811 arg1 = reinterpret_cast< wxWindow * >(argp1);
33812 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33813 if (!SWIG_IsOK(res2)) {
33814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33815 }
33816 if (!argp2) {
33817 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33818 }
33819 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33820 {
33821 PyThreadState* __tstate = wxPyBeginAllowThreads();
33822 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33823 wxPyEndAllowThreads(__tstate);
33824 if (PyErr_Occurred()) SWIG_fail;
33825 }
33826 resultobj = SWIG_Py_Void();
33827 return resultobj;
33828 fail:
33829 return NULL;
33830 }
33831
33832
33833 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33834 PyObject *resultobj = 0;
33835 wxWindow *arg1 = (wxWindow *) 0 ;
33836 wxAcceleratorTable *result = 0 ;
33837 void *argp1 = 0 ;
33838 int res1 = 0 ;
33839 PyObject *swig_obj[1] ;
33840
33841 if (!args) SWIG_fail;
33842 swig_obj[0] = args;
33843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33844 if (!SWIG_IsOK(res1)) {
33845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33846 }
33847 arg1 = reinterpret_cast< wxWindow * >(argp1);
33848 {
33849 PyThreadState* __tstate = wxPyBeginAllowThreads();
33850 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33851 wxPyEndAllowThreads(__tstate);
33852 if (PyErr_Occurred()) SWIG_fail;
33853 }
33854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33855 return resultobj;
33856 fail:
33857 return NULL;
33858 }
33859
33860
33861 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33862 PyObject *resultobj = 0;
33863 wxWindow *arg1 = (wxWindow *) 0 ;
33864 int arg2 ;
33865 int arg3 ;
33866 int arg4 ;
33867 bool result;
33868 void *argp1 = 0 ;
33869 int res1 = 0 ;
33870 int val2 ;
33871 int ecode2 = 0 ;
33872 int val3 ;
33873 int ecode3 = 0 ;
33874 int val4 ;
33875 int ecode4 = 0 ;
33876 PyObject * obj0 = 0 ;
33877 PyObject * obj1 = 0 ;
33878 PyObject * obj2 = 0 ;
33879 PyObject * obj3 = 0 ;
33880 char * kwnames[] = {
33881 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33882 };
33883
33884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33886 if (!SWIG_IsOK(res1)) {
33887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33888 }
33889 arg1 = reinterpret_cast< wxWindow * >(argp1);
33890 ecode2 = SWIG_AsVal_int(obj1, &val2);
33891 if (!SWIG_IsOK(ecode2)) {
33892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33893 }
33894 arg2 = static_cast< int >(val2);
33895 ecode3 = SWIG_AsVal_int(obj2, &val3);
33896 if (!SWIG_IsOK(ecode3)) {
33897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33898 }
33899 arg3 = static_cast< int >(val3);
33900 ecode4 = SWIG_AsVal_int(obj3, &val4);
33901 if (!SWIG_IsOK(ecode4)) {
33902 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33903 }
33904 arg4 = static_cast< int >(val4);
33905 {
33906 PyThreadState* __tstate = wxPyBeginAllowThreads();
33907 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33908 wxPyEndAllowThreads(__tstate);
33909 if (PyErr_Occurred()) SWIG_fail;
33910 }
33911 {
33912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33913 }
33914 return resultobj;
33915 fail:
33916 return NULL;
33917 }
33918
33919
33920 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33921 PyObject *resultobj = 0;
33922 wxWindow *arg1 = (wxWindow *) 0 ;
33923 int arg2 ;
33924 bool result;
33925 void *argp1 = 0 ;
33926 int res1 = 0 ;
33927 int val2 ;
33928 int ecode2 = 0 ;
33929 PyObject * obj0 = 0 ;
33930 PyObject * obj1 = 0 ;
33931 char * kwnames[] = {
33932 (char *) "self",(char *) "hotkeyId", NULL
33933 };
33934
33935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33937 if (!SWIG_IsOK(res1)) {
33938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33939 }
33940 arg1 = reinterpret_cast< wxWindow * >(argp1);
33941 ecode2 = SWIG_AsVal_int(obj1, &val2);
33942 if (!SWIG_IsOK(ecode2)) {
33943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33944 }
33945 arg2 = static_cast< int >(val2);
33946 {
33947 PyThreadState* __tstate = wxPyBeginAllowThreads();
33948 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33949 wxPyEndAllowThreads(__tstate);
33950 if (PyErr_Occurred()) SWIG_fail;
33951 }
33952 {
33953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33954 }
33955 return resultobj;
33956 fail:
33957 return NULL;
33958 }
33959
33960
33961 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33962 PyObject *resultobj = 0;
33963 wxWindow *arg1 = (wxWindow *) 0 ;
33964 wxPoint *arg2 = 0 ;
33965 wxPoint result;
33966 void *argp1 = 0 ;
33967 int res1 = 0 ;
33968 wxPoint temp2 ;
33969 PyObject * obj0 = 0 ;
33970 PyObject * obj1 = 0 ;
33971 char * kwnames[] = {
33972 (char *) "self",(char *) "pt", NULL
33973 };
33974
33975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33977 if (!SWIG_IsOK(res1)) {
33978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33979 }
33980 arg1 = reinterpret_cast< wxWindow * >(argp1);
33981 {
33982 arg2 = &temp2;
33983 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33984 }
33985 {
33986 PyThreadState* __tstate = wxPyBeginAllowThreads();
33987 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33988 wxPyEndAllowThreads(__tstate);
33989 if (PyErr_Occurred()) SWIG_fail;
33990 }
33991 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33992 return resultobj;
33993 fail:
33994 return NULL;
33995 }
33996
33997
33998 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33999 PyObject *resultobj = 0;
34000 wxWindow *arg1 = (wxWindow *) 0 ;
34001 wxSize *arg2 = 0 ;
34002 wxSize result;
34003 void *argp1 = 0 ;
34004 int res1 = 0 ;
34005 wxSize temp2 ;
34006 PyObject * obj0 = 0 ;
34007 PyObject * obj1 = 0 ;
34008 char * kwnames[] = {
34009 (char *) "self",(char *) "sz", NULL
34010 };
34011
34012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34014 if (!SWIG_IsOK(res1)) {
34015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34016 }
34017 arg1 = reinterpret_cast< wxWindow * >(argp1);
34018 {
34019 arg2 = &temp2;
34020 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34021 }
34022 {
34023 PyThreadState* __tstate = wxPyBeginAllowThreads();
34024 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34025 wxPyEndAllowThreads(__tstate);
34026 if (PyErr_Occurred()) SWIG_fail;
34027 }
34028 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34029 return resultobj;
34030 fail:
34031 return NULL;
34032 }
34033
34034
34035 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34036 PyObject *resultobj = 0;
34037 wxWindow *arg1 = (wxWindow *) 0 ;
34038 wxPoint *arg2 = 0 ;
34039 wxPoint result;
34040 void *argp1 = 0 ;
34041 int res1 = 0 ;
34042 wxPoint temp2 ;
34043 PyObject * obj0 = 0 ;
34044 PyObject * obj1 = 0 ;
34045 char * kwnames[] = {
34046 (char *) "self",(char *) "pt", NULL
34047 };
34048
34049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34051 if (!SWIG_IsOK(res1)) {
34052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34053 }
34054 arg1 = reinterpret_cast< wxWindow * >(argp1);
34055 {
34056 arg2 = &temp2;
34057 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34058 }
34059 {
34060 PyThreadState* __tstate = wxPyBeginAllowThreads();
34061 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34062 wxPyEndAllowThreads(__tstate);
34063 if (PyErr_Occurred()) SWIG_fail;
34064 }
34065 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34066 return resultobj;
34067 fail:
34068 return NULL;
34069 }
34070
34071
34072 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34073 PyObject *resultobj = 0;
34074 wxWindow *arg1 = (wxWindow *) 0 ;
34075 wxSize *arg2 = 0 ;
34076 wxSize result;
34077 void *argp1 = 0 ;
34078 int res1 = 0 ;
34079 wxSize temp2 ;
34080 PyObject * obj0 = 0 ;
34081 PyObject * obj1 = 0 ;
34082 char * kwnames[] = {
34083 (char *) "self",(char *) "sz", NULL
34084 };
34085
34086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34088 if (!SWIG_IsOK(res1)) {
34089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34090 }
34091 arg1 = reinterpret_cast< wxWindow * >(argp1);
34092 {
34093 arg2 = &temp2;
34094 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34095 }
34096 {
34097 PyThreadState* __tstate = wxPyBeginAllowThreads();
34098 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34099 wxPyEndAllowThreads(__tstate);
34100 if (PyErr_Occurred()) SWIG_fail;
34101 }
34102 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34103 return resultobj;
34104 fail:
34105 return NULL;
34106 }
34107
34108
34109 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34110 PyObject *resultobj = 0;
34111 wxWindow *arg1 = (wxWindow *) 0 ;
34112 wxPoint *arg2 = 0 ;
34113 wxPoint result;
34114 void *argp1 = 0 ;
34115 int res1 = 0 ;
34116 wxPoint temp2 ;
34117 PyObject * obj0 = 0 ;
34118 PyObject * obj1 = 0 ;
34119 char * kwnames[] = {
34120 (char *) "self",(char *) "pt", NULL
34121 };
34122
34123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34125 if (!SWIG_IsOK(res1)) {
34126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34127 }
34128 arg1 = reinterpret_cast< wxWindow * >(argp1);
34129 {
34130 arg2 = &temp2;
34131 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34132 }
34133 {
34134 PyThreadState* __tstate = wxPyBeginAllowThreads();
34135 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34136 wxPyEndAllowThreads(__tstate);
34137 if (PyErr_Occurred()) SWIG_fail;
34138 }
34139 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34140 return resultobj;
34141 fail:
34142 return NULL;
34143 }
34144
34145
34146 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34147 PyObject *resultobj = 0;
34148 wxWindow *arg1 = (wxWindow *) 0 ;
34149 wxSize *arg2 = 0 ;
34150 wxSize result;
34151 void *argp1 = 0 ;
34152 int res1 = 0 ;
34153 wxSize temp2 ;
34154 PyObject * obj0 = 0 ;
34155 PyObject * obj1 = 0 ;
34156 char * kwnames[] = {
34157 (char *) "self",(char *) "sz", NULL
34158 };
34159
34160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34162 if (!SWIG_IsOK(res1)) {
34163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34164 }
34165 arg1 = reinterpret_cast< wxWindow * >(argp1);
34166 {
34167 arg2 = &temp2;
34168 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34169 }
34170 {
34171 PyThreadState* __tstate = wxPyBeginAllowThreads();
34172 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34173 wxPyEndAllowThreads(__tstate);
34174 if (PyErr_Occurred()) SWIG_fail;
34175 }
34176 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34177 return resultobj;
34178 fail:
34179 return NULL;
34180 }
34181
34182
34183 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34184 PyObject *resultobj = 0;
34185 wxWindow *arg1 = (wxWindow *) 0 ;
34186 int arg2 ;
34187 int arg3 ;
34188 void *argp1 = 0 ;
34189 int res1 = 0 ;
34190 int val2 ;
34191 int ecode2 = 0 ;
34192 int val3 ;
34193 int ecode3 = 0 ;
34194 PyObject * obj0 = 0 ;
34195 PyObject * obj1 = 0 ;
34196 PyObject * obj2 = 0 ;
34197 char * kwnames[] = {
34198 (char *) "self",(char *) "x",(char *) "y", NULL
34199 };
34200
34201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34203 if (!SWIG_IsOK(res1)) {
34204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34205 }
34206 arg1 = reinterpret_cast< wxWindow * >(argp1);
34207 ecode2 = SWIG_AsVal_int(obj1, &val2);
34208 if (!SWIG_IsOK(ecode2)) {
34209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34210 }
34211 arg2 = static_cast< int >(val2);
34212 ecode3 = SWIG_AsVal_int(obj2, &val3);
34213 if (!SWIG_IsOK(ecode3)) {
34214 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34215 }
34216 arg3 = static_cast< int >(val3);
34217 {
34218 PyThreadState* __tstate = wxPyBeginAllowThreads();
34219 (arg1)->WarpPointer(arg2,arg3);
34220 wxPyEndAllowThreads(__tstate);
34221 if (PyErr_Occurred()) SWIG_fail;
34222 }
34223 resultobj = SWIG_Py_Void();
34224 return resultobj;
34225 fail:
34226 return NULL;
34227 }
34228
34229
34230 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34231 PyObject *resultobj = 0;
34232 wxWindow *arg1 = (wxWindow *) 0 ;
34233 void *argp1 = 0 ;
34234 int res1 = 0 ;
34235 PyObject *swig_obj[1] ;
34236
34237 if (!args) SWIG_fail;
34238 swig_obj[0] = args;
34239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34240 if (!SWIG_IsOK(res1)) {
34241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34242 }
34243 arg1 = reinterpret_cast< wxWindow * >(argp1);
34244 {
34245 PyThreadState* __tstate = wxPyBeginAllowThreads();
34246 (arg1)->CaptureMouse();
34247 wxPyEndAllowThreads(__tstate);
34248 if (PyErr_Occurred()) SWIG_fail;
34249 }
34250 resultobj = SWIG_Py_Void();
34251 return resultobj;
34252 fail:
34253 return NULL;
34254 }
34255
34256
34257 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34258 PyObject *resultobj = 0;
34259 wxWindow *arg1 = (wxWindow *) 0 ;
34260 void *argp1 = 0 ;
34261 int res1 = 0 ;
34262 PyObject *swig_obj[1] ;
34263
34264 if (!args) SWIG_fail;
34265 swig_obj[0] = args;
34266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34267 if (!SWIG_IsOK(res1)) {
34268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34269 }
34270 arg1 = reinterpret_cast< wxWindow * >(argp1);
34271 {
34272 PyThreadState* __tstate = wxPyBeginAllowThreads();
34273 (arg1)->ReleaseMouse();
34274 wxPyEndAllowThreads(__tstate);
34275 if (PyErr_Occurred()) SWIG_fail;
34276 }
34277 resultobj = SWIG_Py_Void();
34278 return resultobj;
34279 fail:
34280 return NULL;
34281 }
34282
34283
34284 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34285 PyObject *resultobj = 0;
34286 wxWindow *result = 0 ;
34287
34288 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34289 {
34290 if (!wxPyCheckForApp()) SWIG_fail;
34291 PyThreadState* __tstate = wxPyBeginAllowThreads();
34292 result = (wxWindow *)wxWindow::GetCapture();
34293 wxPyEndAllowThreads(__tstate);
34294 if (PyErr_Occurred()) SWIG_fail;
34295 }
34296 {
34297 resultobj = wxPyMake_wxObject(result, 0);
34298 }
34299 return resultobj;
34300 fail:
34301 return NULL;
34302 }
34303
34304
34305 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34306 PyObject *resultobj = 0;
34307 wxWindow *arg1 = (wxWindow *) 0 ;
34308 bool result;
34309 void *argp1 = 0 ;
34310 int res1 = 0 ;
34311 PyObject *swig_obj[1] ;
34312
34313 if (!args) SWIG_fail;
34314 swig_obj[0] = args;
34315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34316 if (!SWIG_IsOK(res1)) {
34317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34318 }
34319 arg1 = reinterpret_cast< wxWindow * >(argp1);
34320 {
34321 PyThreadState* __tstate = wxPyBeginAllowThreads();
34322 result = (bool)((wxWindow const *)arg1)->HasCapture();
34323 wxPyEndAllowThreads(__tstate);
34324 if (PyErr_Occurred()) SWIG_fail;
34325 }
34326 {
34327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34328 }
34329 return resultobj;
34330 fail:
34331 return NULL;
34332 }
34333
34334
34335 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34336 PyObject *resultobj = 0;
34337 wxWindow *arg1 = (wxWindow *) 0 ;
34338 bool arg2 = (bool) true ;
34339 wxRect *arg3 = (wxRect *) NULL ;
34340 void *argp1 = 0 ;
34341 int res1 = 0 ;
34342 bool val2 ;
34343 int ecode2 = 0 ;
34344 void *argp3 = 0 ;
34345 int res3 = 0 ;
34346 PyObject * obj0 = 0 ;
34347 PyObject * obj1 = 0 ;
34348 PyObject * obj2 = 0 ;
34349 char * kwnames[] = {
34350 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34351 };
34352
34353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34355 if (!SWIG_IsOK(res1)) {
34356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34357 }
34358 arg1 = reinterpret_cast< wxWindow * >(argp1);
34359 if (obj1) {
34360 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34361 if (!SWIG_IsOK(ecode2)) {
34362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34363 }
34364 arg2 = static_cast< bool >(val2);
34365 }
34366 if (obj2) {
34367 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34368 if (!SWIG_IsOK(res3)) {
34369 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34370 }
34371 arg3 = reinterpret_cast< wxRect * >(argp3);
34372 }
34373 {
34374 PyThreadState* __tstate = wxPyBeginAllowThreads();
34375 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34376 wxPyEndAllowThreads(__tstate);
34377 if (PyErr_Occurred()) SWIG_fail;
34378 }
34379 resultobj = SWIG_Py_Void();
34380 return resultobj;
34381 fail:
34382 return NULL;
34383 }
34384
34385
34386 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34387 PyObject *resultobj = 0;
34388 wxWindow *arg1 = (wxWindow *) 0 ;
34389 wxRect *arg2 = 0 ;
34390 bool arg3 = (bool) true ;
34391 void *argp1 = 0 ;
34392 int res1 = 0 ;
34393 wxRect temp2 ;
34394 bool val3 ;
34395 int ecode3 = 0 ;
34396 PyObject * obj0 = 0 ;
34397 PyObject * obj1 = 0 ;
34398 PyObject * obj2 = 0 ;
34399 char * kwnames[] = {
34400 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34401 };
34402
34403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34405 if (!SWIG_IsOK(res1)) {
34406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34407 }
34408 arg1 = reinterpret_cast< wxWindow * >(argp1);
34409 {
34410 arg2 = &temp2;
34411 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34412 }
34413 if (obj2) {
34414 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34415 if (!SWIG_IsOK(ecode3)) {
34416 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34417 }
34418 arg3 = static_cast< bool >(val3);
34419 }
34420 {
34421 PyThreadState* __tstate = wxPyBeginAllowThreads();
34422 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34423 wxPyEndAllowThreads(__tstate);
34424 if (PyErr_Occurred()) SWIG_fail;
34425 }
34426 resultobj = SWIG_Py_Void();
34427 return resultobj;
34428 fail:
34429 return NULL;
34430 }
34431
34432
34433 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34434 PyObject *resultobj = 0;
34435 wxWindow *arg1 = (wxWindow *) 0 ;
34436 void *argp1 = 0 ;
34437 int res1 = 0 ;
34438 PyObject *swig_obj[1] ;
34439
34440 if (!args) SWIG_fail;
34441 swig_obj[0] = args;
34442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34443 if (!SWIG_IsOK(res1)) {
34444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34445 }
34446 arg1 = reinterpret_cast< wxWindow * >(argp1);
34447 {
34448 PyThreadState* __tstate = wxPyBeginAllowThreads();
34449 (arg1)->Update();
34450 wxPyEndAllowThreads(__tstate);
34451 if (PyErr_Occurred()) SWIG_fail;
34452 }
34453 resultobj = SWIG_Py_Void();
34454 return resultobj;
34455 fail:
34456 return NULL;
34457 }
34458
34459
34460 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34461 PyObject *resultobj = 0;
34462 wxWindow *arg1 = (wxWindow *) 0 ;
34463 void *argp1 = 0 ;
34464 int res1 = 0 ;
34465 PyObject *swig_obj[1] ;
34466
34467 if (!args) SWIG_fail;
34468 swig_obj[0] = args;
34469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34470 if (!SWIG_IsOK(res1)) {
34471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34472 }
34473 arg1 = reinterpret_cast< wxWindow * >(argp1);
34474 {
34475 PyThreadState* __tstate = wxPyBeginAllowThreads();
34476 (arg1)->ClearBackground();
34477 wxPyEndAllowThreads(__tstate);
34478 if (PyErr_Occurred()) SWIG_fail;
34479 }
34480 resultobj = SWIG_Py_Void();
34481 return resultobj;
34482 fail:
34483 return NULL;
34484 }
34485
34486
34487 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34488 PyObject *resultobj = 0;
34489 wxWindow *arg1 = (wxWindow *) 0 ;
34490 void *argp1 = 0 ;
34491 int res1 = 0 ;
34492 PyObject *swig_obj[1] ;
34493
34494 if (!args) SWIG_fail;
34495 swig_obj[0] = args;
34496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34497 if (!SWIG_IsOK(res1)) {
34498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34499 }
34500 arg1 = reinterpret_cast< wxWindow * >(argp1);
34501 {
34502 PyThreadState* __tstate = wxPyBeginAllowThreads();
34503 (arg1)->Freeze();
34504 wxPyEndAllowThreads(__tstate);
34505 if (PyErr_Occurred()) SWIG_fail;
34506 }
34507 resultobj = SWIG_Py_Void();
34508 return resultobj;
34509 fail:
34510 return NULL;
34511 }
34512
34513
34514 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34515 PyObject *resultobj = 0;
34516 wxWindow *arg1 = (wxWindow *) 0 ;
34517 void *argp1 = 0 ;
34518 int res1 = 0 ;
34519 PyObject *swig_obj[1] ;
34520
34521 if (!args) SWIG_fail;
34522 swig_obj[0] = args;
34523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34524 if (!SWIG_IsOK(res1)) {
34525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34526 }
34527 arg1 = reinterpret_cast< wxWindow * >(argp1);
34528 {
34529 PyThreadState* __tstate = wxPyBeginAllowThreads();
34530 (arg1)->Thaw();
34531 wxPyEndAllowThreads(__tstate);
34532 if (PyErr_Occurred()) SWIG_fail;
34533 }
34534 resultobj = SWIG_Py_Void();
34535 return resultobj;
34536 fail:
34537 return NULL;
34538 }
34539
34540
34541 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34542 PyObject *resultobj = 0;
34543 wxWindow *arg1 = (wxWindow *) 0 ;
34544 wxDC *arg2 = 0 ;
34545 void *argp1 = 0 ;
34546 int res1 = 0 ;
34547 void *argp2 = 0 ;
34548 int res2 = 0 ;
34549 PyObject * obj0 = 0 ;
34550 PyObject * obj1 = 0 ;
34551 char * kwnames[] = {
34552 (char *) "self",(char *) "dc", NULL
34553 };
34554
34555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34557 if (!SWIG_IsOK(res1)) {
34558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34559 }
34560 arg1 = reinterpret_cast< wxWindow * >(argp1);
34561 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34562 if (!SWIG_IsOK(res2)) {
34563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34564 }
34565 if (!argp2) {
34566 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34567 }
34568 arg2 = reinterpret_cast< wxDC * >(argp2);
34569 {
34570 PyThreadState* __tstate = wxPyBeginAllowThreads();
34571 (arg1)->PrepareDC(*arg2);
34572 wxPyEndAllowThreads(__tstate);
34573 if (PyErr_Occurred()) SWIG_fail;
34574 }
34575 resultobj = SWIG_Py_Void();
34576 return resultobj;
34577 fail:
34578 return NULL;
34579 }
34580
34581
34582 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34583 PyObject *resultobj = 0;
34584 wxWindow *arg1 = (wxWindow *) 0 ;
34585 wxRegion *result = 0 ;
34586 void *argp1 = 0 ;
34587 int res1 = 0 ;
34588 PyObject *swig_obj[1] ;
34589
34590 if (!args) SWIG_fail;
34591 swig_obj[0] = args;
34592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34593 if (!SWIG_IsOK(res1)) {
34594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34595 }
34596 arg1 = reinterpret_cast< wxWindow * >(argp1);
34597 {
34598 PyThreadState* __tstate = wxPyBeginAllowThreads();
34599 {
34600 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34601 result = (wxRegion *) &_result_ref;
34602 }
34603 wxPyEndAllowThreads(__tstate);
34604 if (PyErr_Occurred()) SWIG_fail;
34605 }
34606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34607 return resultobj;
34608 fail:
34609 return NULL;
34610 }
34611
34612
34613 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34614 PyObject *resultobj = 0;
34615 wxWindow *arg1 = (wxWindow *) 0 ;
34616 wxRect result;
34617 void *argp1 = 0 ;
34618 int res1 = 0 ;
34619 PyObject *swig_obj[1] ;
34620
34621 if (!args) SWIG_fail;
34622 swig_obj[0] = args;
34623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34624 if (!SWIG_IsOK(res1)) {
34625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34626 }
34627 arg1 = reinterpret_cast< wxWindow * >(argp1);
34628 {
34629 PyThreadState* __tstate = wxPyBeginAllowThreads();
34630 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34631 wxPyEndAllowThreads(__tstate);
34632 if (PyErr_Occurred()) SWIG_fail;
34633 }
34634 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34635 return resultobj;
34636 fail:
34637 return NULL;
34638 }
34639
34640
34641 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34642 PyObject *resultobj = 0;
34643 wxWindow *arg1 = (wxWindow *) 0 ;
34644 int arg2 ;
34645 int arg3 ;
34646 int arg4 = (int) 1 ;
34647 int arg5 = (int) 1 ;
34648 bool result;
34649 void *argp1 = 0 ;
34650 int res1 = 0 ;
34651 int val2 ;
34652 int ecode2 = 0 ;
34653 int val3 ;
34654 int ecode3 = 0 ;
34655 int val4 ;
34656 int ecode4 = 0 ;
34657 int val5 ;
34658 int ecode5 = 0 ;
34659 PyObject * obj0 = 0 ;
34660 PyObject * obj1 = 0 ;
34661 PyObject * obj2 = 0 ;
34662 PyObject * obj3 = 0 ;
34663 PyObject * obj4 = 0 ;
34664 char * kwnames[] = {
34665 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34666 };
34667
34668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34670 if (!SWIG_IsOK(res1)) {
34671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34672 }
34673 arg1 = reinterpret_cast< wxWindow * >(argp1);
34674 ecode2 = SWIG_AsVal_int(obj1, &val2);
34675 if (!SWIG_IsOK(ecode2)) {
34676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34677 }
34678 arg2 = static_cast< int >(val2);
34679 ecode3 = SWIG_AsVal_int(obj2, &val3);
34680 if (!SWIG_IsOK(ecode3)) {
34681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34682 }
34683 arg3 = static_cast< int >(val3);
34684 if (obj3) {
34685 ecode4 = SWIG_AsVal_int(obj3, &val4);
34686 if (!SWIG_IsOK(ecode4)) {
34687 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34688 }
34689 arg4 = static_cast< int >(val4);
34690 }
34691 if (obj4) {
34692 ecode5 = SWIG_AsVal_int(obj4, &val5);
34693 if (!SWIG_IsOK(ecode5)) {
34694 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34695 }
34696 arg5 = static_cast< int >(val5);
34697 }
34698 {
34699 PyThreadState* __tstate = wxPyBeginAllowThreads();
34700 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34701 wxPyEndAllowThreads(__tstate);
34702 if (PyErr_Occurred()) SWIG_fail;
34703 }
34704 {
34705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34706 }
34707 return resultobj;
34708 fail:
34709 return NULL;
34710 }
34711
34712
34713 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34714 PyObject *resultobj = 0;
34715 wxWindow *arg1 = (wxWindow *) 0 ;
34716 wxPoint *arg2 = 0 ;
34717 bool result;
34718 void *argp1 = 0 ;
34719 int res1 = 0 ;
34720 wxPoint temp2 ;
34721 PyObject * obj0 = 0 ;
34722 PyObject * obj1 = 0 ;
34723 char * kwnames[] = {
34724 (char *) "self",(char *) "pt", NULL
34725 };
34726
34727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34729 if (!SWIG_IsOK(res1)) {
34730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34731 }
34732 arg1 = reinterpret_cast< wxWindow * >(argp1);
34733 {
34734 arg2 = &temp2;
34735 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34736 }
34737 {
34738 PyThreadState* __tstate = wxPyBeginAllowThreads();
34739 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34740 wxPyEndAllowThreads(__tstate);
34741 if (PyErr_Occurred()) SWIG_fail;
34742 }
34743 {
34744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34745 }
34746 return resultobj;
34747 fail:
34748 return NULL;
34749 }
34750
34751
34752 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34753 PyObject *resultobj = 0;
34754 wxWindow *arg1 = (wxWindow *) 0 ;
34755 wxRect *arg2 = 0 ;
34756 bool result;
34757 void *argp1 = 0 ;
34758 int res1 = 0 ;
34759 wxRect temp2 ;
34760 PyObject * obj0 = 0 ;
34761 PyObject * obj1 = 0 ;
34762 char * kwnames[] = {
34763 (char *) "self",(char *) "rect", NULL
34764 };
34765
34766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34768 if (!SWIG_IsOK(res1)) {
34769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34770 }
34771 arg1 = reinterpret_cast< wxWindow * >(argp1);
34772 {
34773 arg2 = &temp2;
34774 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34775 }
34776 {
34777 PyThreadState* __tstate = wxPyBeginAllowThreads();
34778 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34779 wxPyEndAllowThreads(__tstate);
34780 if (PyErr_Occurred()) SWIG_fail;
34781 }
34782 {
34783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34784 }
34785 return resultobj;
34786 fail:
34787 return NULL;
34788 }
34789
34790
34791 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34792 PyObject *resultobj = 0;
34793 wxWindow *arg1 = (wxWindow *) 0 ;
34794 SwigValueWrapper<wxVisualAttributes > result;
34795 void *argp1 = 0 ;
34796 int res1 = 0 ;
34797 PyObject *swig_obj[1] ;
34798
34799 if (!args) SWIG_fail;
34800 swig_obj[0] = args;
34801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34802 if (!SWIG_IsOK(res1)) {
34803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34804 }
34805 arg1 = reinterpret_cast< wxWindow * >(argp1);
34806 {
34807 PyThreadState* __tstate = wxPyBeginAllowThreads();
34808 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34809 wxPyEndAllowThreads(__tstate);
34810 if (PyErr_Occurred()) SWIG_fail;
34811 }
34812 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34813 return resultobj;
34814 fail:
34815 return NULL;
34816 }
34817
34818
34819 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34820 PyObject *resultobj = 0;
34821 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34822 SwigValueWrapper<wxVisualAttributes > result;
34823 int val1 ;
34824 int ecode1 = 0 ;
34825 PyObject * obj0 = 0 ;
34826 char * kwnames[] = {
34827 (char *) "variant", NULL
34828 };
34829
34830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34831 if (obj0) {
34832 ecode1 = SWIG_AsVal_int(obj0, &val1);
34833 if (!SWIG_IsOK(ecode1)) {
34834 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34835 }
34836 arg1 = static_cast< wxWindowVariant >(val1);
34837 }
34838 {
34839 if (!wxPyCheckForApp()) SWIG_fail;
34840 PyThreadState* __tstate = wxPyBeginAllowThreads();
34841 result = wxWindow::GetClassDefaultAttributes(arg1);
34842 wxPyEndAllowThreads(__tstate);
34843 if (PyErr_Occurred()) SWIG_fail;
34844 }
34845 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34846 return resultobj;
34847 fail:
34848 return NULL;
34849 }
34850
34851
34852 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34853 PyObject *resultobj = 0;
34854 wxWindow *arg1 = (wxWindow *) 0 ;
34855 wxColour *arg2 = 0 ;
34856 bool result;
34857 void *argp1 = 0 ;
34858 int res1 = 0 ;
34859 wxColour temp2 ;
34860 PyObject * obj0 = 0 ;
34861 PyObject * obj1 = 0 ;
34862 char * kwnames[] = {
34863 (char *) "self",(char *) "colour", NULL
34864 };
34865
34866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34868 if (!SWIG_IsOK(res1)) {
34869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34870 }
34871 arg1 = reinterpret_cast< wxWindow * >(argp1);
34872 {
34873 arg2 = &temp2;
34874 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34875 }
34876 {
34877 PyThreadState* __tstate = wxPyBeginAllowThreads();
34878 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34879 wxPyEndAllowThreads(__tstate);
34880 if (PyErr_Occurred()) SWIG_fail;
34881 }
34882 {
34883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34884 }
34885 return resultobj;
34886 fail:
34887 return NULL;
34888 }
34889
34890
34891 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34892 PyObject *resultobj = 0;
34893 wxWindow *arg1 = (wxWindow *) 0 ;
34894 wxColour *arg2 = 0 ;
34895 void *argp1 = 0 ;
34896 int res1 = 0 ;
34897 wxColour temp2 ;
34898 PyObject * obj0 = 0 ;
34899 PyObject * obj1 = 0 ;
34900 char * kwnames[] = {
34901 (char *) "self",(char *) "colour", NULL
34902 };
34903
34904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34906 if (!SWIG_IsOK(res1)) {
34907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34908 }
34909 arg1 = reinterpret_cast< wxWindow * >(argp1);
34910 {
34911 arg2 = &temp2;
34912 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34913 }
34914 {
34915 PyThreadState* __tstate = wxPyBeginAllowThreads();
34916 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34917 wxPyEndAllowThreads(__tstate);
34918 if (PyErr_Occurred()) SWIG_fail;
34919 }
34920 resultobj = SWIG_Py_Void();
34921 return resultobj;
34922 fail:
34923 return NULL;
34924 }
34925
34926
34927 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34928 PyObject *resultobj = 0;
34929 wxWindow *arg1 = (wxWindow *) 0 ;
34930 wxColour *arg2 = 0 ;
34931 bool result;
34932 void *argp1 = 0 ;
34933 int res1 = 0 ;
34934 wxColour temp2 ;
34935 PyObject * obj0 = 0 ;
34936 PyObject * obj1 = 0 ;
34937 char * kwnames[] = {
34938 (char *) "self",(char *) "colour", NULL
34939 };
34940
34941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34943 if (!SWIG_IsOK(res1)) {
34944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34945 }
34946 arg1 = reinterpret_cast< wxWindow * >(argp1);
34947 {
34948 arg2 = &temp2;
34949 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34950 }
34951 {
34952 PyThreadState* __tstate = wxPyBeginAllowThreads();
34953 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34954 wxPyEndAllowThreads(__tstate);
34955 if (PyErr_Occurred()) SWIG_fail;
34956 }
34957 {
34958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34959 }
34960 return resultobj;
34961 fail:
34962 return NULL;
34963 }
34964
34965
34966 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34967 PyObject *resultobj = 0;
34968 wxWindow *arg1 = (wxWindow *) 0 ;
34969 wxColour *arg2 = 0 ;
34970 void *argp1 = 0 ;
34971 int res1 = 0 ;
34972 wxColour temp2 ;
34973 PyObject * obj0 = 0 ;
34974 PyObject * obj1 = 0 ;
34975 char * kwnames[] = {
34976 (char *) "self",(char *) "colour", NULL
34977 };
34978
34979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34981 if (!SWIG_IsOK(res1)) {
34982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34983 }
34984 arg1 = reinterpret_cast< wxWindow * >(argp1);
34985 {
34986 arg2 = &temp2;
34987 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34988 }
34989 {
34990 PyThreadState* __tstate = wxPyBeginAllowThreads();
34991 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34992 wxPyEndAllowThreads(__tstate);
34993 if (PyErr_Occurred()) SWIG_fail;
34994 }
34995 resultobj = SWIG_Py_Void();
34996 return resultobj;
34997 fail:
34998 return NULL;
34999 }
35000
35001
35002 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35003 PyObject *resultobj = 0;
35004 wxWindow *arg1 = (wxWindow *) 0 ;
35005 wxColour result;
35006 void *argp1 = 0 ;
35007 int res1 = 0 ;
35008 PyObject *swig_obj[1] ;
35009
35010 if (!args) SWIG_fail;
35011 swig_obj[0] = args;
35012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35013 if (!SWIG_IsOK(res1)) {
35014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35015 }
35016 arg1 = reinterpret_cast< wxWindow * >(argp1);
35017 {
35018 PyThreadState* __tstate = wxPyBeginAllowThreads();
35019 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35020 wxPyEndAllowThreads(__tstate);
35021 if (PyErr_Occurred()) SWIG_fail;
35022 }
35023 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35024 return resultobj;
35025 fail:
35026 return NULL;
35027 }
35028
35029
35030 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35031 PyObject *resultobj = 0;
35032 wxWindow *arg1 = (wxWindow *) 0 ;
35033 wxColour result;
35034 void *argp1 = 0 ;
35035 int res1 = 0 ;
35036 PyObject *swig_obj[1] ;
35037
35038 if (!args) SWIG_fail;
35039 swig_obj[0] = args;
35040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35041 if (!SWIG_IsOK(res1)) {
35042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35043 }
35044 arg1 = reinterpret_cast< wxWindow * >(argp1);
35045 {
35046 PyThreadState* __tstate = wxPyBeginAllowThreads();
35047 result = ((wxWindow const *)arg1)->GetForegroundColour();
35048 wxPyEndAllowThreads(__tstate);
35049 if (PyErr_Occurred()) SWIG_fail;
35050 }
35051 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35052 return resultobj;
35053 fail:
35054 return NULL;
35055 }
35056
35057
35058 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35059 PyObject *resultobj = 0;
35060 wxWindow *arg1 = (wxWindow *) 0 ;
35061 bool result;
35062 void *argp1 = 0 ;
35063 int res1 = 0 ;
35064 PyObject *swig_obj[1] ;
35065
35066 if (!args) SWIG_fail;
35067 swig_obj[0] = args;
35068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35069 if (!SWIG_IsOK(res1)) {
35070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35071 }
35072 arg1 = reinterpret_cast< wxWindow * >(argp1);
35073 {
35074 PyThreadState* __tstate = wxPyBeginAllowThreads();
35075 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35076 wxPyEndAllowThreads(__tstate);
35077 if (PyErr_Occurred()) SWIG_fail;
35078 }
35079 {
35080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35081 }
35082 return resultobj;
35083 fail:
35084 return NULL;
35085 }
35086
35087
35088 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35089 PyObject *resultobj = 0;
35090 wxWindow *arg1 = (wxWindow *) 0 ;
35091 bool result;
35092 void *argp1 = 0 ;
35093 int res1 = 0 ;
35094 PyObject *swig_obj[1] ;
35095
35096 if (!args) SWIG_fail;
35097 swig_obj[0] = args;
35098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35099 if (!SWIG_IsOK(res1)) {
35100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35101 }
35102 arg1 = reinterpret_cast< wxWindow * >(argp1);
35103 {
35104 PyThreadState* __tstate = wxPyBeginAllowThreads();
35105 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35106 wxPyEndAllowThreads(__tstate);
35107 if (PyErr_Occurred()) SWIG_fail;
35108 }
35109 {
35110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35111 }
35112 return resultobj;
35113 fail:
35114 return NULL;
35115 }
35116
35117
35118 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35119 PyObject *resultobj = 0;
35120 wxWindow *arg1 = (wxWindow *) 0 ;
35121 wxBackgroundStyle arg2 ;
35122 bool result;
35123 void *argp1 = 0 ;
35124 int res1 = 0 ;
35125 int val2 ;
35126 int ecode2 = 0 ;
35127 PyObject * obj0 = 0 ;
35128 PyObject * obj1 = 0 ;
35129 char * kwnames[] = {
35130 (char *) "self",(char *) "style", NULL
35131 };
35132
35133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35135 if (!SWIG_IsOK(res1)) {
35136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35137 }
35138 arg1 = reinterpret_cast< wxWindow * >(argp1);
35139 ecode2 = SWIG_AsVal_int(obj1, &val2);
35140 if (!SWIG_IsOK(ecode2)) {
35141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35142 }
35143 arg2 = static_cast< wxBackgroundStyle >(val2);
35144 {
35145 PyThreadState* __tstate = wxPyBeginAllowThreads();
35146 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35147 wxPyEndAllowThreads(__tstate);
35148 if (PyErr_Occurred()) SWIG_fail;
35149 }
35150 {
35151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35152 }
35153 return resultobj;
35154 fail:
35155 return NULL;
35156 }
35157
35158
35159 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35160 PyObject *resultobj = 0;
35161 wxWindow *arg1 = (wxWindow *) 0 ;
35162 wxBackgroundStyle result;
35163 void *argp1 = 0 ;
35164 int res1 = 0 ;
35165 PyObject *swig_obj[1] ;
35166
35167 if (!args) SWIG_fail;
35168 swig_obj[0] = args;
35169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35170 if (!SWIG_IsOK(res1)) {
35171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35172 }
35173 arg1 = reinterpret_cast< wxWindow * >(argp1);
35174 {
35175 PyThreadState* __tstate = wxPyBeginAllowThreads();
35176 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35177 wxPyEndAllowThreads(__tstate);
35178 if (PyErr_Occurred()) SWIG_fail;
35179 }
35180 resultobj = SWIG_From_int(static_cast< int >(result));
35181 return resultobj;
35182 fail:
35183 return NULL;
35184 }
35185
35186
35187 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35188 PyObject *resultobj = 0;
35189 wxWindow *arg1 = (wxWindow *) 0 ;
35190 bool result;
35191 void *argp1 = 0 ;
35192 int res1 = 0 ;
35193 PyObject *swig_obj[1] ;
35194
35195 if (!args) SWIG_fail;
35196 swig_obj[0] = args;
35197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35198 if (!SWIG_IsOK(res1)) {
35199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35200 }
35201 arg1 = reinterpret_cast< wxWindow * >(argp1);
35202 {
35203 PyThreadState* __tstate = wxPyBeginAllowThreads();
35204 result = (bool)(arg1)->HasTransparentBackground();
35205 wxPyEndAllowThreads(__tstate);
35206 if (PyErr_Occurred()) SWIG_fail;
35207 }
35208 {
35209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35210 }
35211 return resultobj;
35212 fail:
35213 return NULL;
35214 }
35215
35216
35217 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35218 PyObject *resultobj = 0;
35219 wxWindow *arg1 = (wxWindow *) 0 ;
35220 wxCursor *arg2 = 0 ;
35221 bool result;
35222 void *argp1 = 0 ;
35223 int res1 = 0 ;
35224 void *argp2 = 0 ;
35225 int res2 = 0 ;
35226 PyObject * obj0 = 0 ;
35227 PyObject * obj1 = 0 ;
35228 char * kwnames[] = {
35229 (char *) "self",(char *) "cursor", NULL
35230 };
35231
35232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35234 if (!SWIG_IsOK(res1)) {
35235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35236 }
35237 arg1 = reinterpret_cast< wxWindow * >(argp1);
35238 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35239 if (!SWIG_IsOK(res2)) {
35240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35241 }
35242 if (!argp2) {
35243 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35244 }
35245 arg2 = reinterpret_cast< wxCursor * >(argp2);
35246 {
35247 PyThreadState* __tstate = wxPyBeginAllowThreads();
35248 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35249 wxPyEndAllowThreads(__tstate);
35250 if (PyErr_Occurred()) SWIG_fail;
35251 }
35252 {
35253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35254 }
35255 return resultobj;
35256 fail:
35257 return NULL;
35258 }
35259
35260
35261 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35262 PyObject *resultobj = 0;
35263 wxWindow *arg1 = (wxWindow *) 0 ;
35264 wxCursor result;
35265 void *argp1 = 0 ;
35266 int res1 = 0 ;
35267 PyObject *swig_obj[1] ;
35268
35269 if (!args) SWIG_fail;
35270 swig_obj[0] = args;
35271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35272 if (!SWIG_IsOK(res1)) {
35273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35274 }
35275 arg1 = reinterpret_cast< wxWindow * >(argp1);
35276 {
35277 PyThreadState* __tstate = wxPyBeginAllowThreads();
35278 result = (arg1)->GetCursor();
35279 wxPyEndAllowThreads(__tstate);
35280 if (PyErr_Occurred()) SWIG_fail;
35281 }
35282 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35283 return resultobj;
35284 fail:
35285 return NULL;
35286 }
35287
35288
35289 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35290 PyObject *resultobj = 0;
35291 wxWindow *arg1 = (wxWindow *) 0 ;
35292 wxFont *arg2 = 0 ;
35293 bool result;
35294 void *argp1 = 0 ;
35295 int res1 = 0 ;
35296 void *argp2 = 0 ;
35297 int res2 = 0 ;
35298 PyObject * obj0 = 0 ;
35299 PyObject * obj1 = 0 ;
35300 char * kwnames[] = {
35301 (char *) "self",(char *) "font", NULL
35302 };
35303
35304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35306 if (!SWIG_IsOK(res1)) {
35307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35308 }
35309 arg1 = reinterpret_cast< wxWindow * >(argp1);
35310 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35311 if (!SWIG_IsOK(res2)) {
35312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35313 }
35314 if (!argp2) {
35315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35316 }
35317 arg2 = reinterpret_cast< wxFont * >(argp2);
35318 {
35319 PyThreadState* __tstate = wxPyBeginAllowThreads();
35320 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35321 wxPyEndAllowThreads(__tstate);
35322 if (PyErr_Occurred()) SWIG_fail;
35323 }
35324 {
35325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35326 }
35327 return resultobj;
35328 fail:
35329 return NULL;
35330 }
35331
35332
35333 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35334 PyObject *resultobj = 0;
35335 wxWindow *arg1 = (wxWindow *) 0 ;
35336 wxFont *arg2 = 0 ;
35337 void *argp1 = 0 ;
35338 int res1 = 0 ;
35339 void *argp2 = 0 ;
35340 int res2 = 0 ;
35341 PyObject * obj0 = 0 ;
35342 PyObject * obj1 = 0 ;
35343 char * kwnames[] = {
35344 (char *) "self",(char *) "font", NULL
35345 };
35346
35347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35349 if (!SWIG_IsOK(res1)) {
35350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35351 }
35352 arg1 = reinterpret_cast< wxWindow * >(argp1);
35353 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35354 if (!SWIG_IsOK(res2)) {
35355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35356 }
35357 if (!argp2) {
35358 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35359 }
35360 arg2 = reinterpret_cast< wxFont * >(argp2);
35361 {
35362 PyThreadState* __tstate = wxPyBeginAllowThreads();
35363 (arg1)->SetOwnFont((wxFont const &)*arg2);
35364 wxPyEndAllowThreads(__tstate);
35365 if (PyErr_Occurred()) SWIG_fail;
35366 }
35367 resultobj = SWIG_Py_Void();
35368 return resultobj;
35369 fail:
35370 return NULL;
35371 }
35372
35373
35374 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35375 PyObject *resultobj = 0;
35376 wxWindow *arg1 = (wxWindow *) 0 ;
35377 wxFont result;
35378 void *argp1 = 0 ;
35379 int res1 = 0 ;
35380 PyObject *swig_obj[1] ;
35381
35382 if (!args) SWIG_fail;
35383 swig_obj[0] = args;
35384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35385 if (!SWIG_IsOK(res1)) {
35386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35387 }
35388 arg1 = reinterpret_cast< wxWindow * >(argp1);
35389 {
35390 PyThreadState* __tstate = wxPyBeginAllowThreads();
35391 result = (arg1)->GetFont();
35392 wxPyEndAllowThreads(__tstate);
35393 if (PyErr_Occurred()) SWIG_fail;
35394 }
35395 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35396 return resultobj;
35397 fail:
35398 return NULL;
35399 }
35400
35401
35402 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35403 PyObject *resultobj = 0;
35404 wxWindow *arg1 = (wxWindow *) 0 ;
35405 wxCaret *arg2 = (wxCaret *) 0 ;
35406 void *argp1 = 0 ;
35407 int res1 = 0 ;
35408 int res2 = 0 ;
35409 PyObject * obj0 = 0 ;
35410 PyObject * obj1 = 0 ;
35411 char * kwnames[] = {
35412 (char *) "self",(char *) "caret", NULL
35413 };
35414
35415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35417 if (!SWIG_IsOK(res1)) {
35418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35419 }
35420 arg1 = reinterpret_cast< wxWindow * >(argp1);
35421 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35422 if (!SWIG_IsOK(res2)) {
35423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35424 }
35425 {
35426 PyThreadState* __tstate = wxPyBeginAllowThreads();
35427 (arg1)->SetCaret(arg2);
35428 wxPyEndAllowThreads(__tstate);
35429 if (PyErr_Occurred()) SWIG_fail;
35430 }
35431 resultobj = SWIG_Py_Void();
35432 return resultobj;
35433 fail:
35434 return NULL;
35435 }
35436
35437
35438 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35439 PyObject *resultobj = 0;
35440 wxWindow *arg1 = (wxWindow *) 0 ;
35441 wxCaret *result = 0 ;
35442 void *argp1 = 0 ;
35443 int res1 = 0 ;
35444 PyObject *swig_obj[1] ;
35445
35446 if (!args) SWIG_fail;
35447 swig_obj[0] = args;
35448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35449 if (!SWIG_IsOK(res1)) {
35450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35451 }
35452 arg1 = reinterpret_cast< wxWindow * >(argp1);
35453 {
35454 PyThreadState* __tstate = wxPyBeginAllowThreads();
35455 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35456 wxPyEndAllowThreads(__tstate);
35457 if (PyErr_Occurred()) SWIG_fail;
35458 }
35459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35460 return resultobj;
35461 fail:
35462 return NULL;
35463 }
35464
35465
35466 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35467 PyObject *resultobj = 0;
35468 wxWindow *arg1 = (wxWindow *) 0 ;
35469 int result;
35470 void *argp1 = 0 ;
35471 int res1 = 0 ;
35472 PyObject *swig_obj[1] ;
35473
35474 if (!args) SWIG_fail;
35475 swig_obj[0] = args;
35476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35477 if (!SWIG_IsOK(res1)) {
35478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35479 }
35480 arg1 = reinterpret_cast< wxWindow * >(argp1);
35481 {
35482 PyThreadState* __tstate = wxPyBeginAllowThreads();
35483 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35484 wxPyEndAllowThreads(__tstate);
35485 if (PyErr_Occurred()) SWIG_fail;
35486 }
35487 resultobj = SWIG_From_int(static_cast< int >(result));
35488 return resultobj;
35489 fail:
35490 return NULL;
35491 }
35492
35493
35494 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35495 PyObject *resultobj = 0;
35496 wxWindow *arg1 = (wxWindow *) 0 ;
35497 int result;
35498 void *argp1 = 0 ;
35499 int res1 = 0 ;
35500 PyObject *swig_obj[1] ;
35501
35502 if (!args) SWIG_fail;
35503 swig_obj[0] = args;
35504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35505 if (!SWIG_IsOK(res1)) {
35506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35507 }
35508 arg1 = reinterpret_cast< wxWindow * >(argp1);
35509 {
35510 PyThreadState* __tstate = wxPyBeginAllowThreads();
35511 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35512 wxPyEndAllowThreads(__tstate);
35513 if (PyErr_Occurred()) SWIG_fail;
35514 }
35515 resultobj = SWIG_From_int(static_cast< int >(result));
35516 return resultobj;
35517 fail:
35518 return NULL;
35519 }
35520
35521
35522 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35523 PyObject *resultobj = 0;
35524 wxWindow *arg1 = (wxWindow *) 0 ;
35525 wxString *arg2 = 0 ;
35526 int *arg3 = (int *) 0 ;
35527 int *arg4 = (int *) 0 ;
35528 void *argp1 = 0 ;
35529 int res1 = 0 ;
35530 bool temp2 = false ;
35531 int temp3 ;
35532 int res3 = SWIG_TMPOBJ ;
35533 int temp4 ;
35534 int res4 = SWIG_TMPOBJ ;
35535 PyObject * obj0 = 0 ;
35536 PyObject * obj1 = 0 ;
35537 char * kwnames[] = {
35538 (char *) "self",(char *) "string", NULL
35539 };
35540
35541 arg3 = &temp3;
35542 arg4 = &temp4;
35543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35545 if (!SWIG_IsOK(res1)) {
35546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35547 }
35548 arg1 = reinterpret_cast< wxWindow * >(argp1);
35549 {
35550 arg2 = wxString_in_helper(obj1);
35551 if (arg2 == NULL) SWIG_fail;
35552 temp2 = true;
35553 }
35554 {
35555 PyThreadState* __tstate = wxPyBeginAllowThreads();
35556 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35557 wxPyEndAllowThreads(__tstate);
35558 if (PyErr_Occurred()) SWIG_fail;
35559 }
35560 resultobj = SWIG_Py_Void();
35561 if (SWIG_IsTmpObj(res3)) {
35562 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35563 } else {
35564 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35565 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35566 }
35567 if (SWIG_IsTmpObj(res4)) {
35568 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35569 } else {
35570 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35571 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35572 }
35573 {
35574 if (temp2)
35575 delete arg2;
35576 }
35577 return resultobj;
35578 fail:
35579 {
35580 if (temp2)
35581 delete arg2;
35582 }
35583 return NULL;
35584 }
35585
35586
35587 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35588 PyObject *resultobj = 0;
35589 wxWindow *arg1 = (wxWindow *) 0 ;
35590 wxString *arg2 = 0 ;
35591 int *arg3 = (int *) 0 ;
35592 int *arg4 = (int *) 0 ;
35593 int *arg5 = (int *) 0 ;
35594 int *arg6 = (int *) 0 ;
35595 wxFont *arg7 = (wxFont *) NULL ;
35596 void *argp1 = 0 ;
35597 int res1 = 0 ;
35598 bool temp2 = false ;
35599 int temp3 ;
35600 int res3 = SWIG_TMPOBJ ;
35601 int temp4 ;
35602 int res4 = SWIG_TMPOBJ ;
35603 int temp5 ;
35604 int res5 = SWIG_TMPOBJ ;
35605 int temp6 ;
35606 int res6 = SWIG_TMPOBJ ;
35607 void *argp7 = 0 ;
35608 int res7 = 0 ;
35609 PyObject * obj0 = 0 ;
35610 PyObject * obj1 = 0 ;
35611 PyObject * obj2 = 0 ;
35612 char * kwnames[] = {
35613 (char *) "self",(char *) "string",(char *) "font", NULL
35614 };
35615
35616 arg3 = &temp3;
35617 arg4 = &temp4;
35618 arg5 = &temp5;
35619 arg6 = &temp6;
35620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35622 if (!SWIG_IsOK(res1)) {
35623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35624 }
35625 arg1 = reinterpret_cast< wxWindow * >(argp1);
35626 {
35627 arg2 = wxString_in_helper(obj1);
35628 if (arg2 == NULL) SWIG_fail;
35629 temp2 = true;
35630 }
35631 if (obj2) {
35632 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35633 if (!SWIG_IsOK(res7)) {
35634 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35635 }
35636 arg7 = reinterpret_cast< wxFont * >(argp7);
35637 }
35638 {
35639 PyThreadState* __tstate = wxPyBeginAllowThreads();
35640 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35641 wxPyEndAllowThreads(__tstate);
35642 if (PyErr_Occurred()) SWIG_fail;
35643 }
35644 resultobj = SWIG_Py_Void();
35645 if (SWIG_IsTmpObj(res3)) {
35646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35647 } else {
35648 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35650 }
35651 if (SWIG_IsTmpObj(res4)) {
35652 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35653 } else {
35654 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35655 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35656 }
35657 if (SWIG_IsTmpObj(res5)) {
35658 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35659 } else {
35660 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35661 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35662 }
35663 if (SWIG_IsTmpObj(res6)) {
35664 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35665 } else {
35666 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35667 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35668 }
35669 {
35670 if (temp2)
35671 delete arg2;
35672 }
35673 return resultobj;
35674 fail:
35675 {
35676 if (temp2)
35677 delete arg2;
35678 }
35679 return NULL;
35680 }
35681
35682
35683 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35684 PyObject *resultobj = 0;
35685 wxWindow *arg1 = (wxWindow *) 0 ;
35686 int *arg2 = (int *) 0 ;
35687 int *arg3 = (int *) 0 ;
35688 void *argp1 = 0 ;
35689 int res1 = 0 ;
35690 int temp2 ;
35691 int res2 = 0 ;
35692 int temp3 ;
35693 int res3 = 0 ;
35694 PyObject * obj0 = 0 ;
35695 PyObject * obj1 = 0 ;
35696 PyObject * obj2 = 0 ;
35697 char * kwnames[] = {
35698 (char *) "self",(char *) "x",(char *) "y", NULL
35699 };
35700
35701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35703 if (!SWIG_IsOK(res1)) {
35704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35705 }
35706 arg1 = reinterpret_cast< wxWindow * >(argp1);
35707 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35708 int val;
35709 int ecode = SWIG_AsVal_int(obj1, &val);
35710 if (!SWIG_IsOK(ecode)) {
35711 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35712 }
35713 temp2 = static_cast< int >(val);
35714 arg2 = &temp2;
35715 res2 = SWIG_AddTmpMask(ecode);
35716 }
35717 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35718 int val;
35719 int ecode = SWIG_AsVal_int(obj2, &val);
35720 if (!SWIG_IsOK(ecode)) {
35721 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35722 }
35723 temp3 = static_cast< int >(val);
35724 arg3 = &temp3;
35725 res3 = SWIG_AddTmpMask(ecode);
35726 }
35727 {
35728 PyThreadState* __tstate = wxPyBeginAllowThreads();
35729 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35730 wxPyEndAllowThreads(__tstate);
35731 if (PyErr_Occurred()) SWIG_fail;
35732 }
35733 resultobj = SWIG_Py_Void();
35734 if (SWIG_IsTmpObj(res2)) {
35735 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35736 } else {
35737 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35738 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35739 }
35740 if (SWIG_IsTmpObj(res3)) {
35741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35742 } else {
35743 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35744 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35745 }
35746 return resultobj;
35747 fail:
35748 return NULL;
35749 }
35750
35751
35752 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35753 PyObject *resultobj = 0;
35754 wxWindow *arg1 = (wxWindow *) 0 ;
35755 int *arg2 = (int *) 0 ;
35756 int *arg3 = (int *) 0 ;
35757 void *argp1 = 0 ;
35758 int res1 = 0 ;
35759 int temp2 ;
35760 int res2 = 0 ;
35761 int temp3 ;
35762 int res3 = 0 ;
35763 PyObject * obj0 = 0 ;
35764 PyObject * obj1 = 0 ;
35765 PyObject * obj2 = 0 ;
35766 char * kwnames[] = {
35767 (char *) "self",(char *) "x",(char *) "y", NULL
35768 };
35769
35770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35772 if (!SWIG_IsOK(res1)) {
35773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35774 }
35775 arg1 = reinterpret_cast< wxWindow * >(argp1);
35776 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35777 int val;
35778 int ecode = SWIG_AsVal_int(obj1, &val);
35779 if (!SWIG_IsOK(ecode)) {
35780 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35781 }
35782 temp2 = static_cast< int >(val);
35783 arg2 = &temp2;
35784 res2 = SWIG_AddTmpMask(ecode);
35785 }
35786 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35787 int val;
35788 int ecode = SWIG_AsVal_int(obj2, &val);
35789 if (!SWIG_IsOK(ecode)) {
35790 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35791 }
35792 temp3 = static_cast< int >(val);
35793 arg3 = &temp3;
35794 res3 = SWIG_AddTmpMask(ecode);
35795 }
35796 {
35797 PyThreadState* __tstate = wxPyBeginAllowThreads();
35798 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35799 wxPyEndAllowThreads(__tstate);
35800 if (PyErr_Occurred()) SWIG_fail;
35801 }
35802 resultobj = SWIG_Py_Void();
35803 if (SWIG_IsTmpObj(res2)) {
35804 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35805 } else {
35806 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35807 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35808 }
35809 if (SWIG_IsTmpObj(res3)) {
35810 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35811 } else {
35812 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35813 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35814 }
35815 return resultobj;
35816 fail:
35817 return NULL;
35818 }
35819
35820
35821 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35822 PyObject *resultobj = 0;
35823 wxWindow *arg1 = (wxWindow *) 0 ;
35824 wxPoint *arg2 = 0 ;
35825 wxPoint result;
35826 void *argp1 = 0 ;
35827 int res1 = 0 ;
35828 wxPoint temp2 ;
35829 PyObject * obj0 = 0 ;
35830 PyObject * obj1 = 0 ;
35831 char * kwnames[] = {
35832 (char *) "self",(char *) "pt", NULL
35833 };
35834
35835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35837 if (!SWIG_IsOK(res1)) {
35838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35839 }
35840 arg1 = reinterpret_cast< wxWindow * >(argp1);
35841 {
35842 arg2 = &temp2;
35843 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35844 }
35845 {
35846 PyThreadState* __tstate = wxPyBeginAllowThreads();
35847 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35848 wxPyEndAllowThreads(__tstate);
35849 if (PyErr_Occurred()) SWIG_fail;
35850 }
35851 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35852 return resultobj;
35853 fail:
35854 return NULL;
35855 }
35856
35857
35858 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35859 PyObject *resultobj = 0;
35860 wxWindow *arg1 = (wxWindow *) 0 ;
35861 wxPoint *arg2 = 0 ;
35862 wxPoint result;
35863 void *argp1 = 0 ;
35864 int res1 = 0 ;
35865 wxPoint temp2 ;
35866 PyObject * obj0 = 0 ;
35867 PyObject * obj1 = 0 ;
35868 char * kwnames[] = {
35869 (char *) "self",(char *) "pt", NULL
35870 };
35871
35872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35874 if (!SWIG_IsOK(res1)) {
35875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35876 }
35877 arg1 = reinterpret_cast< wxWindow * >(argp1);
35878 {
35879 arg2 = &temp2;
35880 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35881 }
35882 {
35883 PyThreadState* __tstate = wxPyBeginAllowThreads();
35884 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35885 wxPyEndAllowThreads(__tstate);
35886 if (PyErr_Occurred()) SWIG_fail;
35887 }
35888 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35889 return resultobj;
35890 fail:
35891 return NULL;
35892 }
35893
35894
35895 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35896 PyObject *resultobj = 0;
35897 wxWindow *arg1 = (wxWindow *) 0 ;
35898 int arg2 ;
35899 int arg3 ;
35900 wxHitTest result;
35901 void *argp1 = 0 ;
35902 int res1 = 0 ;
35903 int val2 ;
35904 int ecode2 = 0 ;
35905 int val3 ;
35906 int ecode3 = 0 ;
35907 PyObject * obj0 = 0 ;
35908 PyObject * obj1 = 0 ;
35909 PyObject * obj2 = 0 ;
35910 char * kwnames[] = {
35911 (char *) "self",(char *) "x",(char *) "y", NULL
35912 };
35913
35914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35916 if (!SWIG_IsOK(res1)) {
35917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35918 }
35919 arg1 = reinterpret_cast< wxWindow * >(argp1);
35920 ecode2 = SWIG_AsVal_int(obj1, &val2);
35921 if (!SWIG_IsOK(ecode2)) {
35922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35923 }
35924 arg2 = static_cast< int >(val2);
35925 ecode3 = SWIG_AsVal_int(obj2, &val3);
35926 if (!SWIG_IsOK(ecode3)) {
35927 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35928 }
35929 arg3 = static_cast< int >(val3);
35930 {
35931 PyThreadState* __tstate = wxPyBeginAllowThreads();
35932 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35933 wxPyEndAllowThreads(__tstate);
35934 if (PyErr_Occurred()) SWIG_fail;
35935 }
35936 resultobj = SWIG_From_int(static_cast< int >(result));
35937 return resultobj;
35938 fail:
35939 return NULL;
35940 }
35941
35942
35943 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35944 PyObject *resultobj = 0;
35945 wxWindow *arg1 = (wxWindow *) 0 ;
35946 wxPoint *arg2 = 0 ;
35947 wxHitTest result;
35948 void *argp1 = 0 ;
35949 int res1 = 0 ;
35950 wxPoint temp2 ;
35951 PyObject * obj0 = 0 ;
35952 PyObject * obj1 = 0 ;
35953 char * kwnames[] = {
35954 (char *) "self",(char *) "pt", NULL
35955 };
35956
35957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35959 if (!SWIG_IsOK(res1)) {
35960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35961 }
35962 arg1 = reinterpret_cast< wxWindow * >(argp1);
35963 {
35964 arg2 = &temp2;
35965 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35966 }
35967 {
35968 PyThreadState* __tstate = wxPyBeginAllowThreads();
35969 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35970 wxPyEndAllowThreads(__tstate);
35971 if (PyErr_Occurred()) SWIG_fail;
35972 }
35973 resultobj = SWIG_From_int(static_cast< int >(result));
35974 return resultobj;
35975 fail:
35976 return NULL;
35977 }
35978
35979
35980 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35981 PyObject *resultobj = 0;
35982 wxWindow *arg1 = (wxWindow *) 0 ;
35983 long arg2 ;
35984 wxBorder result;
35985 void *argp1 = 0 ;
35986 int res1 = 0 ;
35987 long val2 ;
35988 int ecode2 = 0 ;
35989
35990 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35992 if (!SWIG_IsOK(res1)) {
35993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35994 }
35995 arg1 = reinterpret_cast< wxWindow * >(argp1);
35996 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35997 if (!SWIG_IsOK(ecode2)) {
35998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35999 }
36000 arg2 = static_cast< long >(val2);
36001 {
36002 PyThreadState* __tstate = wxPyBeginAllowThreads();
36003 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36004 wxPyEndAllowThreads(__tstate);
36005 if (PyErr_Occurred()) SWIG_fail;
36006 }
36007 resultobj = SWIG_From_int(static_cast< int >(result));
36008 return resultobj;
36009 fail:
36010 return NULL;
36011 }
36012
36013
36014 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36015 PyObject *resultobj = 0;
36016 wxWindow *arg1 = (wxWindow *) 0 ;
36017 wxBorder result;
36018 void *argp1 = 0 ;
36019 int res1 = 0 ;
36020
36021 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36023 if (!SWIG_IsOK(res1)) {
36024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36025 }
36026 arg1 = reinterpret_cast< wxWindow * >(argp1);
36027 {
36028 PyThreadState* __tstate = wxPyBeginAllowThreads();
36029 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36030 wxPyEndAllowThreads(__tstate);
36031 if (PyErr_Occurred()) SWIG_fail;
36032 }
36033 resultobj = SWIG_From_int(static_cast< int >(result));
36034 return resultobj;
36035 fail:
36036 return NULL;
36037 }
36038
36039
36040 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36041 int argc;
36042 PyObject *argv[3];
36043
36044 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36045 --argc;
36046 if (argc == 1) {
36047 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36048 }
36049 if (argc == 2) {
36050 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36051 }
36052
36053 fail:
36054 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36055 return NULL;
36056 }
36057
36058
36059 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36060 PyObject *resultobj = 0;
36061 wxWindow *arg1 = (wxWindow *) 0 ;
36062 long arg2 = (long) wxUPDATE_UI_NONE ;
36063 void *argp1 = 0 ;
36064 int res1 = 0 ;
36065 long val2 ;
36066 int ecode2 = 0 ;
36067 PyObject * obj0 = 0 ;
36068 PyObject * obj1 = 0 ;
36069 char * kwnames[] = {
36070 (char *) "self",(char *) "flags", NULL
36071 };
36072
36073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36075 if (!SWIG_IsOK(res1)) {
36076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36077 }
36078 arg1 = reinterpret_cast< wxWindow * >(argp1);
36079 if (obj1) {
36080 ecode2 = SWIG_AsVal_long(obj1, &val2);
36081 if (!SWIG_IsOK(ecode2)) {
36082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36083 }
36084 arg2 = static_cast< long >(val2);
36085 }
36086 {
36087 PyThreadState* __tstate = wxPyBeginAllowThreads();
36088 (arg1)->UpdateWindowUI(arg2);
36089 wxPyEndAllowThreads(__tstate);
36090 if (PyErr_Occurred()) SWIG_fail;
36091 }
36092 resultobj = SWIG_Py_Void();
36093 return resultobj;
36094 fail:
36095 return NULL;
36096 }
36097
36098
36099 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36100 PyObject *resultobj = 0;
36101 wxWindow *arg1 = (wxWindow *) 0 ;
36102 wxMenu *arg2 = (wxMenu *) 0 ;
36103 int arg3 = (int) -1 ;
36104 int arg4 = (int) -1 ;
36105 bool result;
36106 void *argp1 = 0 ;
36107 int res1 = 0 ;
36108 void *argp2 = 0 ;
36109 int res2 = 0 ;
36110 int val3 ;
36111 int ecode3 = 0 ;
36112 int val4 ;
36113 int ecode4 = 0 ;
36114 PyObject * obj0 = 0 ;
36115 PyObject * obj1 = 0 ;
36116 PyObject * obj2 = 0 ;
36117 PyObject * obj3 = 0 ;
36118 char * kwnames[] = {
36119 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36120 };
36121
36122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36124 if (!SWIG_IsOK(res1)) {
36125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36126 }
36127 arg1 = reinterpret_cast< wxWindow * >(argp1);
36128 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36129 if (!SWIG_IsOK(res2)) {
36130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36131 }
36132 arg2 = reinterpret_cast< wxMenu * >(argp2);
36133 if (obj2) {
36134 ecode3 = SWIG_AsVal_int(obj2, &val3);
36135 if (!SWIG_IsOK(ecode3)) {
36136 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36137 }
36138 arg3 = static_cast< int >(val3);
36139 }
36140 if (obj3) {
36141 ecode4 = SWIG_AsVal_int(obj3, &val4);
36142 if (!SWIG_IsOK(ecode4)) {
36143 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36144 }
36145 arg4 = static_cast< int >(val4);
36146 }
36147 {
36148 PyThreadState* __tstate = wxPyBeginAllowThreads();
36149 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36150 wxPyEndAllowThreads(__tstate);
36151 if (PyErr_Occurred()) SWIG_fail;
36152 }
36153 {
36154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36155 }
36156 return resultobj;
36157 fail:
36158 return NULL;
36159 }
36160
36161
36162 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36163 PyObject *resultobj = 0;
36164 wxWindow *arg1 = (wxWindow *) 0 ;
36165 wxMenu *arg2 = (wxMenu *) 0 ;
36166 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36167 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36168 bool result;
36169 void *argp1 = 0 ;
36170 int res1 = 0 ;
36171 void *argp2 = 0 ;
36172 int res2 = 0 ;
36173 wxPoint temp3 ;
36174 PyObject * obj0 = 0 ;
36175 PyObject * obj1 = 0 ;
36176 PyObject * obj2 = 0 ;
36177 char * kwnames[] = {
36178 (char *) "self",(char *) "menu",(char *) "pos", NULL
36179 };
36180
36181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36183 if (!SWIG_IsOK(res1)) {
36184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36185 }
36186 arg1 = reinterpret_cast< wxWindow * >(argp1);
36187 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36188 if (!SWIG_IsOK(res2)) {
36189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36190 }
36191 arg2 = reinterpret_cast< wxMenu * >(argp2);
36192 if (obj2) {
36193 {
36194 arg3 = &temp3;
36195 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36196 }
36197 }
36198 {
36199 PyThreadState* __tstate = wxPyBeginAllowThreads();
36200 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36201 wxPyEndAllowThreads(__tstate);
36202 if (PyErr_Occurred()) SWIG_fail;
36203 }
36204 {
36205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36206 }
36207 return resultobj;
36208 fail:
36209 return NULL;
36210 }
36211
36212
36213 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36214 PyObject *resultobj = 0;
36215 wxWindow *arg1 = (wxWindow *) 0 ;
36216 long result;
36217 void *argp1 = 0 ;
36218 int res1 = 0 ;
36219 PyObject *swig_obj[1] ;
36220
36221 if (!args) SWIG_fail;
36222 swig_obj[0] = args;
36223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36224 if (!SWIG_IsOK(res1)) {
36225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36226 }
36227 arg1 = reinterpret_cast< wxWindow * >(argp1);
36228 {
36229 PyThreadState* __tstate = wxPyBeginAllowThreads();
36230 result = (long)wxWindow_GetHandle(arg1);
36231 wxPyEndAllowThreads(__tstate);
36232 if (PyErr_Occurred()) SWIG_fail;
36233 }
36234 resultobj = SWIG_From_long(static_cast< long >(result));
36235 return resultobj;
36236 fail:
36237 return NULL;
36238 }
36239
36240
36241 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36242 PyObject *resultobj = 0;
36243 wxWindow *arg1 = (wxWindow *) 0 ;
36244 long arg2 ;
36245 void *argp1 = 0 ;
36246 int res1 = 0 ;
36247 long val2 ;
36248 int ecode2 = 0 ;
36249 PyObject * obj0 = 0 ;
36250 PyObject * obj1 = 0 ;
36251 char * kwnames[] = {
36252 (char *) "self",(char *) "handle", NULL
36253 };
36254
36255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36257 if (!SWIG_IsOK(res1)) {
36258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36259 }
36260 arg1 = reinterpret_cast< wxWindow * >(argp1);
36261 ecode2 = SWIG_AsVal_long(obj1, &val2);
36262 if (!SWIG_IsOK(ecode2)) {
36263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36264 }
36265 arg2 = static_cast< long >(val2);
36266 {
36267 PyThreadState* __tstate = wxPyBeginAllowThreads();
36268 wxWindow_AssociateHandle(arg1,arg2);
36269 wxPyEndAllowThreads(__tstate);
36270 if (PyErr_Occurred()) SWIG_fail;
36271 }
36272 resultobj = SWIG_Py_Void();
36273 return resultobj;
36274 fail:
36275 return NULL;
36276 }
36277
36278
36279 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36280 PyObject *resultobj = 0;
36281 wxWindow *arg1 = (wxWindow *) 0 ;
36282 void *argp1 = 0 ;
36283 int res1 = 0 ;
36284 PyObject *swig_obj[1] ;
36285
36286 if (!args) SWIG_fail;
36287 swig_obj[0] = args;
36288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36289 if (!SWIG_IsOK(res1)) {
36290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36291 }
36292 arg1 = reinterpret_cast< wxWindow * >(argp1);
36293 {
36294 PyThreadState* __tstate = wxPyBeginAllowThreads();
36295 (arg1)->DissociateHandle();
36296 wxPyEndAllowThreads(__tstate);
36297 if (PyErr_Occurred()) SWIG_fail;
36298 }
36299 resultobj = SWIG_Py_Void();
36300 return resultobj;
36301 fail:
36302 return NULL;
36303 }
36304
36305
36306 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36307 PyObject *resultobj = 0;
36308 wxWindow *arg1 = (wxWindow *) 0 ;
36309 wxPaintEvent *arg2 = 0 ;
36310 void *argp1 = 0 ;
36311 int res1 = 0 ;
36312 void *argp2 = 0 ;
36313 int res2 = 0 ;
36314 PyObject * obj0 = 0 ;
36315 PyObject * obj1 = 0 ;
36316 char * kwnames[] = {
36317 (char *) "self",(char *) "event", NULL
36318 };
36319
36320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36322 if (!SWIG_IsOK(res1)) {
36323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36324 }
36325 arg1 = reinterpret_cast< wxWindow * >(argp1);
36326 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36327 if (!SWIG_IsOK(res2)) {
36328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36329 }
36330 if (!argp2) {
36331 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36332 }
36333 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36334 {
36335 PyThreadState* __tstate = wxPyBeginAllowThreads();
36336 (arg1)->OnPaint(*arg2);
36337 wxPyEndAllowThreads(__tstate);
36338 if (PyErr_Occurred()) SWIG_fail;
36339 }
36340 resultobj = SWIG_Py_Void();
36341 return resultobj;
36342 fail:
36343 return NULL;
36344 }
36345
36346
36347 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36348 PyObject *resultobj = 0;
36349 wxWindow *arg1 = (wxWindow *) 0 ;
36350 int arg2 ;
36351 bool result;
36352 void *argp1 = 0 ;
36353 int res1 = 0 ;
36354 int val2 ;
36355 int ecode2 = 0 ;
36356 PyObject * obj0 = 0 ;
36357 PyObject * obj1 = 0 ;
36358 char * kwnames[] = {
36359 (char *) "self",(char *) "orient", NULL
36360 };
36361
36362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36364 if (!SWIG_IsOK(res1)) {
36365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36366 }
36367 arg1 = reinterpret_cast< wxWindow * >(argp1);
36368 ecode2 = SWIG_AsVal_int(obj1, &val2);
36369 if (!SWIG_IsOK(ecode2)) {
36370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36371 }
36372 arg2 = static_cast< int >(val2);
36373 {
36374 PyThreadState* __tstate = wxPyBeginAllowThreads();
36375 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36376 wxPyEndAllowThreads(__tstate);
36377 if (PyErr_Occurred()) SWIG_fail;
36378 }
36379 {
36380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36381 }
36382 return resultobj;
36383 fail:
36384 return NULL;
36385 }
36386
36387
36388 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36389 PyObject *resultobj = 0;
36390 wxWindow *arg1 = (wxWindow *) 0 ;
36391 int arg2 ;
36392 int arg3 ;
36393 int arg4 ;
36394 int arg5 ;
36395 bool arg6 = (bool) true ;
36396 void *argp1 = 0 ;
36397 int res1 = 0 ;
36398 int val2 ;
36399 int ecode2 = 0 ;
36400 int val3 ;
36401 int ecode3 = 0 ;
36402 int val4 ;
36403 int ecode4 = 0 ;
36404 int val5 ;
36405 int ecode5 = 0 ;
36406 bool val6 ;
36407 int ecode6 = 0 ;
36408 PyObject * obj0 = 0 ;
36409 PyObject * obj1 = 0 ;
36410 PyObject * obj2 = 0 ;
36411 PyObject * obj3 = 0 ;
36412 PyObject * obj4 = 0 ;
36413 PyObject * obj5 = 0 ;
36414 char * kwnames[] = {
36415 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36416 };
36417
36418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36420 if (!SWIG_IsOK(res1)) {
36421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36422 }
36423 arg1 = reinterpret_cast< wxWindow * >(argp1);
36424 ecode2 = SWIG_AsVal_int(obj1, &val2);
36425 if (!SWIG_IsOK(ecode2)) {
36426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36427 }
36428 arg2 = static_cast< int >(val2);
36429 ecode3 = SWIG_AsVal_int(obj2, &val3);
36430 if (!SWIG_IsOK(ecode3)) {
36431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36432 }
36433 arg3 = static_cast< int >(val3);
36434 ecode4 = SWIG_AsVal_int(obj3, &val4);
36435 if (!SWIG_IsOK(ecode4)) {
36436 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36437 }
36438 arg4 = static_cast< int >(val4);
36439 ecode5 = SWIG_AsVal_int(obj4, &val5);
36440 if (!SWIG_IsOK(ecode5)) {
36441 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36442 }
36443 arg5 = static_cast< int >(val5);
36444 if (obj5) {
36445 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36446 if (!SWIG_IsOK(ecode6)) {
36447 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36448 }
36449 arg6 = static_cast< bool >(val6);
36450 }
36451 {
36452 PyThreadState* __tstate = wxPyBeginAllowThreads();
36453 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36454 wxPyEndAllowThreads(__tstate);
36455 if (PyErr_Occurred()) SWIG_fail;
36456 }
36457 resultobj = SWIG_Py_Void();
36458 return resultobj;
36459 fail:
36460 return NULL;
36461 }
36462
36463
36464 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36465 PyObject *resultobj = 0;
36466 wxWindow *arg1 = (wxWindow *) 0 ;
36467 int arg2 ;
36468 int arg3 ;
36469 bool arg4 = (bool) true ;
36470 void *argp1 = 0 ;
36471 int res1 = 0 ;
36472 int val2 ;
36473 int ecode2 = 0 ;
36474 int val3 ;
36475 int ecode3 = 0 ;
36476 bool val4 ;
36477 int ecode4 = 0 ;
36478 PyObject * obj0 = 0 ;
36479 PyObject * obj1 = 0 ;
36480 PyObject * obj2 = 0 ;
36481 PyObject * obj3 = 0 ;
36482 char * kwnames[] = {
36483 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36484 };
36485
36486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36488 if (!SWIG_IsOK(res1)) {
36489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36490 }
36491 arg1 = reinterpret_cast< wxWindow * >(argp1);
36492 ecode2 = SWIG_AsVal_int(obj1, &val2);
36493 if (!SWIG_IsOK(ecode2)) {
36494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36495 }
36496 arg2 = static_cast< int >(val2);
36497 ecode3 = SWIG_AsVal_int(obj2, &val3);
36498 if (!SWIG_IsOK(ecode3)) {
36499 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36500 }
36501 arg3 = static_cast< int >(val3);
36502 if (obj3) {
36503 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36504 if (!SWIG_IsOK(ecode4)) {
36505 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36506 }
36507 arg4 = static_cast< bool >(val4);
36508 }
36509 {
36510 PyThreadState* __tstate = wxPyBeginAllowThreads();
36511 (arg1)->SetScrollPos(arg2,arg3,arg4);
36512 wxPyEndAllowThreads(__tstate);
36513 if (PyErr_Occurred()) SWIG_fail;
36514 }
36515 resultobj = SWIG_Py_Void();
36516 return resultobj;
36517 fail:
36518 return NULL;
36519 }
36520
36521
36522 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36523 PyObject *resultobj = 0;
36524 wxWindow *arg1 = (wxWindow *) 0 ;
36525 int arg2 ;
36526 int result;
36527 void *argp1 = 0 ;
36528 int res1 = 0 ;
36529 int val2 ;
36530 int ecode2 = 0 ;
36531 PyObject * obj0 = 0 ;
36532 PyObject * obj1 = 0 ;
36533 char * kwnames[] = {
36534 (char *) "self",(char *) "orientation", NULL
36535 };
36536
36537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36539 if (!SWIG_IsOK(res1)) {
36540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36541 }
36542 arg1 = reinterpret_cast< wxWindow * >(argp1);
36543 ecode2 = SWIG_AsVal_int(obj1, &val2);
36544 if (!SWIG_IsOK(ecode2)) {
36545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36546 }
36547 arg2 = static_cast< int >(val2);
36548 {
36549 PyThreadState* __tstate = wxPyBeginAllowThreads();
36550 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36551 wxPyEndAllowThreads(__tstate);
36552 if (PyErr_Occurred()) SWIG_fail;
36553 }
36554 resultobj = SWIG_From_int(static_cast< int >(result));
36555 return resultobj;
36556 fail:
36557 return NULL;
36558 }
36559
36560
36561 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36562 PyObject *resultobj = 0;
36563 wxWindow *arg1 = (wxWindow *) 0 ;
36564 int arg2 ;
36565 int result;
36566 void *argp1 = 0 ;
36567 int res1 = 0 ;
36568 int val2 ;
36569 int ecode2 = 0 ;
36570 PyObject * obj0 = 0 ;
36571 PyObject * obj1 = 0 ;
36572 char * kwnames[] = {
36573 (char *) "self",(char *) "orientation", NULL
36574 };
36575
36576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36578 if (!SWIG_IsOK(res1)) {
36579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36580 }
36581 arg1 = reinterpret_cast< wxWindow * >(argp1);
36582 ecode2 = SWIG_AsVal_int(obj1, &val2);
36583 if (!SWIG_IsOK(ecode2)) {
36584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36585 }
36586 arg2 = static_cast< int >(val2);
36587 {
36588 PyThreadState* __tstate = wxPyBeginAllowThreads();
36589 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36590 wxPyEndAllowThreads(__tstate);
36591 if (PyErr_Occurred()) SWIG_fail;
36592 }
36593 resultobj = SWIG_From_int(static_cast< int >(result));
36594 return resultobj;
36595 fail:
36596 return NULL;
36597 }
36598
36599
36600 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36601 PyObject *resultobj = 0;
36602 wxWindow *arg1 = (wxWindow *) 0 ;
36603 int arg2 ;
36604 int result;
36605 void *argp1 = 0 ;
36606 int res1 = 0 ;
36607 int val2 ;
36608 int ecode2 = 0 ;
36609 PyObject * obj0 = 0 ;
36610 PyObject * obj1 = 0 ;
36611 char * kwnames[] = {
36612 (char *) "self",(char *) "orientation", NULL
36613 };
36614
36615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36617 if (!SWIG_IsOK(res1)) {
36618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36619 }
36620 arg1 = reinterpret_cast< wxWindow * >(argp1);
36621 ecode2 = SWIG_AsVal_int(obj1, &val2);
36622 if (!SWIG_IsOK(ecode2)) {
36623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36624 }
36625 arg2 = static_cast< int >(val2);
36626 {
36627 PyThreadState* __tstate = wxPyBeginAllowThreads();
36628 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36629 wxPyEndAllowThreads(__tstate);
36630 if (PyErr_Occurred()) SWIG_fail;
36631 }
36632 resultobj = SWIG_From_int(static_cast< int >(result));
36633 return resultobj;
36634 fail:
36635 return NULL;
36636 }
36637
36638
36639 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36640 PyObject *resultobj = 0;
36641 wxWindow *arg1 = (wxWindow *) 0 ;
36642 int arg2 ;
36643 int arg3 ;
36644 wxRect *arg4 = (wxRect *) NULL ;
36645 void *argp1 = 0 ;
36646 int res1 = 0 ;
36647 int val2 ;
36648 int ecode2 = 0 ;
36649 int val3 ;
36650 int ecode3 = 0 ;
36651 void *argp4 = 0 ;
36652 int res4 = 0 ;
36653 PyObject * obj0 = 0 ;
36654 PyObject * obj1 = 0 ;
36655 PyObject * obj2 = 0 ;
36656 PyObject * obj3 = 0 ;
36657 char * kwnames[] = {
36658 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36659 };
36660
36661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36663 if (!SWIG_IsOK(res1)) {
36664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36665 }
36666 arg1 = reinterpret_cast< wxWindow * >(argp1);
36667 ecode2 = SWIG_AsVal_int(obj1, &val2);
36668 if (!SWIG_IsOK(ecode2)) {
36669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36670 }
36671 arg2 = static_cast< int >(val2);
36672 ecode3 = SWIG_AsVal_int(obj2, &val3);
36673 if (!SWIG_IsOK(ecode3)) {
36674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36675 }
36676 arg3 = static_cast< int >(val3);
36677 if (obj3) {
36678 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36679 if (!SWIG_IsOK(res4)) {
36680 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36681 }
36682 arg4 = reinterpret_cast< wxRect * >(argp4);
36683 }
36684 {
36685 PyThreadState* __tstate = wxPyBeginAllowThreads();
36686 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36687 wxPyEndAllowThreads(__tstate);
36688 if (PyErr_Occurred()) SWIG_fail;
36689 }
36690 resultobj = SWIG_Py_Void();
36691 return resultobj;
36692 fail:
36693 return NULL;
36694 }
36695
36696
36697 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36698 PyObject *resultobj = 0;
36699 wxWindow *arg1 = (wxWindow *) 0 ;
36700 int arg2 ;
36701 bool result;
36702 void *argp1 = 0 ;
36703 int res1 = 0 ;
36704 int val2 ;
36705 int ecode2 = 0 ;
36706 PyObject * obj0 = 0 ;
36707 PyObject * obj1 = 0 ;
36708 char * kwnames[] = {
36709 (char *) "self",(char *) "lines", NULL
36710 };
36711
36712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36714 if (!SWIG_IsOK(res1)) {
36715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36716 }
36717 arg1 = reinterpret_cast< wxWindow * >(argp1);
36718 ecode2 = SWIG_AsVal_int(obj1, &val2);
36719 if (!SWIG_IsOK(ecode2)) {
36720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36721 }
36722 arg2 = static_cast< int >(val2);
36723 {
36724 PyThreadState* __tstate = wxPyBeginAllowThreads();
36725 result = (bool)(arg1)->ScrollLines(arg2);
36726 wxPyEndAllowThreads(__tstate);
36727 if (PyErr_Occurred()) SWIG_fail;
36728 }
36729 {
36730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36731 }
36732 return resultobj;
36733 fail:
36734 return NULL;
36735 }
36736
36737
36738 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36739 PyObject *resultobj = 0;
36740 wxWindow *arg1 = (wxWindow *) 0 ;
36741 int arg2 ;
36742 bool result;
36743 void *argp1 = 0 ;
36744 int res1 = 0 ;
36745 int val2 ;
36746 int ecode2 = 0 ;
36747 PyObject * obj0 = 0 ;
36748 PyObject * obj1 = 0 ;
36749 char * kwnames[] = {
36750 (char *) "self",(char *) "pages", NULL
36751 };
36752
36753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36755 if (!SWIG_IsOK(res1)) {
36756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36757 }
36758 arg1 = reinterpret_cast< wxWindow * >(argp1);
36759 ecode2 = SWIG_AsVal_int(obj1, &val2);
36760 if (!SWIG_IsOK(ecode2)) {
36761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36762 }
36763 arg2 = static_cast< int >(val2);
36764 {
36765 PyThreadState* __tstate = wxPyBeginAllowThreads();
36766 result = (bool)(arg1)->ScrollPages(arg2);
36767 wxPyEndAllowThreads(__tstate);
36768 if (PyErr_Occurred()) SWIG_fail;
36769 }
36770 {
36771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36772 }
36773 return resultobj;
36774 fail:
36775 return NULL;
36776 }
36777
36778
36779 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36780 PyObject *resultobj = 0;
36781 wxWindow *arg1 = (wxWindow *) 0 ;
36782 bool result;
36783 void *argp1 = 0 ;
36784 int res1 = 0 ;
36785 PyObject *swig_obj[1] ;
36786
36787 if (!args) SWIG_fail;
36788 swig_obj[0] = args;
36789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36790 if (!SWIG_IsOK(res1)) {
36791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36792 }
36793 arg1 = reinterpret_cast< wxWindow * >(argp1);
36794 {
36795 PyThreadState* __tstate = wxPyBeginAllowThreads();
36796 result = (bool)(arg1)->LineUp();
36797 wxPyEndAllowThreads(__tstate);
36798 if (PyErr_Occurred()) SWIG_fail;
36799 }
36800 {
36801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36802 }
36803 return resultobj;
36804 fail:
36805 return NULL;
36806 }
36807
36808
36809 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36810 PyObject *resultobj = 0;
36811 wxWindow *arg1 = (wxWindow *) 0 ;
36812 bool result;
36813 void *argp1 = 0 ;
36814 int res1 = 0 ;
36815 PyObject *swig_obj[1] ;
36816
36817 if (!args) SWIG_fail;
36818 swig_obj[0] = args;
36819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36820 if (!SWIG_IsOK(res1)) {
36821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36822 }
36823 arg1 = reinterpret_cast< wxWindow * >(argp1);
36824 {
36825 PyThreadState* __tstate = wxPyBeginAllowThreads();
36826 result = (bool)(arg1)->LineDown();
36827 wxPyEndAllowThreads(__tstate);
36828 if (PyErr_Occurred()) SWIG_fail;
36829 }
36830 {
36831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36832 }
36833 return resultobj;
36834 fail:
36835 return NULL;
36836 }
36837
36838
36839 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36840 PyObject *resultobj = 0;
36841 wxWindow *arg1 = (wxWindow *) 0 ;
36842 bool result;
36843 void *argp1 = 0 ;
36844 int res1 = 0 ;
36845 PyObject *swig_obj[1] ;
36846
36847 if (!args) SWIG_fail;
36848 swig_obj[0] = args;
36849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36850 if (!SWIG_IsOK(res1)) {
36851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36852 }
36853 arg1 = reinterpret_cast< wxWindow * >(argp1);
36854 {
36855 PyThreadState* __tstate = wxPyBeginAllowThreads();
36856 result = (bool)(arg1)->PageUp();
36857 wxPyEndAllowThreads(__tstate);
36858 if (PyErr_Occurred()) SWIG_fail;
36859 }
36860 {
36861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36862 }
36863 return resultobj;
36864 fail:
36865 return NULL;
36866 }
36867
36868
36869 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36870 PyObject *resultobj = 0;
36871 wxWindow *arg1 = (wxWindow *) 0 ;
36872 bool result;
36873 void *argp1 = 0 ;
36874 int res1 = 0 ;
36875 PyObject *swig_obj[1] ;
36876
36877 if (!args) SWIG_fail;
36878 swig_obj[0] = args;
36879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36880 if (!SWIG_IsOK(res1)) {
36881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36882 }
36883 arg1 = reinterpret_cast< wxWindow * >(argp1);
36884 {
36885 PyThreadState* __tstate = wxPyBeginAllowThreads();
36886 result = (bool)(arg1)->PageDown();
36887 wxPyEndAllowThreads(__tstate);
36888 if (PyErr_Occurred()) SWIG_fail;
36889 }
36890 {
36891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36892 }
36893 return resultobj;
36894 fail:
36895 return NULL;
36896 }
36897
36898
36899 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36900 PyObject *resultobj = 0;
36901 wxWindow *arg1 = (wxWindow *) 0 ;
36902 wxString *arg2 = 0 ;
36903 void *argp1 = 0 ;
36904 int res1 = 0 ;
36905 bool temp2 = false ;
36906 PyObject * obj0 = 0 ;
36907 PyObject * obj1 = 0 ;
36908 char * kwnames[] = {
36909 (char *) "self",(char *) "text", NULL
36910 };
36911
36912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36914 if (!SWIG_IsOK(res1)) {
36915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36916 }
36917 arg1 = reinterpret_cast< wxWindow * >(argp1);
36918 {
36919 arg2 = wxString_in_helper(obj1);
36920 if (arg2 == NULL) SWIG_fail;
36921 temp2 = true;
36922 }
36923 {
36924 PyThreadState* __tstate = wxPyBeginAllowThreads();
36925 (arg1)->SetHelpText((wxString const &)*arg2);
36926 wxPyEndAllowThreads(__tstate);
36927 if (PyErr_Occurred()) SWIG_fail;
36928 }
36929 resultobj = SWIG_Py_Void();
36930 {
36931 if (temp2)
36932 delete arg2;
36933 }
36934 return resultobj;
36935 fail:
36936 {
36937 if (temp2)
36938 delete arg2;
36939 }
36940 return NULL;
36941 }
36942
36943
36944 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36945 PyObject *resultobj = 0;
36946 wxWindow *arg1 = (wxWindow *) 0 ;
36947 wxString *arg2 = 0 ;
36948 void *argp1 = 0 ;
36949 int res1 = 0 ;
36950 bool temp2 = false ;
36951 PyObject * obj0 = 0 ;
36952 PyObject * obj1 = 0 ;
36953 char * kwnames[] = {
36954 (char *) "self",(char *) "text", NULL
36955 };
36956
36957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36959 if (!SWIG_IsOK(res1)) {
36960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36961 }
36962 arg1 = reinterpret_cast< wxWindow * >(argp1);
36963 {
36964 arg2 = wxString_in_helper(obj1);
36965 if (arg2 == NULL) SWIG_fail;
36966 temp2 = true;
36967 }
36968 {
36969 PyThreadState* __tstate = wxPyBeginAllowThreads();
36970 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36971 wxPyEndAllowThreads(__tstate);
36972 if (PyErr_Occurred()) SWIG_fail;
36973 }
36974 resultobj = SWIG_Py_Void();
36975 {
36976 if (temp2)
36977 delete arg2;
36978 }
36979 return resultobj;
36980 fail:
36981 {
36982 if (temp2)
36983 delete arg2;
36984 }
36985 return NULL;
36986 }
36987
36988
36989 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36990 PyObject *resultobj = 0;
36991 wxWindow *arg1 = (wxWindow *) 0 ;
36992 wxPoint *arg2 = 0 ;
36993 wxHelpEvent::Origin arg3 ;
36994 wxString result;
36995 void *argp1 = 0 ;
36996 int res1 = 0 ;
36997 wxPoint temp2 ;
36998 void *argp3 ;
36999 int res3 = 0 ;
37000 PyObject * obj0 = 0 ;
37001 PyObject * obj1 = 0 ;
37002 PyObject * obj2 = 0 ;
37003 char * kwnames[] = {
37004 (char *) "self",(char *) "pt",(char *) "origin", NULL
37005 };
37006
37007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37009 if (!SWIG_IsOK(res1)) {
37010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37011 }
37012 arg1 = reinterpret_cast< wxWindow * >(argp1);
37013 {
37014 arg2 = &temp2;
37015 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37016 }
37017 {
37018 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37019 if (!SWIG_IsOK(res3)) {
37020 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37021 }
37022 if (!argp3) {
37023 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37024 } else {
37025 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37026 arg3 = *temp;
37027 if (SWIG_IsNewObj(res3)) delete temp;
37028 }
37029 }
37030 {
37031 PyThreadState* __tstate = wxPyBeginAllowThreads();
37032 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37033 wxPyEndAllowThreads(__tstate);
37034 if (PyErr_Occurred()) SWIG_fail;
37035 }
37036 {
37037 #if wxUSE_UNICODE
37038 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37039 #else
37040 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37041 #endif
37042 }
37043 return resultobj;
37044 fail:
37045 return NULL;
37046 }
37047
37048
37049 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37050 PyObject *resultobj = 0;
37051 wxWindow *arg1 = (wxWindow *) 0 ;
37052 wxString result;
37053 void *argp1 = 0 ;
37054 int res1 = 0 ;
37055 PyObject *swig_obj[1] ;
37056
37057 if (!args) SWIG_fail;
37058 swig_obj[0] = args;
37059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37060 if (!SWIG_IsOK(res1)) {
37061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37062 }
37063 arg1 = reinterpret_cast< wxWindow * >(argp1);
37064 {
37065 PyThreadState* __tstate = wxPyBeginAllowThreads();
37066 result = ((wxWindow const *)arg1)->GetHelpText();
37067 wxPyEndAllowThreads(__tstate);
37068 if (PyErr_Occurred()) SWIG_fail;
37069 }
37070 {
37071 #if wxUSE_UNICODE
37072 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37073 #else
37074 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37075 #endif
37076 }
37077 return resultobj;
37078 fail:
37079 return NULL;
37080 }
37081
37082
37083 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37084 PyObject *resultobj = 0;
37085 wxWindow *arg1 = (wxWindow *) 0 ;
37086 wxString *arg2 = 0 ;
37087 void *argp1 = 0 ;
37088 int res1 = 0 ;
37089 bool temp2 = false ;
37090 PyObject * obj0 = 0 ;
37091 PyObject * obj1 = 0 ;
37092 char * kwnames[] = {
37093 (char *) "self",(char *) "tip", NULL
37094 };
37095
37096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37098 if (!SWIG_IsOK(res1)) {
37099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37100 }
37101 arg1 = reinterpret_cast< wxWindow * >(argp1);
37102 {
37103 arg2 = wxString_in_helper(obj1);
37104 if (arg2 == NULL) SWIG_fail;
37105 temp2 = true;
37106 }
37107 {
37108 PyThreadState* __tstate = wxPyBeginAllowThreads();
37109 (arg1)->SetToolTip((wxString const &)*arg2);
37110 wxPyEndAllowThreads(__tstate);
37111 if (PyErr_Occurred()) SWIG_fail;
37112 }
37113 resultobj = SWIG_Py_Void();
37114 {
37115 if (temp2)
37116 delete arg2;
37117 }
37118 return resultobj;
37119 fail:
37120 {
37121 if (temp2)
37122 delete arg2;
37123 }
37124 return NULL;
37125 }
37126
37127
37128 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37129 PyObject *resultobj = 0;
37130 wxWindow *arg1 = (wxWindow *) 0 ;
37131 wxToolTip *arg2 = (wxToolTip *) 0 ;
37132 void *argp1 = 0 ;
37133 int res1 = 0 ;
37134 int res2 = 0 ;
37135 PyObject * obj0 = 0 ;
37136 PyObject * obj1 = 0 ;
37137 char * kwnames[] = {
37138 (char *) "self",(char *) "tip", NULL
37139 };
37140
37141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37143 if (!SWIG_IsOK(res1)) {
37144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37145 }
37146 arg1 = reinterpret_cast< wxWindow * >(argp1);
37147 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37148 if (!SWIG_IsOK(res2)) {
37149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37150 }
37151 {
37152 PyThreadState* __tstate = wxPyBeginAllowThreads();
37153 (arg1)->SetToolTip(arg2);
37154 wxPyEndAllowThreads(__tstate);
37155 if (PyErr_Occurred()) SWIG_fail;
37156 }
37157 resultobj = SWIG_Py_Void();
37158 return resultobj;
37159 fail:
37160 return NULL;
37161 }
37162
37163
37164 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37165 PyObject *resultobj = 0;
37166 wxWindow *arg1 = (wxWindow *) 0 ;
37167 wxToolTip *result = 0 ;
37168 void *argp1 = 0 ;
37169 int res1 = 0 ;
37170 PyObject *swig_obj[1] ;
37171
37172 if (!args) SWIG_fail;
37173 swig_obj[0] = args;
37174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37175 if (!SWIG_IsOK(res1)) {
37176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37177 }
37178 arg1 = reinterpret_cast< wxWindow * >(argp1);
37179 {
37180 PyThreadState* __tstate = wxPyBeginAllowThreads();
37181 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37182 wxPyEndAllowThreads(__tstate);
37183 if (PyErr_Occurred()) SWIG_fail;
37184 }
37185 {
37186 resultobj = wxPyMake_wxObject(result, (bool)0);
37187 }
37188 return resultobj;
37189 fail:
37190 return NULL;
37191 }
37192
37193
37194 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37195 PyObject *resultobj = 0;
37196 wxWindow *arg1 = (wxWindow *) 0 ;
37197 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37198 void *argp1 = 0 ;
37199 int res1 = 0 ;
37200 int res2 = 0 ;
37201 PyObject * obj0 = 0 ;
37202 PyObject * obj1 = 0 ;
37203 char * kwnames[] = {
37204 (char *) "self",(char *) "dropTarget", NULL
37205 };
37206
37207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37209 if (!SWIG_IsOK(res1)) {
37210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37211 }
37212 arg1 = reinterpret_cast< wxWindow * >(argp1);
37213 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37214 if (!SWIG_IsOK(res2)) {
37215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37216 }
37217 {
37218 PyThreadState* __tstate = wxPyBeginAllowThreads();
37219 (arg1)->SetDropTarget(arg2);
37220 wxPyEndAllowThreads(__tstate);
37221 if (PyErr_Occurred()) SWIG_fail;
37222 }
37223 resultobj = SWIG_Py_Void();
37224 return resultobj;
37225 fail:
37226 return NULL;
37227 }
37228
37229
37230 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37231 PyObject *resultobj = 0;
37232 wxWindow *arg1 = (wxWindow *) 0 ;
37233 wxPyDropTarget *result = 0 ;
37234 void *argp1 = 0 ;
37235 int res1 = 0 ;
37236 PyObject *swig_obj[1] ;
37237
37238 if (!args) SWIG_fail;
37239 swig_obj[0] = args;
37240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37241 if (!SWIG_IsOK(res1)) {
37242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37243 }
37244 arg1 = reinterpret_cast< wxWindow * >(argp1);
37245 {
37246 PyThreadState* __tstate = wxPyBeginAllowThreads();
37247 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37248 wxPyEndAllowThreads(__tstate);
37249 if (PyErr_Occurred()) SWIG_fail;
37250 }
37251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37252 return resultobj;
37253 fail:
37254 return NULL;
37255 }
37256
37257
37258 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37259 PyObject *resultobj = 0;
37260 wxWindow *arg1 = (wxWindow *) 0 ;
37261 bool arg2 ;
37262 void *argp1 = 0 ;
37263 int res1 = 0 ;
37264 bool val2 ;
37265 int ecode2 = 0 ;
37266 PyObject * obj0 = 0 ;
37267 PyObject * obj1 = 0 ;
37268 char * kwnames[] = {
37269 (char *) "self",(char *) "accept", NULL
37270 };
37271
37272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37274 if (!SWIG_IsOK(res1)) {
37275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37276 }
37277 arg1 = reinterpret_cast< wxWindow * >(argp1);
37278 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37279 if (!SWIG_IsOK(ecode2)) {
37280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37281 }
37282 arg2 = static_cast< bool >(val2);
37283 {
37284 PyThreadState* __tstate = wxPyBeginAllowThreads();
37285 (arg1)->DragAcceptFiles(arg2);
37286 wxPyEndAllowThreads(__tstate);
37287 if (PyErr_Occurred()) SWIG_fail;
37288 }
37289 resultobj = SWIG_Py_Void();
37290 return resultobj;
37291 fail:
37292 return NULL;
37293 }
37294
37295
37296 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37297 PyObject *resultobj = 0;
37298 wxWindow *arg1 = (wxWindow *) 0 ;
37299 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37300 void *argp1 = 0 ;
37301 int res1 = 0 ;
37302 int res2 = 0 ;
37303 PyObject * obj0 = 0 ;
37304 PyObject * obj1 = 0 ;
37305 char * kwnames[] = {
37306 (char *) "self",(char *) "constraints", NULL
37307 };
37308
37309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37311 if (!SWIG_IsOK(res1)) {
37312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37313 }
37314 arg1 = reinterpret_cast< wxWindow * >(argp1);
37315 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37316 if (!SWIG_IsOK(res2)) {
37317 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37318 }
37319 {
37320 PyThreadState* __tstate = wxPyBeginAllowThreads();
37321 (arg1)->SetConstraints(arg2);
37322 wxPyEndAllowThreads(__tstate);
37323 if (PyErr_Occurred()) SWIG_fail;
37324 }
37325 resultobj = SWIG_Py_Void();
37326 return resultobj;
37327 fail:
37328 return NULL;
37329 }
37330
37331
37332 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37333 PyObject *resultobj = 0;
37334 wxWindow *arg1 = (wxWindow *) 0 ;
37335 wxLayoutConstraints *result = 0 ;
37336 void *argp1 = 0 ;
37337 int res1 = 0 ;
37338 PyObject *swig_obj[1] ;
37339
37340 if (!args) SWIG_fail;
37341 swig_obj[0] = args;
37342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37343 if (!SWIG_IsOK(res1)) {
37344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37345 }
37346 arg1 = reinterpret_cast< wxWindow * >(argp1);
37347 {
37348 PyThreadState* __tstate = wxPyBeginAllowThreads();
37349 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37350 wxPyEndAllowThreads(__tstate);
37351 if (PyErr_Occurred()) SWIG_fail;
37352 }
37353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37354 return resultobj;
37355 fail:
37356 return NULL;
37357 }
37358
37359
37360 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37361 PyObject *resultobj = 0;
37362 wxWindow *arg1 = (wxWindow *) 0 ;
37363 bool arg2 ;
37364 void *argp1 = 0 ;
37365 int res1 = 0 ;
37366 bool val2 ;
37367 int ecode2 = 0 ;
37368 PyObject * obj0 = 0 ;
37369 PyObject * obj1 = 0 ;
37370 char * kwnames[] = {
37371 (char *) "self",(char *) "autoLayout", NULL
37372 };
37373
37374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37376 if (!SWIG_IsOK(res1)) {
37377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37378 }
37379 arg1 = reinterpret_cast< wxWindow * >(argp1);
37380 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37381 if (!SWIG_IsOK(ecode2)) {
37382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37383 }
37384 arg2 = static_cast< bool >(val2);
37385 {
37386 PyThreadState* __tstate = wxPyBeginAllowThreads();
37387 (arg1)->SetAutoLayout(arg2);
37388 wxPyEndAllowThreads(__tstate);
37389 if (PyErr_Occurred()) SWIG_fail;
37390 }
37391 resultobj = SWIG_Py_Void();
37392 return resultobj;
37393 fail:
37394 return NULL;
37395 }
37396
37397
37398 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37399 PyObject *resultobj = 0;
37400 wxWindow *arg1 = (wxWindow *) 0 ;
37401 bool result;
37402 void *argp1 = 0 ;
37403 int res1 = 0 ;
37404 PyObject *swig_obj[1] ;
37405
37406 if (!args) SWIG_fail;
37407 swig_obj[0] = args;
37408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37409 if (!SWIG_IsOK(res1)) {
37410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37411 }
37412 arg1 = reinterpret_cast< wxWindow * >(argp1);
37413 {
37414 PyThreadState* __tstate = wxPyBeginAllowThreads();
37415 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37416 wxPyEndAllowThreads(__tstate);
37417 if (PyErr_Occurred()) SWIG_fail;
37418 }
37419 {
37420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37421 }
37422 return resultobj;
37423 fail:
37424 return NULL;
37425 }
37426
37427
37428 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37429 PyObject *resultobj = 0;
37430 wxWindow *arg1 = (wxWindow *) 0 ;
37431 bool result;
37432 void *argp1 = 0 ;
37433 int res1 = 0 ;
37434 PyObject *swig_obj[1] ;
37435
37436 if (!args) SWIG_fail;
37437 swig_obj[0] = args;
37438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37439 if (!SWIG_IsOK(res1)) {
37440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37441 }
37442 arg1 = reinterpret_cast< wxWindow * >(argp1);
37443 {
37444 PyThreadState* __tstate = wxPyBeginAllowThreads();
37445 result = (bool)(arg1)->Layout();
37446 wxPyEndAllowThreads(__tstate);
37447 if (PyErr_Occurred()) SWIG_fail;
37448 }
37449 {
37450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37451 }
37452 return resultobj;
37453 fail:
37454 return NULL;
37455 }
37456
37457
37458 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37459 PyObject *resultobj = 0;
37460 wxWindow *arg1 = (wxWindow *) 0 ;
37461 wxSizer *arg2 = (wxSizer *) 0 ;
37462 bool arg3 = (bool) true ;
37463 void *argp1 = 0 ;
37464 int res1 = 0 ;
37465 int res2 = 0 ;
37466 bool val3 ;
37467 int ecode3 = 0 ;
37468 PyObject * obj0 = 0 ;
37469 PyObject * obj1 = 0 ;
37470 PyObject * obj2 = 0 ;
37471 char * kwnames[] = {
37472 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37473 };
37474
37475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37477 if (!SWIG_IsOK(res1)) {
37478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37479 }
37480 arg1 = reinterpret_cast< wxWindow * >(argp1);
37481 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37482 if (!SWIG_IsOK(res2)) {
37483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37484 }
37485 if (obj2) {
37486 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37487 if (!SWIG_IsOK(ecode3)) {
37488 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37489 }
37490 arg3 = static_cast< bool >(val3);
37491 }
37492 {
37493 PyThreadState* __tstate = wxPyBeginAllowThreads();
37494 (arg1)->SetSizer(arg2,arg3);
37495 wxPyEndAllowThreads(__tstate);
37496 if (PyErr_Occurred()) SWIG_fail;
37497 }
37498 resultobj = SWIG_Py_Void();
37499 return resultobj;
37500 fail:
37501 return NULL;
37502 }
37503
37504
37505 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37506 PyObject *resultobj = 0;
37507 wxWindow *arg1 = (wxWindow *) 0 ;
37508 wxSizer *arg2 = (wxSizer *) 0 ;
37509 bool arg3 = (bool) true ;
37510 void *argp1 = 0 ;
37511 int res1 = 0 ;
37512 int res2 = 0 ;
37513 bool val3 ;
37514 int ecode3 = 0 ;
37515 PyObject * obj0 = 0 ;
37516 PyObject * obj1 = 0 ;
37517 PyObject * obj2 = 0 ;
37518 char * kwnames[] = {
37519 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37520 };
37521
37522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37524 if (!SWIG_IsOK(res1)) {
37525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37526 }
37527 arg1 = reinterpret_cast< wxWindow * >(argp1);
37528 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37529 if (!SWIG_IsOK(res2)) {
37530 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37531 }
37532 if (obj2) {
37533 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37534 if (!SWIG_IsOK(ecode3)) {
37535 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37536 }
37537 arg3 = static_cast< bool >(val3);
37538 }
37539 {
37540 PyThreadState* __tstate = wxPyBeginAllowThreads();
37541 (arg1)->SetSizerAndFit(arg2,arg3);
37542 wxPyEndAllowThreads(__tstate);
37543 if (PyErr_Occurred()) SWIG_fail;
37544 }
37545 resultobj = SWIG_Py_Void();
37546 return resultobj;
37547 fail:
37548 return NULL;
37549 }
37550
37551
37552 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37553 PyObject *resultobj = 0;
37554 wxWindow *arg1 = (wxWindow *) 0 ;
37555 wxSizer *result = 0 ;
37556 void *argp1 = 0 ;
37557 int res1 = 0 ;
37558 PyObject *swig_obj[1] ;
37559
37560 if (!args) SWIG_fail;
37561 swig_obj[0] = args;
37562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37563 if (!SWIG_IsOK(res1)) {
37564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37565 }
37566 arg1 = reinterpret_cast< wxWindow * >(argp1);
37567 {
37568 PyThreadState* __tstate = wxPyBeginAllowThreads();
37569 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37570 wxPyEndAllowThreads(__tstate);
37571 if (PyErr_Occurred()) SWIG_fail;
37572 }
37573 {
37574 resultobj = wxPyMake_wxObject(result, (bool)0);
37575 }
37576 return resultobj;
37577 fail:
37578 return NULL;
37579 }
37580
37581
37582 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37583 PyObject *resultobj = 0;
37584 wxWindow *arg1 = (wxWindow *) 0 ;
37585 wxSizer *arg2 = (wxSizer *) 0 ;
37586 void *argp1 = 0 ;
37587 int res1 = 0 ;
37588 void *argp2 = 0 ;
37589 int res2 = 0 ;
37590 PyObject * obj0 = 0 ;
37591 PyObject * obj1 = 0 ;
37592 char * kwnames[] = {
37593 (char *) "self",(char *) "sizer", NULL
37594 };
37595
37596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37598 if (!SWIG_IsOK(res1)) {
37599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37600 }
37601 arg1 = reinterpret_cast< wxWindow * >(argp1);
37602 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37603 if (!SWIG_IsOK(res2)) {
37604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37605 }
37606 arg2 = reinterpret_cast< wxSizer * >(argp2);
37607 {
37608 PyThreadState* __tstate = wxPyBeginAllowThreads();
37609 (arg1)->SetContainingSizer(arg2);
37610 wxPyEndAllowThreads(__tstate);
37611 if (PyErr_Occurred()) SWIG_fail;
37612 }
37613 resultobj = SWIG_Py_Void();
37614 return resultobj;
37615 fail:
37616 return NULL;
37617 }
37618
37619
37620 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37621 PyObject *resultobj = 0;
37622 wxWindow *arg1 = (wxWindow *) 0 ;
37623 wxSizer *result = 0 ;
37624 void *argp1 = 0 ;
37625 int res1 = 0 ;
37626 PyObject *swig_obj[1] ;
37627
37628 if (!args) SWIG_fail;
37629 swig_obj[0] = args;
37630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37631 if (!SWIG_IsOK(res1)) {
37632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37633 }
37634 arg1 = reinterpret_cast< wxWindow * >(argp1);
37635 {
37636 PyThreadState* __tstate = wxPyBeginAllowThreads();
37637 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37638 wxPyEndAllowThreads(__tstate);
37639 if (PyErr_Occurred()) SWIG_fail;
37640 }
37641 {
37642 resultobj = wxPyMake_wxObject(result, (bool)0);
37643 }
37644 return resultobj;
37645 fail:
37646 return NULL;
37647 }
37648
37649
37650 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37651 PyObject *resultobj = 0;
37652 wxWindow *arg1 = (wxWindow *) 0 ;
37653 void *argp1 = 0 ;
37654 int res1 = 0 ;
37655 PyObject *swig_obj[1] ;
37656
37657 if (!args) SWIG_fail;
37658 swig_obj[0] = args;
37659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37660 if (!SWIG_IsOK(res1)) {
37661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37662 }
37663 arg1 = reinterpret_cast< wxWindow * >(argp1);
37664 {
37665 PyThreadState* __tstate = wxPyBeginAllowThreads();
37666 (arg1)->InheritAttributes();
37667 wxPyEndAllowThreads(__tstate);
37668 if (PyErr_Occurred()) SWIG_fail;
37669 }
37670 resultobj = SWIG_Py_Void();
37671 return resultobj;
37672 fail:
37673 return NULL;
37674 }
37675
37676
37677 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37678 PyObject *resultobj = 0;
37679 wxWindow *arg1 = (wxWindow *) 0 ;
37680 bool result;
37681 void *argp1 = 0 ;
37682 int res1 = 0 ;
37683 PyObject *swig_obj[1] ;
37684
37685 if (!args) SWIG_fail;
37686 swig_obj[0] = args;
37687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37688 if (!SWIG_IsOK(res1)) {
37689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37690 }
37691 arg1 = reinterpret_cast< wxWindow * >(argp1);
37692 {
37693 PyThreadState* __tstate = wxPyBeginAllowThreads();
37694 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37695 wxPyEndAllowThreads(__tstate);
37696 if (PyErr_Occurred()) SWIG_fail;
37697 }
37698 {
37699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37700 }
37701 return resultobj;
37702 fail:
37703 return NULL;
37704 }
37705
37706
37707 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37708 PyObject *obj;
37709 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37710 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37711 return SWIG_Py_Void();
37712 }
37713
37714 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37715 return SWIG_Python_InitShadowInstance(args);
37716 }
37717
37718 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37719 PyObject *resultobj = 0;
37720 long arg1 ;
37721 wxWindow *arg2 = (wxWindow *) NULL ;
37722 wxWindow *result = 0 ;
37723 long val1 ;
37724 int ecode1 = 0 ;
37725 void *argp2 = 0 ;
37726 int res2 = 0 ;
37727 PyObject * obj0 = 0 ;
37728 PyObject * obj1 = 0 ;
37729 char * kwnames[] = {
37730 (char *) "id",(char *) "parent", NULL
37731 };
37732
37733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37734 ecode1 = SWIG_AsVal_long(obj0, &val1);
37735 if (!SWIG_IsOK(ecode1)) {
37736 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37737 }
37738 arg1 = static_cast< long >(val1);
37739 if (obj1) {
37740 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37741 if (!SWIG_IsOK(res2)) {
37742 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37743 }
37744 arg2 = reinterpret_cast< wxWindow * >(argp2);
37745 }
37746 {
37747 if (!wxPyCheckForApp()) SWIG_fail;
37748 PyThreadState* __tstate = wxPyBeginAllowThreads();
37749 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37750 wxPyEndAllowThreads(__tstate);
37751 if (PyErr_Occurred()) SWIG_fail;
37752 }
37753 {
37754 resultobj = wxPyMake_wxObject(result, 0);
37755 }
37756 return resultobj;
37757 fail:
37758 return NULL;
37759 }
37760
37761
37762 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37763 PyObject *resultobj = 0;
37764 wxString *arg1 = 0 ;
37765 wxWindow *arg2 = (wxWindow *) NULL ;
37766 wxWindow *result = 0 ;
37767 bool temp1 = false ;
37768 void *argp2 = 0 ;
37769 int res2 = 0 ;
37770 PyObject * obj0 = 0 ;
37771 PyObject * obj1 = 0 ;
37772 char * kwnames[] = {
37773 (char *) "name",(char *) "parent", NULL
37774 };
37775
37776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37777 {
37778 arg1 = wxString_in_helper(obj0);
37779 if (arg1 == NULL) SWIG_fail;
37780 temp1 = true;
37781 }
37782 if (obj1) {
37783 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37784 if (!SWIG_IsOK(res2)) {
37785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37786 }
37787 arg2 = reinterpret_cast< wxWindow * >(argp2);
37788 }
37789 {
37790 if (!wxPyCheckForApp()) SWIG_fail;
37791 PyThreadState* __tstate = wxPyBeginAllowThreads();
37792 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37793 wxPyEndAllowThreads(__tstate);
37794 if (PyErr_Occurred()) SWIG_fail;
37795 }
37796 {
37797 resultobj = wxPyMake_wxObject(result, 0);
37798 }
37799 {
37800 if (temp1)
37801 delete arg1;
37802 }
37803 return resultobj;
37804 fail:
37805 {
37806 if (temp1)
37807 delete arg1;
37808 }
37809 return NULL;
37810 }
37811
37812
37813 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37814 PyObject *resultobj = 0;
37815 wxString *arg1 = 0 ;
37816 wxWindow *arg2 = (wxWindow *) NULL ;
37817 wxWindow *result = 0 ;
37818 bool temp1 = false ;
37819 void *argp2 = 0 ;
37820 int res2 = 0 ;
37821 PyObject * obj0 = 0 ;
37822 PyObject * obj1 = 0 ;
37823 char * kwnames[] = {
37824 (char *) "label",(char *) "parent", NULL
37825 };
37826
37827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37828 {
37829 arg1 = wxString_in_helper(obj0);
37830 if (arg1 == NULL) SWIG_fail;
37831 temp1 = true;
37832 }
37833 if (obj1) {
37834 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37835 if (!SWIG_IsOK(res2)) {
37836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37837 }
37838 arg2 = reinterpret_cast< wxWindow * >(argp2);
37839 }
37840 {
37841 if (!wxPyCheckForApp()) SWIG_fail;
37842 PyThreadState* __tstate = wxPyBeginAllowThreads();
37843 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37844 wxPyEndAllowThreads(__tstate);
37845 if (PyErr_Occurred()) SWIG_fail;
37846 }
37847 {
37848 resultobj = wxPyMake_wxObject(result, 0);
37849 }
37850 {
37851 if (temp1)
37852 delete arg1;
37853 }
37854 return resultobj;
37855 fail:
37856 {
37857 if (temp1)
37858 delete arg1;
37859 }
37860 return NULL;
37861 }
37862
37863
37864 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37865 PyObject *resultobj = 0;
37866 wxWindow *arg1 = (wxWindow *) 0 ;
37867 unsigned long arg2 ;
37868 wxWindow *result = 0 ;
37869 void *argp1 = 0 ;
37870 int res1 = 0 ;
37871 unsigned long val2 ;
37872 int ecode2 = 0 ;
37873 PyObject * obj0 = 0 ;
37874 PyObject * obj1 = 0 ;
37875 char * kwnames[] = {
37876 (char *) "parent",(char *) "_hWnd", NULL
37877 };
37878
37879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37881 if (!SWIG_IsOK(res1)) {
37882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37883 }
37884 arg1 = reinterpret_cast< wxWindow * >(argp1);
37885 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37886 if (!SWIG_IsOK(ecode2)) {
37887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37888 }
37889 arg2 = static_cast< unsigned long >(val2);
37890 {
37891 PyThreadState* __tstate = wxPyBeginAllowThreads();
37892 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37893 wxPyEndAllowThreads(__tstate);
37894 if (PyErr_Occurred()) SWIG_fail;
37895 }
37896 {
37897 resultobj = wxPyMake_wxObject(result, 0);
37898 }
37899 return resultobj;
37900 fail:
37901 return NULL;
37902 }
37903
37904
37905 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37906 PyObject *resultobj = 0;
37907 PyObject *result = 0 ;
37908
37909 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37910 {
37911 PyThreadState* __tstate = wxPyBeginAllowThreads();
37912 result = (PyObject *)GetTopLevelWindows();
37913 wxPyEndAllowThreads(__tstate);
37914 if (PyErr_Occurred()) SWIG_fail;
37915 }
37916 resultobj = result;
37917 return resultobj;
37918 fail:
37919 return NULL;
37920 }
37921
37922
37923 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37924 PyObject *resultobj = 0;
37925 wxValidator *result = 0 ;
37926
37927 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37928 {
37929 PyThreadState* __tstate = wxPyBeginAllowThreads();
37930 result = (wxValidator *)new wxValidator();
37931 wxPyEndAllowThreads(__tstate);
37932 if (PyErr_Occurred()) SWIG_fail;
37933 }
37934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37935 return resultobj;
37936 fail:
37937 return NULL;
37938 }
37939
37940
37941 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37942 PyObject *resultobj = 0;
37943 wxValidator *arg1 = (wxValidator *) 0 ;
37944 wxValidator *result = 0 ;
37945 void *argp1 = 0 ;
37946 int res1 = 0 ;
37947 PyObject *swig_obj[1] ;
37948
37949 if (!args) SWIG_fail;
37950 swig_obj[0] = args;
37951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37952 if (!SWIG_IsOK(res1)) {
37953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37954 }
37955 arg1 = reinterpret_cast< wxValidator * >(argp1);
37956 {
37957 PyThreadState* __tstate = wxPyBeginAllowThreads();
37958 result = (wxValidator *)(arg1)->Clone();
37959 wxPyEndAllowThreads(__tstate);
37960 if (PyErr_Occurred()) SWIG_fail;
37961 }
37962 {
37963 resultobj = wxPyMake_wxObject(result, 0);
37964 }
37965 return resultobj;
37966 fail:
37967 return NULL;
37968 }
37969
37970
37971 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37972 PyObject *resultobj = 0;
37973 wxValidator *arg1 = (wxValidator *) 0 ;
37974 wxWindow *arg2 = (wxWindow *) 0 ;
37975 bool result;
37976 void *argp1 = 0 ;
37977 int res1 = 0 ;
37978 void *argp2 = 0 ;
37979 int res2 = 0 ;
37980 PyObject * obj0 = 0 ;
37981 PyObject * obj1 = 0 ;
37982 char * kwnames[] = {
37983 (char *) "self",(char *) "parent", NULL
37984 };
37985
37986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37988 if (!SWIG_IsOK(res1)) {
37989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37990 }
37991 arg1 = reinterpret_cast< wxValidator * >(argp1);
37992 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37993 if (!SWIG_IsOK(res2)) {
37994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37995 }
37996 arg2 = reinterpret_cast< wxWindow * >(argp2);
37997 {
37998 PyThreadState* __tstate = wxPyBeginAllowThreads();
37999 result = (bool)(arg1)->Validate(arg2);
38000 wxPyEndAllowThreads(__tstate);
38001 if (PyErr_Occurred()) SWIG_fail;
38002 }
38003 {
38004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38005 }
38006 return resultobj;
38007 fail:
38008 return NULL;
38009 }
38010
38011
38012 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38013 PyObject *resultobj = 0;
38014 wxValidator *arg1 = (wxValidator *) 0 ;
38015 bool result;
38016 void *argp1 = 0 ;
38017 int res1 = 0 ;
38018 PyObject *swig_obj[1] ;
38019
38020 if (!args) SWIG_fail;
38021 swig_obj[0] = args;
38022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38023 if (!SWIG_IsOK(res1)) {
38024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38025 }
38026 arg1 = reinterpret_cast< wxValidator * >(argp1);
38027 {
38028 PyThreadState* __tstate = wxPyBeginAllowThreads();
38029 result = (bool)(arg1)->TransferToWindow();
38030 wxPyEndAllowThreads(__tstate);
38031 if (PyErr_Occurred()) SWIG_fail;
38032 }
38033 {
38034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38035 }
38036 return resultobj;
38037 fail:
38038 return NULL;
38039 }
38040
38041
38042 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38043 PyObject *resultobj = 0;
38044 wxValidator *arg1 = (wxValidator *) 0 ;
38045 bool result;
38046 void *argp1 = 0 ;
38047 int res1 = 0 ;
38048 PyObject *swig_obj[1] ;
38049
38050 if (!args) SWIG_fail;
38051 swig_obj[0] = args;
38052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38053 if (!SWIG_IsOK(res1)) {
38054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38055 }
38056 arg1 = reinterpret_cast< wxValidator * >(argp1);
38057 {
38058 PyThreadState* __tstate = wxPyBeginAllowThreads();
38059 result = (bool)(arg1)->TransferFromWindow();
38060 wxPyEndAllowThreads(__tstate);
38061 if (PyErr_Occurred()) SWIG_fail;
38062 }
38063 {
38064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38065 }
38066 return resultobj;
38067 fail:
38068 return NULL;
38069 }
38070
38071
38072 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38073 PyObject *resultobj = 0;
38074 wxValidator *arg1 = (wxValidator *) 0 ;
38075 wxWindow *result = 0 ;
38076 void *argp1 = 0 ;
38077 int res1 = 0 ;
38078 PyObject *swig_obj[1] ;
38079
38080 if (!args) SWIG_fail;
38081 swig_obj[0] = args;
38082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38083 if (!SWIG_IsOK(res1)) {
38084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38085 }
38086 arg1 = reinterpret_cast< wxValidator * >(argp1);
38087 {
38088 PyThreadState* __tstate = wxPyBeginAllowThreads();
38089 result = (wxWindow *)(arg1)->GetWindow();
38090 wxPyEndAllowThreads(__tstate);
38091 if (PyErr_Occurred()) SWIG_fail;
38092 }
38093 {
38094 resultobj = wxPyMake_wxObject(result, 0);
38095 }
38096 return resultobj;
38097 fail:
38098 return NULL;
38099 }
38100
38101
38102 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38103 PyObject *resultobj = 0;
38104 wxValidator *arg1 = (wxValidator *) 0 ;
38105 wxWindow *arg2 = (wxWindow *) 0 ;
38106 void *argp1 = 0 ;
38107 int res1 = 0 ;
38108 void *argp2 = 0 ;
38109 int res2 = 0 ;
38110 PyObject * obj0 = 0 ;
38111 PyObject * obj1 = 0 ;
38112 char * kwnames[] = {
38113 (char *) "self",(char *) "window", NULL
38114 };
38115
38116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38118 if (!SWIG_IsOK(res1)) {
38119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38120 }
38121 arg1 = reinterpret_cast< wxValidator * >(argp1);
38122 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38123 if (!SWIG_IsOK(res2)) {
38124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38125 }
38126 arg2 = reinterpret_cast< wxWindow * >(argp2);
38127 {
38128 PyThreadState* __tstate = wxPyBeginAllowThreads();
38129 (arg1)->SetWindow(arg2);
38130 wxPyEndAllowThreads(__tstate);
38131 if (PyErr_Occurred()) SWIG_fail;
38132 }
38133 resultobj = SWIG_Py_Void();
38134 return resultobj;
38135 fail:
38136 return NULL;
38137 }
38138
38139
38140 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38141 PyObject *resultobj = 0;
38142 bool result;
38143
38144 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38145 {
38146 PyThreadState* __tstate = wxPyBeginAllowThreads();
38147 result = (bool)wxValidator::IsSilent();
38148 wxPyEndAllowThreads(__tstate);
38149 if (PyErr_Occurred()) SWIG_fail;
38150 }
38151 {
38152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38153 }
38154 return resultobj;
38155 fail:
38156 return NULL;
38157 }
38158
38159
38160 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38161 PyObject *resultobj = 0;
38162 int arg1 = (int) true ;
38163 int val1 ;
38164 int ecode1 = 0 ;
38165 PyObject * obj0 = 0 ;
38166 char * kwnames[] = {
38167 (char *) "doIt", NULL
38168 };
38169
38170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38171 if (obj0) {
38172 ecode1 = SWIG_AsVal_int(obj0, &val1);
38173 if (!SWIG_IsOK(ecode1)) {
38174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38175 }
38176 arg1 = static_cast< int >(val1);
38177 }
38178 {
38179 PyThreadState* __tstate = wxPyBeginAllowThreads();
38180 wxValidator::SetBellOnError(arg1);
38181 wxPyEndAllowThreads(__tstate);
38182 if (PyErr_Occurred()) SWIG_fail;
38183 }
38184 resultobj = SWIG_Py_Void();
38185 return resultobj;
38186 fail:
38187 return NULL;
38188 }
38189
38190
38191 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38192 PyObject *obj;
38193 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38194 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38195 return SWIG_Py_Void();
38196 }
38197
38198 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38199 return SWIG_Python_InitShadowInstance(args);
38200 }
38201
38202 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38203 PyObject *resultobj = 0;
38204 wxPyValidator *result = 0 ;
38205
38206 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38207 {
38208 PyThreadState* __tstate = wxPyBeginAllowThreads();
38209 result = (wxPyValidator *)new wxPyValidator();
38210 wxPyEndAllowThreads(__tstate);
38211 if (PyErr_Occurred()) SWIG_fail;
38212 }
38213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38214 return resultobj;
38215 fail:
38216 return NULL;
38217 }
38218
38219
38220 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38221 PyObject *resultobj = 0;
38222 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38223 PyObject *arg2 = (PyObject *) 0 ;
38224 PyObject *arg3 = (PyObject *) 0 ;
38225 int arg4 = (int) true ;
38226 void *argp1 = 0 ;
38227 int res1 = 0 ;
38228 int val4 ;
38229 int ecode4 = 0 ;
38230 PyObject * obj0 = 0 ;
38231 PyObject * obj1 = 0 ;
38232 PyObject * obj2 = 0 ;
38233 PyObject * obj3 = 0 ;
38234 char * kwnames[] = {
38235 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38236 };
38237
38238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38240 if (!SWIG_IsOK(res1)) {
38241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38242 }
38243 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38244 arg2 = obj1;
38245 arg3 = obj2;
38246 if (obj3) {
38247 ecode4 = SWIG_AsVal_int(obj3, &val4);
38248 if (!SWIG_IsOK(ecode4)) {
38249 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38250 }
38251 arg4 = static_cast< int >(val4);
38252 }
38253 {
38254 PyThreadState* __tstate = wxPyBeginAllowThreads();
38255 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38256 wxPyEndAllowThreads(__tstate);
38257 if (PyErr_Occurred()) SWIG_fail;
38258 }
38259 resultobj = SWIG_Py_Void();
38260 return resultobj;
38261 fail:
38262 return NULL;
38263 }
38264
38265
38266 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38267 PyObject *obj;
38268 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38269 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38270 return SWIG_Py_Void();
38271 }
38272
38273 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38274 return SWIG_Python_InitShadowInstance(args);
38275 }
38276
38277 SWIGINTERN int DefaultValidator_set(PyObject *) {
38278 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38279 return 1;
38280 }
38281
38282
38283 SWIGINTERN PyObject *DefaultValidator_get(void) {
38284 PyObject *pyobj = 0;
38285
38286 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38287 return pyobj;
38288 }
38289
38290
38291 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38292 PyObject *resultobj = 0;
38293 wxString const &arg1_defvalue = wxPyEmptyString ;
38294 wxString *arg1 = (wxString *) &arg1_defvalue ;
38295 long arg2 = (long) 0 ;
38296 wxMenu *result = 0 ;
38297 bool temp1 = false ;
38298 long val2 ;
38299 int ecode2 = 0 ;
38300 PyObject * obj0 = 0 ;
38301 PyObject * obj1 = 0 ;
38302 char * kwnames[] = {
38303 (char *) "title",(char *) "style", NULL
38304 };
38305
38306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38307 if (obj0) {
38308 {
38309 arg1 = wxString_in_helper(obj0);
38310 if (arg1 == NULL) SWIG_fail;
38311 temp1 = true;
38312 }
38313 }
38314 if (obj1) {
38315 ecode2 = SWIG_AsVal_long(obj1, &val2);
38316 if (!SWIG_IsOK(ecode2)) {
38317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38318 }
38319 arg2 = static_cast< long >(val2);
38320 }
38321 {
38322 if (!wxPyCheckForApp()) SWIG_fail;
38323 PyThreadState* __tstate = wxPyBeginAllowThreads();
38324 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38325 wxPyEndAllowThreads(__tstate);
38326 if (PyErr_Occurred()) SWIG_fail;
38327 }
38328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38329 {
38330 if (temp1)
38331 delete arg1;
38332 }
38333 return resultobj;
38334 fail:
38335 {
38336 if (temp1)
38337 delete arg1;
38338 }
38339 return NULL;
38340 }
38341
38342
38343 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38344 PyObject *resultobj = 0;
38345 wxMenu *arg1 = (wxMenu *) 0 ;
38346 int arg2 ;
38347 wxString *arg3 = 0 ;
38348 wxString const &arg4_defvalue = wxPyEmptyString ;
38349 wxString *arg4 = (wxString *) &arg4_defvalue ;
38350 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38351 wxMenuItem *result = 0 ;
38352 void *argp1 = 0 ;
38353 int res1 = 0 ;
38354 int val2 ;
38355 int ecode2 = 0 ;
38356 bool temp3 = false ;
38357 bool temp4 = false ;
38358 int val5 ;
38359 int ecode5 = 0 ;
38360 PyObject * obj0 = 0 ;
38361 PyObject * obj1 = 0 ;
38362 PyObject * obj2 = 0 ;
38363 PyObject * obj3 = 0 ;
38364 PyObject * obj4 = 0 ;
38365 char * kwnames[] = {
38366 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38367 };
38368
38369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38371 if (!SWIG_IsOK(res1)) {
38372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38373 }
38374 arg1 = reinterpret_cast< wxMenu * >(argp1);
38375 ecode2 = SWIG_AsVal_int(obj1, &val2);
38376 if (!SWIG_IsOK(ecode2)) {
38377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38378 }
38379 arg2 = static_cast< int >(val2);
38380 {
38381 arg3 = wxString_in_helper(obj2);
38382 if (arg3 == NULL) SWIG_fail;
38383 temp3 = true;
38384 }
38385 if (obj3) {
38386 {
38387 arg4 = wxString_in_helper(obj3);
38388 if (arg4 == NULL) SWIG_fail;
38389 temp4 = true;
38390 }
38391 }
38392 if (obj4) {
38393 ecode5 = SWIG_AsVal_int(obj4, &val5);
38394 if (!SWIG_IsOK(ecode5)) {
38395 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38396 }
38397 arg5 = static_cast< wxItemKind >(val5);
38398 }
38399 {
38400 PyThreadState* __tstate = wxPyBeginAllowThreads();
38401 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38402 wxPyEndAllowThreads(__tstate);
38403 if (PyErr_Occurred()) SWIG_fail;
38404 }
38405 {
38406 resultobj = wxPyMake_wxObject(result, (bool)0);
38407 }
38408 {
38409 if (temp3)
38410 delete arg3;
38411 }
38412 {
38413 if (temp4)
38414 delete arg4;
38415 }
38416 return resultobj;
38417 fail:
38418 {
38419 if (temp3)
38420 delete arg3;
38421 }
38422 {
38423 if (temp4)
38424 delete arg4;
38425 }
38426 return NULL;
38427 }
38428
38429
38430 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38431 PyObject *resultobj = 0;
38432 wxMenu *arg1 = (wxMenu *) 0 ;
38433 wxMenuItem *result = 0 ;
38434 void *argp1 = 0 ;
38435 int res1 = 0 ;
38436 PyObject *swig_obj[1] ;
38437
38438 if (!args) SWIG_fail;
38439 swig_obj[0] = args;
38440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38441 if (!SWIG_IsOK(res1)) {
38442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38443 }
38444 arg1 = reinterpret_cast< wxMenu * >(argp1);
38445 {
38446 PyThreadState* __tstate = wxPyBeginAllowThreads();
38447 result = (wxMenuItem *)(arg1)->AppendSeparator();
38448 wxPyEndAllowThreads(__tstate);
38449 if (PyErr_Occurred()) SWIG_fail;
38450 }
38451 {
38452 resultobj = wxPyMake_wxObject(result, (bool)0);
38453 }
38454 return resultobj;
38455 fail:
38456 return NULL;
38457 }
38458
38459
38460 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38461 PyObject *resultobj = 0;
38462 wxMenu *arg1 = (wxMenu *) 0 ;
38463 int arg2 ;
38464 wxString *arg3 = 0 ;
38465 wxString const &arg4_defvalue = wxPyEmptyString ;
38466 wxString *arg4 = (wxString *) &arg4_defvalue ;
38467 wxMenuItem *result = 0 ;
38468 void *argp1 = 0 ;
38469 int res1 = 0 ;
38470 int val2 ;
38471 int ecode2 = 0 ;
38472 bool temp3 = false ;
38473 bool temp4 = false ;
38474 PyObject * obj0 = 0 ;
38475 PyObject * obj1 = 0 ;
38476 PyObject * obj2 = 0 ;
38477 PyObject * obj3 = 0 ;
38478 char * kwnames[] = {
38479 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38480 };
38481
38482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38484 if (!SWIG_IsOK(res1)) {
38485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38486 }
38487 arg1 = reinterpret_cast< wxMenu * >(argp1);
38488 ecode2 = SWIG_AsVal_int(obj1, &val2);
38489 if (!SWIG_IsOK(ecode2)) {
38490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38491 }
38492 arg2 = static_cast< int >(val2);
38493 {
38494 arg3 = wxString_in_helper(obj2);
38495 if (arg3 == NULL) SWIG_fail;
38496 temp3 = true;
38497 }
38498 if (obj3) {
38499 {
38500 arg4 = wxString_in_helper(obj3);
38501 if (arg4 == NULL) SWIG_fail;
38502 temp4 = true;
38503 }
38504 }
38505 {
38506 PyThreadState* __tstate = wxPyBeginAllowThreads();
38507 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38508 wxPyEndAllowThreads(__tstate);
38509 if (PyErr_Occurred()) SWIG_fail;
38510 }
38511 {
38512 resultobj = wxPyMake_wxObject(result, (bool)0);
38513 }
38514 {
38515 if (temp3)
38516 delete arg3;
38517 }
38518 {
38519 if (temp4)
38520 delete arg4;
38521 }
38522 return resultobj;
38523 fail:
38524 {
38525 if (temp3)
38526 delete arg3;
38527 }
38528 {
38529 if (temp4)
38530 delete arg4;
38531 }
38532 return NULL;
38533 }
38534
38535
38536 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38537 PyObject *resultobj = 0;
38538 wxMenu *arg1 = (wxMenu *) 0 ;
38539 int arg2 ;
38540 wxString *arg3 = 0 ;
38541 wxString const &arg4_defvalue = wxPyEmptyString ;
38542 wxString *arg4 = (wxString *) &arg4_defvalue ;
38543 wxMenuItem *result = 0 ;
38544 void *argp1 = 0 ;
38545 int res1 = 0 ;
38546 int val2 ;
38547 int ecode2 = 0 ;
38548 bool temp3 = false ;
38549 bool temp4 = false ;
38550 PyObject * obj0 = 0 ;
38551 PyObject * obj1 = 0 ;
38552 PyObject * obj2 = 0 ;
38553 PyObject * obj3 = 0 ;
38554 char * kwnames[] = {
38555 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38556 };
38557
38558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38560 if (!SWIG_IsOK(res1)) {
38561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38562 }
38563 arg1 = reinterpret_cast< wxMenu * >(argp1);
38564 ecode2 = SWIG_AsVal_int(obj1, &val2);
38565 if (!SWIG_IsOK(ecode2)) {
38566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38567 }
38568 arg2 = static_cast< int >(val2);
38569 {
38570 arg3 = wxString_in_helper(obj2);
38571 if (arg3 == NULL) SWIG_fail;
38572 temp3 = true;
38573 }
38574 if (obj3) {
38575 {
38576 arg4 = wxString_in_helper(obj3);
38577 if (arg4 == NULL) SWIG_fail;
38578 temp4 = true;
38579 }
38580 }
38581 {
38582 PyThreadState* __tstate = wxPyBeginAllowThreads();
38583 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38584 wxPyEndAllowThreads(__tstate);
38585 if (PyErr_Occurred()) SWIG_fail;
38586 }
38587 {
38588 resultobj = wxPyMake_wxObject(result, (bool)0);
38589 }
38590 {
38591 if (temp3)
38592 delete arg3;
38593 }
38594 {
38595 if (temp4)
38596 delete arg4;
38597 }
38598 return resultobj;
38599 fail:
38600 {
38601 if (temp3)
38602 delete arg3;
38603 }
38604 {
38605 if (temp4)
38606 delete arg4;
38607 }
38608 return NULL;
38609 }
38610
38611
38612 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38613 PyObject *resultobj = 0;
38614 wxMenu *arg1 = (wxMenu *) 0 ;
38615 int arg2 ;
38616 wxString *arg3 = 0 ;
38617 wxMenu *arg4 = (wxMenu *) 0 ;
38618 wxString const &arg5_defvalue = wxPyEmptyString ;
38619 wxString *arg5 = (wxString *) &arg5_defvalue ;
38620 wxMenuItem *result = 0 ;
38621 void *argp1 = 0 ;
38622 int res1 = 0 ;
38623 int val2 ;
38624 int ecode2 = 0 ;
38625 bool temp3 = false ;
38626 void *argp4 = 0 ;
38627 int res4 = 0 ;
38628 bool temp5 = false ;
38629 PyObject * obj0 = 0 ;
38630 PyObject * obj1 = 0 ;
38631 PyObject * obj2 = 0 ;
38632 PyObject * obj3 = 0 ;
38633 PyObject * obj4 = 0 ;
38634 char * kwnames[] = {
38635 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38636 };
38637
38638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38640 if (!SWIG_IsOK(res1)) {
38641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38642 }
38643 arg1 = reinterpret_cast< wxMenu * >(argp1);
38644 ecode2 = SWIG_AsVal_int(obj1, &val2);
38645 if (!SWIG_IsOK(ecode2)) {
38646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38647 }
38648 arg2 = static_cast< int >(val2);
38649 {
38650 arg3 = wxString_in_helper(obj2);
38651 if (arg3 == NULL) SWIG_fail;
38652 temp3 = true;
38653 }
38654 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38655 if (!SWIG_IsOK(res4)) {
38656 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38657 }
38658 arg4 = reinterpret_cast< wxMenu * >(argp4);
38659 if (obj4) {
38660 {
38661 arg5 = wxString_in_helper(obj4);
38662 if (arg5 == NULL) SWIG_fail;
38663 temp5 = true;
38664 }
38665 }
38666 {
38667 PyThreadState* __tstate = wxPyBeginAllowThreads();
38668 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38669 wxPyEndAllowThreads(__tstate);
38670 if (PyErr_Occurred()) SWIG_fail;
38671 }
38672 {
38673 resultobj = wxPyMake_wxObject(result, (bool)0);
38674 }
38675 {
38676 if (temp3)
38677 delete arg3;
38678 }
38679 {
38680 if (temp5)
38681 delete arg5;
38682 }
38683 return resultobj;
38684 fail:
38685 {
38686 if (temp3)
38687 delete arg3;
38688 }
38689 {
38690 if (temp5)
38691 delete arg5;
38692 }
38693 return NULL;
38694 }
38695
38696
38697 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38698 PyObject *resultobj = 0;
38699 wxMenu *arg1 = (wxMenu *) 0 ;
38700 wxMenu *arg2 = (wxMenu *) 0 ;
38701 wxString *arg3 = 0 ;
38702 wxString const &arg4_defvalue = wxPyEmptyString ;
38703 wxString *arg4 = (wxString *) &arg4_defvalue ;
38704 wxMenuItem *result = 0 ;
38705 void *argp1 = 0 ;
38706 int res1 = 0 ;
38707 void *argp2 = 0 ;
38708 int res2 = 0 ;
38709 bool temp3 = false ;
38710 bool temp4 = false ;
38711 PyObject * obj0 = 0 ;
38712 PyObject * obj1 = 0 ;
38713 PyObject * obj2 = 0 ;
38714 PyObject * obj3 = 0 ;
38715 char * kwnames[] = {
38716 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38717 };
38718
38719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38721 if (!SWIG_IsOK(res1)) {
38722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38723 }
38724 arg1 = reinterpret_cast< wxMenu * >(argp1);
38725 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38726 if (!SWIG_IsOK(res2)) {
38727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38728 }
38729 arg2 = reinterpret_cast< wxMenu * >(argp2);
38730 {
38731 arg3 = wxString_in_helper(obj2);
38732 if (arg3 == NULL) SWIG_fail;
38733 temp3 = true;
38734 }
38735 if (obj3) {
38736 {
38737 arg4 = wxString_in_helper(obj3);
38738 if (arg4 == NULL) SWIG_fail;
38739 temp4 = true;
38740 }
38741 }
38742 {
38743 PyThreadState* __tstate = wxPyBeginAllowThreads();
38744 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38745 wxPyEndAllowThreads(__tstate);
38746 if (PyErr_Occurred()) SWIG_fail;
38747 }
38748 {
38749 resultobj = wxPyMake_wxObject(result, (bool)0);
38750 }
38751 {
38752 if (temp3)
38753 delete arg3;
38754 }
38755 {
38756 if (temp4)
38757 delete arg4;
38758 }
38759 return resultobj;
38760 fail:
38761 {
38762 if (temp3)
38763 delete arg3;
38764 }
38765 {
38766 if (temp4)
38767 delete arg4;
38768 }
38769 return NULL;
38770 }
38771
38772
38773 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38774 PyObject *resultobj = 0;
38775 wxMenu *arg1 = (wxMenu *) 0 ;
38776 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38777 wxMenuItem *result = 0 ;
38778 void *argp1 = 0 ;
38779 int res1 = 0 ;
38780 int res2 = 0 ;
38781 PyObject * obj0 = 0 ;
38782 PyObject * obj1 = 0 ;
38783 char * kwnames[] = {
38784 (char *) "self",(char *) "item", NULL
38785 };
38786
38787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38789 if (!SWIG_IsOK(res1)) {
38790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38791 }
38792 arg1 = reinterpret_cast< wxMenu * >(argp1);
38793 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38794 if (!SWIG_IsOK(res2)) {
38795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38796 }
38797 {
38798 PyThreadState* __tstate = wxPyBeginAllowThreads();
38799 result = (wxMenuItem *)(arg1)->Append(arg2);
38800 wxPyEndAllowThreads(__tstate);
38801 if (PyErr_Occurred()) SWIG_fail;
38802 }
38803 {
38804 resultobj = wxPyMake_wxObject(result, (bool)0);
38805 }
38806 return resultobj;
38807 fail:
38808 return NULL;
38809 }
38810
38811
38812 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38813 PyObject *resultobj = 0;
38814 wxMenu *arg1 = (wxMenu *) 0 ;
38815 size_t arg2 ;
38816 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38817 wxMenuItem *result = 0 ;
38818 void *argp1 = 0 ;
38819 int res1 = 0 ;
38820 size_t val2 ;
38821 int ecode2 = 0 ;
38822 int res3 = 0 ;
38823 PyObject * obj0 = 0 ;
38824 PyObject * obj1 = 0 ;
38825 PyObject * obj2 = 0 ;
38826 char * kwnames[] = {
38827 (char *) "self",(char *) "pos",(char *) "item", NULL
38828 };
38829
38830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38832 if (!SWIG_IsOK(res1)) {
38833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38834 }
38835 arg1 = reinterpret_cast< wxMenu * >(argp1);
38836 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38837 if (!SWIG_IsOK(ecode2)) {
38838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38839 }
38840 arg2 = static_cast< size_t >(val2);
38841 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38842 if (!SWIG_IsOK(res3)) {
38843 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38844 }
38845 {
38846 PyThreadState* __tstate = wxPyBeginAllowThreads();
38847 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38848 wxPyEndAllowThreads(__tstate);
38849 if (PyErr_Occurred()) SWIG_fail;
38850 }
38851 {
38852 resultobj = wxPyMake_wxObject(result, (bool)0);
38853 }
38854 return resultobj;
38855 fail:
38856 return NULL;
38857 }
38858
38859
38860 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38861 PyObject *resultobj = 0;
38862 wxMenu *arg1 = (wxMenu *) 0 ;
38863 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38864 wxMenuItem *result = 0 ;
38865 void *argp1 = 0 ;
38866 int res1 = 0 ;
38867 int res2 = 0 ;
38868 PyObject * obj0 = 0 ;
38869 PyObject * obj1 = 0 ;
38870 char * kwnames[] = {
38871 (char *) "self",(char *) "item", NULL
38872 };
38873
38874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38876 if (!SWIG_IsOK(res1)) {
38877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38878 }
38879 arg1 = reinterpret_cast< wxMenu * >(argp1);
38880 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38881 if (!SWIG_IsOK(res2)) {
38882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38883 }
38884 {
38885 PyThreadState* __tstate = wxPyBeginAllowThreads();
38886 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38887 wxPyEndAllowThreads(__tstate);
38888 if (PyErr_Occurred()) SWIG_fail;
38889 }
38890 {
38891 resultobj = wxPyMake_wxObject(result, (bool)0);
38892 }
38893 return resultobj;
38894 fail:
38895 return NULL;
38896 }
38897
38898
38899 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38900 PyObject *resultobj = 0;
38901 wxMenu *arg1 = (wxMenu *) 0 ;
38902 void *argp1 = 0 ;
38903 int res1 = 0 ;
38904 PyObject *swig_obj[1] ;
38905
38906 if (!args) SWIG_fail;
38907 swig_obj[0] = args;
38908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38909 if (!SWIG_IsOK(res1)) {
38910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38911 }
38912 arg1 = reinterpret_cast< wxMenu * >(argp1);
38913 {
38914 PyThreadState* __tstate = wxPyBeginAllowThreads();
38915 (arg1)->Break();
38916 wxPyEndAllowThreads(__tstate);
38917 if (PyErr_Occurred()) SWIG_fail;
38918 }
38919 resultobj = SWIG_Py_Void();
38920 return resultobj;
38921 fail:
38922 return NULL;
38923 }
38924
38925
38926 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38927 PyObject *resultobj = 0;
38928 wxMenu *arg1 = (wxMenu *) 0 ;
38929 size_t arg2 ;
38930 int arg3 ;
38931 wxString *arg4 = 0 ;
38932 wxString const &arg5_defvalue = wxPyEmptyString ;
38933 wxString *arg5 = (wxString *) &arg5_defvalue ;
38934 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38935 wxMenuItem *result = 0 ;
38936 void *argp1 = 0 ;
38937 int res1 = 0 ;
38938 size_t val2 ;
38939 int ecode2 = 0 ;
38940 int val3 ;
38941 int ecode3 = 0 ;
38942 bool temp4 = false ;
38943 bool temp5 = false ;
38944 int val6 ;
38945 int ecode6 = 0 ;
38946 PyObject * obj0 = 0 ;
38947 PyObject * obj1 = 0 ;
38948 PyObject * obj2 = 0 ;
38949 PyObject * obj3 = 0 ;
38950 PyObject * obj4 = 0 ;
38951 PyObject * obj5 = 0 ;
38952 char * kwnames[] = {
38953 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38954 };
38955
38956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38958 if (!SWIG_IsOK(res1)) {
38959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38960 }
38961 arg1 = reinterpret_cast< wxMenu * >(argp1);
38962 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38963 if (!SWIG_IsOK(ecode2)) {
38964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38965 }
38966 arg2 = static_cast< size_t >(val2);
38967 ecode3 = SWIG_AsVal_int(obj2, &val3);
38968 if (!SWIG_IsOK(ecode3)) {
38969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38970 }
38971 arg3 = static_cast< int >(val3);
38972 {
38973 arg4 = wxString_in_helper(obj3);
38974 if (arg4 == NULL) SWIG_fail;
38975 temp4 = true;
38976 }
38977 if (obj4) {
38978 {
38979 arg5 = wxString_in_helper(obj4);
38980 if (arg5 == NULL) SWIG_fail;
38981 temp5 = true;
38982 }
38983 }
38984 if (obj5) {
38985 ecode6 = SWIG_AsVal_int(obj5, &val6);
38986 if (!SWIG_IsOK(ecode6)) {
38987 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38988 }
38989 arg6 = static_cast< wxItemKind >(val6);
38990 }
38991 {
38992 PyThreadState* __tstate = wxPyBeginAllowThreads();
38993 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38994 wxPyEndAllowThreads(__tstate);
38995 if (PyErr_Occurred()) SWIG_fail;
38996 }
38997 {
38998 resultobj = wxPyMake_wxObject(result, (bool)0);
38999 }
39000 {
39001 if (temp4)
39002 delete arg4;
39003 }
39004 {
39005 if (temp5)
39006 delete arg5;
39007 }
39008 return resultobj;
39009 fail:
39010 {
39011 if (temp4)
39012 delete arg4;
39013 }
39014 {
39015 if (temp5)
39016 delete arg5;
39017 }
39018 return NULL;
39019 }
39020
39021
39022 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39023 PyObject *resultobj = 0;
39024 wxMenu *arg1 = (wxMenu *) 0 ;
39025 size_t arg2 ;
39026 wxMenuItem *result = 0 ;
39027 void *argp1 = 0 ;
39028 int res1 = 0 ;
39029 size_t val2 ;
39030 int ecode2 = 0 ;
39031 PyObject * obj0 = 0 ;
39032 PyObject * obj1 = 0 ;
39033 char * kwnames[] = {
39034 (char *) "self",(char *) "pos", NULL
39035 };
39036
39037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39039 if (!SWIG_IsOK(res1)) {
39040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39041 }
39042 arg1 = reinterpret_cast< wxMenu * >(argp1);
39043 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39044 if (!SWIG_IsOK(ecode2)) {
39045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39046 }
39047 arg2 = static_cast< size_t >(val2);
39048 {
39049 PyThreadState* __tstate = wxPyBeginAllowThreads();
39050 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39051 wxPyEndAllowThreads(__tstate);
39052 if (PyErr_Occurred()) SWIG_fail;
39053 }
39054 {
39055 resultobj = wxPyMake_wxObject(result, (bool)0);
39056 }
39057 return resultobj;
39058 fail:
39059 return NULL;
39060 }
39061
39062
39063 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39064 PyObject *resultobj = 0;
39065 wxMenu *arg1 = (wxMenu *) 0 ;
39066 size_t arg2 ;
39067 int arg3 ;
39068 wxString *arg4 = 0 ;
39069 wxString const &arg5_defvalue = wxPyEmptyString ;
39070 wxString *arg5 = (wxString *) &arg5_defvalue ;
39071 wxMenuItem *result = 0 ;
39072 void *argp1 = 0 ;
39073 int res1 = 0 ;
39074 size_t val2 ;
39075 int ecode2 = 0 ;
39076 int val3 ;
39077 int ecode3 = 0 ;
39078 bool temp4 = false ;
39079 bool temp5 = false ;
39080 PyObject * obj0 = 0 ;
39081 PyObject * obj1 = 0 ;
39082 PyObject * obj2 = 0 ;
39083 PyObject * obj3 = 0 ;
39084 PyObject * obj4 = 0 ;
39085 char * kwnames[] = {
39086 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39087 };
39088
39089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39091 if (!SWIG_IsOK(res1)) {
39092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39093 }
39094 arg1 = reinterpret_cast< wxMenu * >(argp1);
39095 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39096 if (!SWIG_IsOK(ecode2)) {
39097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39098 }
39099 arg2 = static_cast< size_t >(val2);
39100 ecode3 = SWIG_AsVal_int(obj2, &val3);
39101 if (!SWIG_IsOK(ecode3)) {
39102 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39103 }
39104 arg3 = static_cast< int >(val3);
39105 {
39106 arg4 = wxString_in_helper(obj3);
39107 if (arg4 == NULL) SWIG_fail;
39108 temp4 = true;
39109 }
39110 if (obj4) {
39111 {
39112 arg5 = wxString_in_helper(obj4);
39113 if (arg5 == NULL) SWIG_fail;
39114 temp5 = true;
39115 }
39116 }
39117 {
39118 PyThreadState* __tstate = wxPyBeginAllowThreads();
39119 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39120 wxPyEndAllowThreads(__tstate);
39121 if (PyErr_Occurred()) SWIG_fail;
39122 }
39123 {
39124 resultobj = wxPyMake_wxObject(result, (bool)0);
39125 }
39126 {
39127 if (temp4)
39128 delete arg4;
39129 }
39130 {
39131 if (temp5)
39132 delete arg5;
39133 }
39134 return resultobj;
39135 fail:
39136 {
39137 if (temp4)
39138 delete arg4;
39139 }
39140 {
39141 if (temp5)
39142 delete arg5;
39143 }
39144 return NULL;
39145 }
39146
39147
39148 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39149 PyObject *resultobj = 0;
39150 wxMenu *arg1 = (wxMenu *) 0 ;
39151 size_t arg2 ;
39152 int arg3 ;
39153 wxString *arg4 = 0 ;
39154 wxString const &arg5_defvalue = wxPyEmptyString ;
39155 wxString *arg5 = (wxString *) &arg5_defvalue ;
39156 wxMenuItem *result = 0 ;
39157 void *argp1 = 0 ;
39158 int res1 = 0 ;
39159 size_t val2 ;
39160 int ecode2 = 0 ;
39161 int val3 ;
39162 int ecode3 = 0 ;
39163 bool temp4 = false ;
39164 bool temp5 = false ;
39165 PyObject * obj0 = 0 ;
39166 PyObject * obj1 = 0 ;
39167 PyObject * obj2 = 0 ;
39168 PyObject * obj3 = 0 ;
39169 PyObject * obj4 = 0 ;
39170 char * kwnames[] = {
39171 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39172 };
39173
39174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39176 if (!SWIG_IsOK(res1)) {
39177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39178 }
39179 arg1 = reinterpret_cast< wxMenu * >(argp1);
39180 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39181 if (!SWIG_IsOK(ecode2)) {
39182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39183 }
39184 arg2 = static_cast< size_t >(val2);
39185 ecode3 = SWIG_AsVal_int(obj2, &val3);
39186 if (!SWIG_IsOK(ecode3)) {
39187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39188 }
39189 arg3 = static_cast< int >(val3);
39190 {
39191 arg4 = wxString_in_helper(obj3);
39192 if (arg4 == NULL) SWIG_fail;
39193 temp4 = true;
39194 }
39195 if (obj4) {
39196 {
39197 arg5 = wxString_in_helper(obj4);
39198 if (arg5 == NULL) SWIG_fail;
39199 temp5 = true;
39200 }
39201 }
39202 {
39203 PyThreadState* __tstate = wxPyBeginAllowThreads();
39204 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39205 wxPyEndAllowThreads(__tstate);
39206 if (PyErr_Occurred()) SWIG_fail;
39207 }
39208 {
39209 resultobj = wxPyMake_wxObject(result, (bool)0);
39210 }
39211 {
39212 if (temp4)
39213 delete arg4;
39214 }
39215 {
39216 if (temp5)
39217 delete arg5;
39218 }
39219 return resultobj;
39220 fail:
39221 {
39222 if (temp4)
39223 delete arg4;
39224 }
39225 {
39226 if (temp5)
39227 delete arg5;
39228 }
39229 return NULL;
39230 }
39231
39232
39233 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39234 PyObject *resultobj = 0;
39235 wxMenu *arg1 = (wxMenu *) 0 ;
39236 size_t arg2 ;
39237 int arg3 ;
39238 wxString *arg4 = 0 ;
39239 wxMenu *arg5 = (wxMenu *) 0 ;
39240 wxString const &arg6_defvalue = wxPyEmptyString ;
39241 wxString *arg6 = (wxString *) &arg6_defvalue ;
39242 wxMenuItem *result = 0 ;
39243 void *argp1 = 0 ;
39244 int res1 = 0 ;
39245 size_t val2 ;
39246 int ecode2 = 0 ;
39247 int val3 ;
39248 int ecode3 = 0 ;
39249 bool temp4 = false ;
39250 void *argp5 = 0 ;
39251 int res5 = 0 ;
39252 bool temp6 = false ;
39253 PyObject * obj0 = 0 ;
39254 PyObject * obj1 = 0 ;
39255 PyObject * obj2 = 0 ;
39256 PyObject * obj3 = 0 ;
39257 PyObject * obj4 = 0 ;
39258 PyObject * obj5 = 0 ;
39259 char * kwnames[] = {
39260 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39261 };
39262
39263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39265 if (!SWIG_IsOK(res1)) {
39266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39267 }
39268 arg1 = reinterpret_cast< wxMenu * >(argp1);
39269 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39270 if (!SWIG_IsOK(ecode2)) {
39271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39272 }
39273 arg2 = static_cast< size_t >(val2);
39274 ecode3 = SWIG_AsVal_int(obj2, &val3);
39275 if (!SWIG_IsOK(ecode3)) {
39276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39277 }
39278 arg3 = static_cast< int >(val3);
39279 {
39280 arg4 = wxString_in_helper(obj3);
39281 if (arg4 == NULL) SWIG_fail;
39282 temp4 = true;
39283 }
39284 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39285 if (!SWIG_IsOK(res5)) {
39286 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39287 }
39288 arg5 = reinterpret_cast< wxMenu * >(argp5);
39289 if (obj5) {
39290 {
39291 arg6 = wxString_in_helper(obj5);
39292 if (arg6 == NULL) SWIG_fail;
39293 temp6 = true;
39294 }
39295 }
39296 {
39297 PyThreadState* __tstate = wxPyBeginAllowThreads();
39298 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39299 wxPyEndAllowThreads(__tstate);
39300 if (PyErr_Occurred()) SWIG_fail;
39301 }
39302 {
39303 resultobj = wxPyMake_wxObject(result, (bool)0);
39304 }
39305 {
39306 if (temp4)
39307 delete arg4;
39308 }
39309 {
39310 if (temp6)
39311 delete arg6;
39312 }
39313 return resultobj;
39314 fail:
39315 {
39316 if (temp4)
39317 delete arg4;
39318 }
39319 {
39320 if (temp6)
39321 delete arg6;
39322 }
39323 return NULL;
39324 }
39325
39326
39327 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39328 PyObject *resultobj = 0;
39329 wxMenu *arg1 = (wxMenu *) 0 ;
39330 int arg2 ;
39331 wxString *arg3 = 0 ;
39332 wxString const &arg4_defvalue = wxPyEmptyString ;
39333 wxString *arg4 = (wxString *) &arg4_defvalue ;
39334 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39335 wxMenuItem *result = 0 ;
39336 void *argp1 = 0 ;
39337 int res1 = 0 ;
39338 int val2 ;
39339 int ecode2 = 0 ;
39340 bool temp3 = false ;
39341 bool temp4 = false ;
39342 int val5 ;
39343 int ecode5 = 0 ;
39344 PyObject * obj0 = 0 ;
39345 PyObject * obj1 = 0 ;
39346 PyObject * obj2 = 0 ;
39347 PyObject * obj3 = 0 ;
39348 PyObject * obj4 = 0 ;
39349 char * kwnames[] = {
39350 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39351 };
39352
39353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39355 if (!SWIG_IsOK(res1)) {
39356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39357 }
39358 arg1 = reinterpret_cast< wxMenu * >(argp1);
39359 ecode2 = SWIG_AsVal_int(obj1, &val2);
39360 if (!SWIG_IsOK(ecode2)) {
39361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39362 }
39363 arg2 = static_cast< int >(val2);
39364 {
39365 arg3 = wxString_in_helper(obj2);
39366 if (arg3 == NULL) SWIG_fail;
39367 temp3 = true;
39368 }
39369 if (obj3) {
39370 {
39371 arg4 = wxString_in_helper(obj3);
39372 if (arg4 == NULL) SWIG_fail;
39373 temp4 = true;
39374 }
39375 }
39376 if (obj4) {
39377 ecode5 = SWIG_AsVal_int(obj4, &val5);
39378 if (!SWIG_IsOK(ecode5)) {
39379 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39380 }
39381 arg5 = static_cast< wxItemKind >(val5);
39382 }
39383 {
39384 PyThreadState* __tstate = wxPyBeginAllowThreads();
39385 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39386 wxPyEndAllowThreads(__tstate);
39387 if (PyErr_Occurred()) SWIG_fail;
39388 }
39389 {
39390 resultobj = wxPyMake_wxObject(result, (bool)0);
39391 }
39392 {
39393 if (temp3)
39394 delete arg3;
39395 }
39396 {
39397 if (temp4)
39398 delete arg4;
39399 }
39400 return resultobj;
39401 fail:
39402 {
39403 if (temp3)
39404 delete arg3;
39405 }
39406 {
39407 if (temp4)
39408 delete arg4;
39409 }
39410 return NULL;
39411 }
39412
39413
39414 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39415 PyObject *resultobj = 0;
39416 wxMenu *arg1 = (wxMenu *) 0 ;
39417 wxMenuItem *result = 0 ;
39418 void *argp1 = 0 ;
39419 int res1 = 0 ;
39420 PyObject *swig_obj[1] ;
39421
39422 if (!args) SWIG_fail;
39423 swig_obj[0] = args;
39424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39425 if (!SWIG_IsOK(res1)) {
39426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39427 }
39428 arg1 = reinterpret_cast< wxMenu * >(argp1);
39429 {
39430 PyThreadState* __tstate = wxPyBeginAllowThreads();
39431 result = (wxMenuItem *)(arg1)->PrependSeparator();
39432 wxPyEndAllowThreads(__tstate);
39433 if (PyErr_Occurred()) SWIG_fail;
39434 }
39435 {
39436 resultobj = wxPyMake_wxObject(result, (bool)0);
39437 }
39438 return resultobj;
39439 fail:
39440 return NULL;
39441 }
39442
39443
39444 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39445 PyObject *resultobj = 0;
39446 wxMenu *arg1 = (wxMenu *) 0 ;
39447 int arg2 ;
39448 wxString *arg3 = 0 ;
39449 wxString const &arg4_defvalue = wxPyEmptyString ;
39450 wxString *arg4 = (wxString *) &arg4_defvalue ;
39451 wxMenuItem *result = 0 ;
39452 void *argp1 = 0 ;
39453 int res1 = 0 ;
39454 int val2 ;
39455 int ecode2 = 0 ;
39456 bool temp3 = false ;
39457 bool temp4 = false ;
39458 PyObject * obj0 = 0 ;
39459 PyObject * obj1 = 0 ;
39460 PyObject * obj2 = 0 ;
39461 PyObject * obj3 = 0 ;
39462 char * kwnames[] = {
39463 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39464 };
39465
39466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39468 if (!SWIG_IsOK(res1)) {
39469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39470 }
39471 arg1 = reinterpret_cast< wxMenu * >(argp1);
39472 ecode2 = SWIG_AsVal_int(obj1, &val2);
39473 if (!SWIG_IsOK(ecode2)) {
39474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39475 }
39476 arg2 = static_cast< int >(val2);
39477 {
39478 arg3 = wxString_in_helper(obj2);
39479 if (arg3 == NULL) SWIG_fail;
39480 temp3 = true;
39481 }
39482 if (obj3) {
39483 {
39484 arg4 = wxString_in_helper(obj3);
39485 if (arg4 == NULL) SWIG_fail;
39486 temp4 = true;
39487 }
39488 }
39489 {
39490 PyThreadState* __tstate = wxPyBeginAllowThreads();
39491 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39492 wxPyEndAllowThreads(__tstate);
39493 if (PyErr_Occurred()) SWIG_fail;
39494 }
39495 {
39496 resultobj = wxPyMake_wxObject(result, (bool)0);
39497 }
39498 {
39499 if (temp3)
39500 delete arg3;
39501 }
39502 {
39503 if (temp4)
39504 delete arg4;
39505 }
39506 return resultobj;
39507 fail:
39508 {
39509 if (temp3)
39510 delete arg3;
39511 }
39512 {
39513 if (temp4)
39514 delete arg4;
39515 }
39516 return NULL;
39517 }
39518
39519
39520 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39521 PyObject *resultobj = 0;
39522 wxMenu *arg1 = (wxMenu *) 0 ;
39523 int arg2 ;
39524 wxString *arg3 = 0 ;
39525 wxString const &arg4_defvalue = wxPyEmptyString ;
39526 wxString *arg4 = (wxString *) &arg4_defvalue ;
39527 wxMenuItem *result = 0 ;
39528 void *argp1 = 0 ;
39529 int res1 = 0 ;
39530 int val2 ;
39531 int ecode2 = 0 ;
39532 bool temp3 = false ;
39533 bool temp4 = false ;
39534 PyObject * obj0 = 0 ;
39535 PyObject * obj1 = 0 ;
39536 PyObject * obj2 = 0 ;
39537 PyObject * obj3 = 0 ;
39538 char * kwnames[] = {
39539 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39540 };
39541
39542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39544 if (!SWIG_IsOK(res1)) {
39545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39546 }
39547 arg1 = reinterpret_cast< wxMenu * >(argp1);
39548 ecode2 = SWIG_AsVal_int(obj1, &val2);
39549 if (!SWIG_IsOK(ecode2)) {
39550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39551 }
39552 arg2 = static_cast< int >(val2);
39553 {
39554 arg3 = wxString_in_helper(obj2);
39555 if (arg3 == NULL) SWIG_fail;
39556 temp3 = true;
39557 }
39558 if (obj3) {
39559 {
39560 arg4 = wxString_in_helper(obj3);
39561 if (arg4 == NULL) SWIG_fail;
39562 temp4 = true;
39563 }
39564 }
39565 {
39566 PyThreadState* __tstate = wxPyBeginAllowThreads();
39567 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39568 wxPyEndAllowThreads(__tstate);
39569 if (PyErr_Occurred()) SWIG_fail;
39570 }
39571 {
39572 resultobj = wxPyMake_wxObject(result, (bool)0);
39573 }
39574 {
39575 if (temp3)
39576 delete arg3;
39577 }
39578 {
39579 if (temp4)
39580 delete arg4;
39581 }
39582 return resultobj;
39583 fail:
39584 {
39585 if (temp3)
39586 delete arg3;
39587 }
39588 {
39589 if (temp4)
39590 delete arg4;
39591 }
39592 return NULL;
39593 }
39594
39595
39596 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39597 PyObject *resultobj = 0;
39598 wxMenu *arg1 = (wxMenu *) 0 ;
39599 int arg2 ;
39600 wxString *arg3 = 0 ;
39601 wxMenu *arg4 = (wxMenu *) 0 ;
39602 wxString const &arg5_defvalue = wxPyEmptyString ;
39603 wxString *arg5 = (wxString *) &arg5_defvalue ;
39604 wxMenuItem *result = 0 ;
39605 void *argp1 = 0 ;
39606 int res1 = 0 ;
39607 int val2 ;
39608 int ecode2 = 0 ;
39609 bool temp3 = false ;
39610 void *argp4 = 0 ;
39611 int res4 = 0 ;
39612 bool temp5 = false ;
39613 PyObject * obj0 = 0 ;
39614 PyObject * obj1 = 0 ;
39615 PyObject * obj2 = 0 ;
39616 PyObject * obj3 = 0 ;
39617 PyObject * obj4 = 0 ;
39618 char * kwnames[] = {
39619 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39620 };
39621
39622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39624 if (!SWIG_IsOK(res1)) {
39625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39626 }
39627 arg1 = reinterpret_cast< wxMenu * >(argp1);
39628 ecode2 = SWIG_AsVal_int(obj1, &val2);
39629 if (!SWIG_IsOK(ecode2)) {
39630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39631 }
39632 arg2 = static_cast< int >(val2);
39633 {
39634 arg3 = wxString_in_helper(obj2);
39635 if (arg3 == NULL) SWIG_fail;
39636 temp3 = true;
39637 }
39638 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39639 if (!SWIG_IsOK(res4)) {
39640 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39641 }
39642 arg4 = reinterpret_cast< wxMenu * >(argp4);
39643 if (obj4) {
39644 {
39645 arg5 = wxString_in_helper(obj4);
39646 if (arg5 == NULL) SWIG_fail;
39647 temp5 = true;
39648 }
39649 }
39650 {
39651 PyThreadState* __tstate = wxPyBeginAllowThreads();
39652 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39653 wxPyEndAllowThreads(__tstate);
39654 if (PyErr_Occurred()) SWIG_fail;
39655 }
39656 {
39657 resultobj = wxPyMake_wxObject(result, (bool)0);
39658 }
39659 {
39660 if (temp3)
39661 delete arg3;
39662 }
39663 {
39664 if (temp5)
39665 delete arg5;
39666 }
39667 return resultobj;
39668 fail:
39669 {
39670 if (temp3)
39671 delete arg3;
39672 }
39673 {
39674 if (temp5)
39675 delete arg5;
39676 }
39677 return NULL;
39678 }
39679
39680
39681 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39682 PyObject *resultobj = 0;
39683 wxMenu *arg1 = (wxMenu *) 0 ;
39684 int arg2 ;
39685 wxMenuItem *result = 0 ;
39686 void *argp1 = 0 ;
39687 int res1 = 0 ;
39688 int val2 ;
39689 int ecode2 = 0 ;
39690 PyObject * obj0 = 0 ;
39691 PyObject * obj1 = 0 ;
39692 char * kwnames[] = {
39693 (char *) "self",(char *) "id", NULL
39694 };
39695
39696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39698 if (!SWIG_IsOK(res1)) {
39699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39700 }
39701 arg1 = reinterpret_cast< wxMenu * >(argp1);
39702 ecode2 = SWIG_AsVal_int(obj1, &val2);
39703 if (!SWIG_IsOK(ecode2)) {
39704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39705 }
39706 arg2 = static_cast< int >(val2);
39707 {
39708 PyThreadState* __tstate = wxPyBeginAllowThreads();
39709 result = (wxMenuItem *)(arg1)->Remove(arg2);
39710 wxPyEndAllowThreads(__tstate);
39711 if (PyErr_Occurred()) SWIG_fail;
39712 }
39713 {
39714 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39715 }
39716 return resultobj;
39717 fail:
39718 return NULL;
39719 }
39720
39721
39722 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39723 PyObject *resultobj = 0;
39724 wxMenu *arg1 = (wxMenu *) 0 ;
39725 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39726 wxMenuItem *result = 0 ;
39727 void *argp1 = 0 ;
39728 int res1 = 0 ;
39729 void *argp2 = 0 ;
39730 int res2 = 0 ;
39731 PyObject * obj0 = 0 ;
39732 PyObject * obj1 = 0 ;
39733 char * kwnames[] = {
39734 (char *) "self",(char *) "item", NULL
39735 };
39736
39737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39739 if (!SWIG_IsOK(res1)) {
39740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39741 }
39742 arg1 = reinterpret_cast< wxMenu * >(argp1);
39743 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39744 if (!SWIG_IsOK(res2)) {
39745 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39746 }
39747 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39748 {
39749 PyThreadState* __tstate = wxPyBeginAllowThreads();
39750 result = (wxMenuItem *)(arg1)->Remove(arg2);
39751 wxPyEndAllowThreads(__tstate);
39752 if (PyErr_Occurred()) SWIG_fail;
39753 }
39754 {
39755 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39756 }
39757 return resultobj;
39758 fail:
39759 return NULL;
39760 }
39761
39762
39763 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39764 PyObject *resultobj = 0;
39765 wxMenu *arg1 = (wxMenu *) 0 ;
39766 int arg2 ;
39767 bool result;
39768 void *argp1 = 0 ;
39769 int res1 = 0 ;
39770 int val2 ;
39771 int ecode2 = 0 ;
39772 PyObject * obj0 = 0 ;
39773 PyObject * obj1 = 0 ;
39774 char * kwnames[] = {
39775 (char *) "self",(char *) "id", NULL
39776 };
39777
39778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39780 if (!SWIG_IsOK(res1)) {
39781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39782 }
39783 arg1 = reinterpret_cast< wxMenu * >(argp1);
39784 ecode2 = SWIG_AsVal_int(obj1, &val2);
39785 if (!SWIG_IsOK(ecode2)) {
39786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39787 }
39788 arg2 = static_cast< int >(val2);
39789 {
39790 PyThreadState* __tstate = wxPyBeginAllowThreads();
39791 result = (bool)(arg1)->Delete(arg2);
39792 wxPyEndAllowThreads(__tstate);
39793 if (PyErr_Occurred()) SWIG_fail;
39794 }
39795 {
39796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39797 }
39798 return resultobj;
39799 fail:
39800 return NULL;
39801 }
39802
39803
39804 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39805 PyObject *resultobj = 0;
39806 wxMenu *arg1 = (wxMenu *) 0 ;
39807 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39808 bool result;
39809 void *argp1 = 0 ;
39810 int res1 = 0 ;
39811 void *argp2 = 0 ;
39812 int res2 = 0 ;
39813 PyObject * obj0 = 0 ;
39814 PyObject * obj1 = 0 ;
39815 char * kwnames[] = {
39816 (char *) "self",(char *) "item", NULL
39817 };
39818
39819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39821 if (!SWIG_IsOK(res1)) {
39822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39823 }
39824 arg1 = reinterpret_cast< wxMenu * >(argp1);
39825 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39826 if (!SWIG_IsOK(res2)) {
39827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39828 }
39829 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39830 {
39831 PyThreadState* __tstate = wxPyBeginAllowThreads();
39832 result = (bool)(arg1)->Delete(arg2);
39833 wxPyEndAllowThreads(__tstate);
39834 if (PyErr_Occurred()) SWIG_fail;
39835 }
39836 {
39837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39838 }
39839 return resultobj;
39840 fail:
39841 return NULL;
39842 }
39843
39844
39845 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39846 PyObject *resultobj = 0;
39847 wxMenu *arg1 = (wxMenu *) 0 ;
39848 void *argp1 = 0 ;
39849 int res1 = 0 ;
39850 PyObject *swig_obj[1] ;
39851
39852 if (!args) SWIG_fail;
39853 swig_obj[0] = args;
39854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39855 if (!SWIG_IsOK(res1)) {
39856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39857 }
39858 arg1 = reinterpret_cast< wxMenu * >(argp1);
39859 {
39860 PyThreadState* __tstate = wxPyBeginAllowThreads();
39861 wxMenu_Destroy(arg1);
39862 wxPyEndAllowThreads(__tstate);
39863 if (PyErr_Occurred()) SWIG_fail;
39864 }
39865 resultobj = SWIG_Py_Void();
39866 return resultobj;
39867 fail:
39868 return NULL;
39869 }
39870
39871
39872 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39873 PyObject *resultobj = 0;
39874 wxMenu *arg1 = (wxMenu *) 0 ;
39875 int arg2 ;
39876 bool result;
39877 void *argp1 = 0 ;
39878 int res1 = 0 ;
39879 int val2 ;
39880 int ecode2 = 0 ;
39881 PyObject * obj0 = 0 ;
39882 PyObject * obj1 = 0 ;
39883 char * kwnames[] = {
39884 (char *) "self",(char *) "id", NULL
39885 };
39886
39887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39889 if (!SWIG_IsOK(res1)) {
39890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39891 }
39892 arg1 = reinterpret_cast< wxMenu * >(argp1);
39893 ecode2 = SWIG_AsVal_int(obj1, &val2);
39894 if (!SWIG_IsOK(ecode2)) {
39895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39896 }
39897 arg2 = static_cast< int >(val2);
39898 {
39899 PyThreadState* __tstate = wxPyBeginAllowThreads();
39900 result = (bool)(arg1)->Destroy(arg2);
39901 wxPyEndAllowThreads(__tstate);
39902 if (PyErr_Occurred()) SWIG_fail;
39903 }
39904 {
39905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39906 }
39907 return resultobj;
39908 fail:
39909 return NULL;
39910 }
39911
39912
39913 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39914 PyObject *resultobj = 0;
39915 wxMenu *arg1 = (wxMenu *) 0 ;
39916 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39917 bool result;
39918 void *argp1 = 0 ;
39919 int res1 = 0 ;
39920 void *argp2 = 0 ;
39921 int res2 = 0 ;
39922 PyObject * obj0 = 0 ;
39923 PyObject * obj1 = 0 ;
39924 char * kwnames[] = {
39925 (char *) "self",(char *) "item", NULL
39926 };
39927
39928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39930 if (!SWIG_IsOK(res1)) {
39931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39932 }
39933 arg1 = reinterpret_cast< wxMenu * >(argp1);
39934 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39935 if (!SWIG_IsOK(res2)) {
39936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39937 }
39938 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39939 {
39940 PyThreadState* __tstate = wxPyBeginAllowThreads();
39941 result = (bool)(arg1)->Destroy(arg2);
39942 wxPyEndAllowThreads(__tstate);
39943 if (PyErr_Occurred()) SWIG_fail;
39944 }
39945 {
39946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39947 }
39948 return resultobj;
39949 fail:
39950 return NULL;
39951 }
39952
39953
39954 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39955 PyObject *resultobj = 0;
39956 wxMenu *arg1 = (wxMenu *) 0 ;
39957 size_t result;
39958 void *argp1 = 0 ;
39959 int res1 = 0 ;
39960 PyObject *swig_obj[1] ;
39961
39962 if (!args) SWIG_fail;
39963 swig_obj[0] = args;
39964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39965 if (!SWIG_IsOK(res1)) {
39966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39967 }
39968 arg1 = reinterpret_cast< wxMenu * >(argp1);
39969 {
39970 PyThreadState* __tstate = wxPyBeginAllowThreads();
39971 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39972 wxPyEndAllowThreads(__tstate);
39973 if (PyErr_Occurred()) SWIG_fail;
39974 }
39975 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39976 return resultobj;
39977 fail:
39978 return NULL;
39979 }
39980
39981
39982 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39983 PyObject *resultobj = 0;
39984 wxMenu *arg1 = (wxMenu *) 0 ;
39985 PyObject *result = 0 ;
39986 void *argp1 = 0 ;
39987 int res1 = 0 ;
39988 PyObject *swig_obj[1] ;
39989
39990 if (!args) SWIG_fail;
39991 swig_obj[0] = args;
39992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39993 if (!SWIG_IsOK(res1)) {
39994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39995 }
39996 arg1 = reinterpret_cast< wxMenu * >(argp1);
39997 {
39998 PyThreadState* __tstate = wxPyBeginAllowThreads();
39999 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40000 wxPyEndAllowThreads(__tstate);
40001 if (PyErr_Occurred()) SWIG_fail;
40002 }
40003 resultobj = result;
40004 return resultobj;
40005 fail:
40006 return NULL;
40007 }
40008
40009
40010 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40011 PyObject *resultobj = 0;
40012 wxMenu *arg1 = (wxMenu *) 0 ;
40013 wxString *arg2 = 0 ;
40014 int result;
40015 void *argp1 = 0 ;
40016 int res1 = 0 ;
40017 bool temp2 = false ;
40018 PyObject * obj0 = 0 ;
40019 PyObject * obj1 = 0 ;
40020 char * kwnames[] = {
40021 (char *) "self",(char *) "item", NULL
40022 };
40023
40024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40026 if (!SWIG_IsOK(res1)) {
40027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40028 }
40029 arg1 = reinterpret_cast< wxMenu * >(argp1);
40030 {
40031 arg2 = wxString_in_helper(obj1);
40032 if (arg2 == NULL) SWIG_fail;
40033 temp2 = true;
40034 }
40035 {
40036 PyThreadState* __tstate = wxPyBeginAllowThreads();
40037 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40038 wxPyEndAllowThreads(__tstate);
40039 if (PyErr_Occurred()) SWIG_fail;
40040 }
40041 resultobj = SWIG_From_int(static_cast< int >(result));
40042 {
40043 if (temp2)
40044 delete arg2;
40045 }
40046 return resultobj;
40047 fail:
40048 {
40049 if (temp2)
40050 delete arg2;
40051 }
40052 return NULL;
40053 }
40054
40055
40056 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40057 PyObject *resultobj = 0;
40058 wxMenu *arg1 = (wxMenu *) 0 ;
40059 int arg2 ;
40060 wxMenuItem *result = 0 ;
40061 void *argp1 = 0 ;
40062 int res1 = 0 ;
40063 int val2 ;
40064 int ecode2 = 0 ;
40065 PyObject * obj0 = 0 ;
40066 PyObject * obj1 = 0 ;
40067 char * kwnames[] = {
40068 (char *) "self",(char *) "id", NULL
40069 };
40070
40071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40073 if (!SWIG_IsOK(res1)) {
40074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40075 }
40076 arg1 = reinterpret_cast< wxMenu * >(argp1);
40077 ecode2 = SWIG_AsVal_int(obj1, &val2);
40078 if (!SWIG_IsOK(ecode2)) {
40079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40080 }
40081 arg2 = static_cast< int >(val2);
40082 {
40083 PyThreadState* __tstate = wxPyBeginAllowThreads();
40084 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40085 wxPyEndAllowThreads(__tstate);
40086 if (PyErr_Occurred()) SWIG_fail;
40087 }
40088 {
40089 resultobj = wxPyMake_wxObject(result, (bool)0);
40090 }
40091 return resultobj;
40092 fail:
40093 return NULL;
40094 }
40095
40096
40097 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40098 PyObject *resultobj = 0;
40099 wxMenu *arg1 = (wxMenu *) 0 ;
40100 size_t arg2 ;
40101 wxMenuItem *result = 0 ;
40102 void *argp1 = 0 ;
40103 int res1 = 0 ;
40104 size_t val2 ;
40105 int ecode2 = 0 ;
40106 PyObject * obj0 = 0 ;
40107 PyObject * obj1 = 0 ;
40108 char * kwnames[] = {
40109 (char *) "self",(char *) "position", NULL
40110 };
40111
40112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40114 if (!SWIG_IsOK(res1)) {
40115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40116 }
40117 arg1 = reinterpret_cast< wxMenu * >(argp1);
40118 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40119 if (!SWIG_IsOK(ecode2)) {
40120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40121 }
40122 arg2 = static_cast< size_t >(val2);
40123 {
40124 PyThreadState* __tstate = wxPyBeginAllowThreads();
40125 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40126 wxPyEndAllowThreads(__tstate);
40127 if (PyErr_Occurred()) SWIG_fail;
40128 }
40129 {
40130 resultobj = wxPyMake_wxObject(result, (bool)0);
40131 }
40132 return resultobj;
40133 fail:
40134 return NULL;
40135 }
40136
40137
40138 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40139 PyObject *resultobj = 0;
40140 wxMenu *arg1 = (wxMenu *) 0 ;
40141 int arg2 ;
40142 bool arg3 ;
40143 void *argp1 = 0 ;
40144 int res1 = 0 ;
40145 int val2 ;
40146 int ecode2 = 0 ;
40147 bool val3 ;
40148 int ecode3 = 0 ;
40149 PyObject * obj0 = 0 ;
40150 PyObject * obj1 = 0 ;
40151 PyObject * obj2 = 0 ;
40152 char * kwnames[] = {
40153 (char *) "self",(char *) "id",(char *) "enable", NULL
40154 };
40155
40156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40158 if (!SWIG_IsOK(res1)) {
40159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40160 }
40161 arg1 = reinterpret_cast< wxMenu * >(argp1);
40162 ecode2 = SWIG_AsVal_int(obj1, &val2);
40163 if (!SWIG_IsOK(ecode2)) {
40164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40165 }
40166 arg2 = static_cast< int >(val2);
40167 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40168 if (!SWIG_IsOK(ecode3)) {
40169 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40170 }
40171 arg3 = static_cast< bool >(val3);
40172 {
40173 PyThreadState* __tstate = wxPyBeginAllowThreads();
40174 (arg1)->Enable(arg2,arg3);
40175 wxPyEndAllowThreads(__tstate);
40176 if (PyErr_Occurred()) SWIG_fail;
40177 }
40178 resultobj = SWIG_Py_Void();
40179 return resultobj;
40180 fail:
40181 return NULL;
40182 }
40183
40184
40185 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40186 PyObject *resultobj = 0;
40187 wxMenu *arg1 = (wxMenu *) 0 ;
40188 int arg2 ;
40189 bool result;
40190 void *argp1 = 0 ;
40191 int res1 = 0 ;
40192 int val2 ;
40193 int ecode2 = 0 ;
40194 PyObject * obj0 = 0 ;
40195 PyObject * obj1 = 0 ;
40196 char * kwnames[] = {
40197 (char *) "self",(char *) "id", NULL
40198 };
40199
40200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40202 if (!SWIG_IsOK(res1)) {
40203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40204 }
40205 arg1 = reinterpret_cast< wxMenu * >(argp1);
40206 ecode2 = SWIG_AsVal_int(obj1, &val2);
40207 if (!SWIG_IsOK(ecode2)) {
40208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40209 }
40210 arg2 = static_cast< int >(val2);
40211 {
40212 PyThreadState* __tstate = wxPyBeginAllowThreads();
40213 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40214 wxPyEndAllowThreads(__tstate);
40215 if (PyErr_Occurred()) SWIG_fail;
40216 }
40217 {
40218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40219 }
40220 return resultobj;
40221 fail:
40222 return NULL;
40223 }
40224
40225
40226 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40227 PyObject *resultobj = 0;
40228 wxMenu *arg1 = (wxMenu *) 0 ;
40229 int arg2 ;
40230 bool arg3 ;
40231 void *argp1 = 0 ;
40232 int res1 = 0 ;
40233 int val2 ;
40234 int ecode2 = 0 ;
40235 bool val3 ;
40236 int ecode3 = 0 ;
40237 PyObject * obj0 = 0 ;
40238 PyObject * obj1 = 0 ;
40239 PyObject * obj2 = 0 ;
40240 char * kwnames[] = {
40241 (char *) "self",(char *) "id",(char *) "check", NULL
40242 };
40243
40244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40246 if (!SWIG_IsOK(res1)) {
40247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40248 }
40249 arg1 = reinterpret_cast< wxMenu * >(argp1);
40250 ecode2 = SWIG_AsVal_int(obj1, &val2);
40251 if (!SWIG_IsOK(ecode2)) {
40252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40253 }
40254 arg2 = static_cast< int >(val2);
40255 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40256 if (!SWIG_IsOK(ecode3)) {
40257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40258 }
40259 arg3 = static_cast< bool >(val3);
40260 {
40261 PyThreadState* __tstate = wxPyBeginAllowThreads();
40262 (arg1)->Check(arg2,arg3);
40263 wxPyEndAllowThreads(__tstate);
40264 if (PyErr_Occurred()) SWIG_fail;
40265 }
40266 resultobj = SWIG_Py_Void();
40267 return resultobj;
40268 fail:
40269 return NULL;
40270 }
40271
40272
40273 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40274 PyObject *resultobj = 0;
40275 wxMenu *arg1 = (wxMenu *) 0 ;
40276 int arg2 ;
40277 bool result;
40278 void *argp1 = 0 ;
40279 int res1 = 0 ;
40280 int val2 ;
40281 int ecode2 = 0 ;
40282 PyObject * obj0 = 0 ;
40283 PyObject * obj1 = 0 ;
40284 char * kwnames[] = {
40285 (char *) "self",(char *) "id", NULL
40286 };
40287
40288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40290 if (!SWIG_IsOK(res1)) {
40291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40292 }
40293 arg1 = reinterpret_cast< wxMenu * >(argp1);
40294 ecode2 = SWIG_AsVal_int(obj1, &val2);
40295 if (!SWIG_IsOK(ecode2)) {
40296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40297 }
40298 arg2 = static_cast< int >(val2);
40299 {
40300 PyThreadState* __tstate = wxPyBeginAllowThreads();
40301 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40302 wxPyEndAllowThreads(__tstate);
40303 if (PyErr_Occurred()) SWIG_fail;
40304 }
40305 {
40306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40307 }
40308 return resultobj;
40309 fail:
40310 return NULL;
40311 }
40312
40313
40314 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40315 PyObject *resultobj = 0;
40316 wxMenu *arg1 = (wxMenu *) 0 ;
40317 int arg2 ;
40318 wxString *arg3 = 0 ;
40319 void *argp1 = 0 ;
40320 int res1 = 0 ;
40321 int val2 ;
40322 int ecode2 = 0 ;
40323 bool temp3 = false ;
40324 PyObject * obj0 = 0 ;
40325 PyObject * obj1 = 0 ;
40326 PyObject * obj2 = 0 ;
40327 char * kwnames[] = {
40328 (char *) "self",(char *) "id",(char *) "label", NULL
40329 };
40330
40331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40333 if (!SWIG_IsOK(res1)) {
40334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40335 }
40336 arg1 = reinterpret_cast< wxMenu * >(argp1);
40337 ecode2 = SWIG_AsVal_int(obj1, &val2);
40338 if (!SWIG_IsOK(ecode2)) {
40339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40340 }
40341 arg2 = static_cast< int >(val2);
40342 {
40343 arg3 = wxString_in_helper(obj2);
40344 if (arg3 == NULL) SWIG_fail;
40345 temp3 = true;
40346 }
40347 {
40348 PyThreadState* __tstate = wxPyBeginAllowThreads();
40349 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40350 wxPyEndAllowThreads(__tstate);
40351 if (PyErr_Occurred()) SWIG_fail;
40352 }
40353 resultobj = SWIG_Py_Void();
40354 {
40355 if (temp3)
40356 delete arg3;
40357 }
40358 return resultobj;
40359 fail:
40360 {
40361 if (temp3)
40362 delete arg3;
40363 }
40364 return NULL;
40365 }
40366
40367
40368 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40369 PyObject *resultobj = 0;
40370 wxMenu *arg1 = (wxMenu *) 0 ;
40371 int arg2 ;
40372 wxString result;
40373 void *argp1 = 0 ;
40374 int res1 = 0 ;
40375 int val2 ;
40376 int ecode2 = 0 ;
40377 PyObject * obj0 = 0 ;
40378 PyObject * obj1 = 0 ;
40379 char * kwnames[] = {
40380 (char *) "self",(char *) "id", NULL
40381 };
40382
40383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40385 if (!SWIG_IsOK(res1)) {
40386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40387 }
40388 arg1 = reinterpret_cast< wxMenu * >(argp1);
40389 ecode2 = SWIG_AsVal_int(obj1, &val2);
40390 if (!SWIG_IsOK(ecode2)) {
40391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40392 }
40393 arg2 = static_cast< int >(val2);
40394 {
40395 PyThreadState* __tstate = wxPyBeginAllowThreads();
40396 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40397 wxPyEndAllowThreads(__tstate);
40398 if (PyErr_Occurred()) SWIG_fail;
40399 }
40400 {
40401 #if wxUSE_UNICODE
40402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40403 #else
40404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40405 #endif
40406 }
40407 return resultobj;
40408 fail:
40409 return NULL;
40410 }
40411
40412
40413 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40414 PyObject *resultobj = 0;
40415 wxMenu *arg1 = (wxMenu *) 0 ;
40416 int arg2 ;
40417 wxString *arg3 = 0 ;
40418 void *argp1 = 0 ;
40419 int res1 = 0 ;
40420 int val2 ;
40421 int ecode2 = 0 ;
40422 bool temp3 = false ;
40423 PyObject * obj0 = 0 ;
40424 PyObject * obj1 = 0 ;
40425 PyObject * obj2 = 0 ;
40426 char * kwnames[] = {
40427 (char *) "self",(char *) "id",(char *) "helpString", NULL
40428 };
40429
40430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40432 if (!SWIG_IsOK(res1)) {
40433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40434 }
40435 arg1 = reinterpret_cast< wxMenu * >(argp1);
40436 ecode2 = SWIG_AsVal_int(obj1, &val2);
40437 if (!SWIG_IsOK(ecode2)) {
40438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40439 }
40440 arg2 = static_cast< int >(val2);
40441 {
40442 arg3 = wxString_in_helper(obj2);
40443 if (arg3 == NULL) SWIG_fail;
40444 temp3 = true;
40445 }
40446 {
40447 PyThreadState* __tstate = wxPyBeginAllowThreads();
40448 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40449 wxPyEndAllowThreads(__tstate);
40450 if (PyErr_Occurred()) SWIG_fail;
40451 }
40452 resultobj = SWIG_Py_Void();
40453 {
40454 if (temp3)
40455 delete arg3;
40456 }
40457 return resultobj;
40458 fail:
40459 {
40460 if (temp3)
40461 delete arg3;
40462 }
40463 return NULL;
40464 }
40465
40466
40467 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40468 PyObject *resultobj = 0;
40469 wxMenu *arg1 = (wxMenu *) 0 ;
40470 int arg2 ;
40471 wxString result;
40472 void *argp1 = 0 ;
40473 int res1 = 0 ;
40474 int val2 ;
40475 int ecode2 = 0 ;
40476 PyObject * obj0 = 0 ;
40477 PyObject * obj1 = 0 ;
40478 char * kwnames[] = {
40479 (char *) "self",(char *) "id", NULL
40480 };
40481
40482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40484 if (!SWIG_IsOK(res1)) {
40485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40486 }
40487 arg1 = reinterpret_cast< wxMenu * >(argp1);
40488 ecode2 = SWIG_AsVal_int(obj1, &val2);
40489 if (!SWIG_IsOK(ecode2)) {
40490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40491 }
40492 arg2 = static_cast< int >(val2);
40493 {
40494 PyThreadState* __tstate = wxPyBeginAllowThreads();
40495 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40496 wxPyEndAllowThreads(__tstate);
40497 if (PyErr_Occurred()) SWIG_fail;
40498 }
40499 {
40500 #if wxUSE_UNICODE
40501 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40502 #else
40503 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40504 #endif
40505 }
40506 return resultobj;
40507 fail:
40508 return NULL;
40509 }
40510
40511
40512 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40513 PyObject *resultobj = 0;
40514 wxMenu *arg1 = (wxMenu *) 0 ;
40515 wxString *arg2 = 0 ;
40516 void *argp1 = 0 ;
40517 int res1 = 0 ;
40518 bool temp2 = false ;
40519 PyObject * obj0 = 0 ;
40520 PyObject * obj1 = 0 ;
40521 char * kwnames[] = {
40522 (char *) "self",(char *) "title", NULL
40523 };
40524
40525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40527 if (!SWIG_IsOK(res1)) {
40528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40529 }
40530 arg1 = reinterpret_cast< wxMenu * >(argp1);
40531 {
40532 arg2 = wxString_in_helper(obj1);
40533 if (arg2 == NULL) SWIG_fail;
40534 temp2 = true;
40535 }
40536 {
40537 PyThreadState* __tstate = wxPyBeginAllowThreads();
40538 (arg1)->SetTitle((wxString const &)*arg2);
40539 wxPyEndAllowThreads(__tstate);
40540 if (PyErr_Occurred()) SWIG_fail;
40541 }
40542 resultobj = SWIG_Py_Void();
40543 {
40544 if (temp2)
40545 delete arg2;
40546 }
40547 return resultobj;
40548 fail:
40549 {
40550 if (temp2)
40551 delete arg2;
40552 }
40553 return NULL;
40554 }
40555
40556
40557 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40558 PyObject *resultobj = 0;
40559 wxMenu *arg1 = (wxMenu *) 0 ;
40560 wxString result;
40561 void *argp1 = 0 ;
40562 int res1 = 0 ;
40563 PyObject *swig_obj[1] ;
40564
40565 if (!args) SWIG_fail;
40566 swig_obj[0] = args;
40567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40568 if (!SWIG_IsOK(res1)) {
40569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40570 }
40571 arg1 = reinterpret_cast< wxMenu * >(argp1);
40572 {
40573 PyThreadState* __tstate = wxPyBeginAllowThreads();
40574 result = ((wxMenu const *)arg1)->GetTitle();
40575 wxPyEndAllowThreads(__tstate);
40576 if (PyErr_Occurred()) SWIG_fail;
40577 }
40578 {
40579 #if wxUSE_UNICODE
40580 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40581 #else
40582 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40583 #endif
40584 }
40585 return resultobj;
40586 fail:
40587 return NULL;
40588 }
40589
40590
40591 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40592 PyObject *resultobj = 0;
40593 wxMenu *arg1 = (wxMenu *) 0 ;
40594 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40595 void *argp1 = 0 ;
40596 int res1 = 0 ;
40597 void *argp2 = 0 ;
40598 int res2 = 0 ;
40599 PyObject * obj0 = 0 ;
40600 PyObject * obj1 = 0 ;
40601 char * kwnames[] = {
40602 (char *) "self",(char *) "handler", NULL
40603 };
40604
40605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40607 if (!SWIG_IsOK(res1)) {
40608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40609 }
40610 arg1 = reinterpret_cast< wxMenu * >(argp1);
40611 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40612 if (!SWIG_IsOK(res2)) {
40613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40614 }
40615 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40616 {
40617 PyThreadState* __tstate = wxPyBeginAllowThreads();
40618 (arg1)->SetEventHandler(arg2);
40619 wxPyEndAllowThreads(__tstate);
40620 if (PyErr_Occurred()) SWIG_fail;
40621 }
40622 resultobj = SWIG_Py_Void();
40623 return resultobj;
40624 fail:
40625 return NULL;
40626 }
40627
40628
40629 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40630 PyObject *resultobj = 0;
40631 wxMenu *arg1 = (wxMenu *) 0 ;
40632 wxEvtHandler *result = 0 ;
40633 void *argp1 = 0 ;
40634 int res1 = 0 ;
40635 PyObject *swig_obj[1] ;
40636
40637 if (!args) SWIG_fail;
40638 swig_obj[0] = args;
40639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40640 if (!SWIG_IsOK(res1)) {
40641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40642 }
40643 arg1 = reinterpret_cast< wxMenu * >(argp1);
40644 {
40645 PyThreadState* __tstate = wxPyBeginAllowThreads();
40646 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40647 wxPyEndAllowThreads(__tstate);
40648 if (PyErr_Occurred()) SWIG_fail;
40649 }
40650 {
40651 resultobj = wxPyMake_wxObject(result, 0);
40652 }
40653 return resultobj;
40654 fail:
40655 return NULL;
40656 }
40657
40658
40659 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40660 PyObject *resultobj = 0;
40661 wxMenu *arg1 = (wxMenu *) 0 ;
40662 wxWindow *arg2 = (wxWindow *) 0 ;
40663 void *argp1 = 0 ;
40664 int res1 = 0 ;
40665 void *argp2 = 0 ;
40666 int res2 = 0 ;
40667 PyObject * obj0 = 0 ;
40668 PyObject * obj1 = 0 ;
40669 char * kwnames[] = {
40670 (char *) "self",(char *) "win", NULL
40671 };
40672
40673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40675 if (!SWIG_IsOK(res1)) {
40676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40677 }
40678 arg1 = reinterpret_cast< wxMenu * >(argp1);
40679 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40680 if (!SWIG_IsOK(res2)) {
40681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40682 }
40683 arg2 = reinterpret_cast< wxWindow * >(argp2);
40684 {
40685 PyThreadState* __tstate = wxPyBeginAllowThreads();
40686 (arg1)->SetInvokingWindow(arg2);
40687 wxPyEndAllowThreads(__tstate);
40688 if (PyErr_Occurred()) SWIG_fail;
40689 }
40690 resultobj = SWIG_Py_Void();
40691 return resultobj;
40692 fail:
40693 return NULL;
40694 }
40695
40696
40697 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40698 PyObject *resultobj = 0;
40699 wxMenu *arg1 = (wxMenu *) 0 ;
40700 wxWindow *result = 0 ;
40701 void *argp1 = 0 ;
40702 int res1 = 0 ;
40703 PyObject *swig_obj[1] ;
40704
40705 if (!args) SWIG_fail;
40706 swig_obj[0] = args;
40707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40708 if (!SWIG_IsOK(res1)) {
40709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40710 }
40711 arg1 = reinterpret_cast< wxMenu * >(argp1);
40712 {
40713 PyThreadState* __tstate = wxPyBeginAllowThreads();
40714 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40715 wxPyEndAllowThreads(__tstate);
40716 if (PyErr_Occurred()) SWIG_fail;
40717 }
40718 {
40719 resultobj = wxPyMake_wxObject(result, 0);
40720 }
40721 return resultobj;
40722 fail:
40723 return NULL;
40724 }
40725
40726
40727 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40728 PyObject *resultobj = 0;
40729 wxMenu *arg1 = (wxMenu *) 0 ;
40730 long result;
40731 void *argp1 = 0 ;
40732 int res1 = 0 ;
40733 PyObject *swig_obj[1] ;
40734
40735 if (!args) SWIG_fail;
40736 swig_obj[0] = args;
40737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40738 if (!SWIG_IsOK(res1)) {
40739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40740 }
40741 arg1 = reinterpret_cast< wxMenu * >(argp1);
40742 {
40743 PyThreadState* __tstate = wxPyBeginAllowThreads();
40744 result = (long)((wxMenu const *)arg1)->GetStyle();
40745 wxPyEndAllowThreads(__tstate);
40746 if (PyErr_Occurred()) SWIG_fail;
40747 }
40748 resultobj = SWIG_From_long(static_cast< long >(result));
40749 return resultobj;
40750 fail:
40751 return NULL;
40752 }
40753
40754
40755 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40756 PyObject *resultobj = 0;
40757 wxMenu *arg1 = (wxMenu *) 0 ;
40758 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40759 void *argp1 = 0 ;
40760 int res1 = 0 ;
40761 void *argp2 = 0 ;
40762 int res2 = 0 ;
40763 PyObject * obj0 = 0 ;
40764 PyObject * obj1 = 0 ;
40765 char * kwnames[] = {
40766 (char *) "self",(char *) "source", NULL
40767 };
40768
40769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40771 if (!SWIG_IsOK(res1)) {
40772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40773 }
40774 arg1 = reinterpret_cast< wxMenu * >(argp1);
40775 if (obj1) {
40776 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40777 if (!SWIG_IsOK(res2)) {
40778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40779 }
40780 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40781 }
40782 {
40783 PyThreadState* __tstate = wxPyBeginAllowThreads();
40784 (arg1)->UpdateUI(arg2);
40785 wxPyEndAllowThreads(__tstate);
40786 if (PyErr_Occurred()) SWIG_fail;
40787 }
40788 resultobj = SWIG_Py_Void();
40789 return resultobj;
40790 fail:
40791 return NULL;
40792 }
40793
40794
40795 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40796 PyObject *resultobj = 0;
40797 wxMenu *arg1 = (wxMenu *) 0 ;
40798 wxMenuBar *result = 0 ;
40799 void *argp1 = 0 ;
40800 int res1 = 0 ;
40801 PyObject *swig_obj[1] ;
40802
40803 if (!args) SWIG_fail;
40804 swig_obj[0] = args;
40805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40806 if (!SWIG_IsOK(res1)) {
40807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40808 }
40809 arg1 = reinterpret_cast< wxMenu * >(argp1);
40810 {
40811 PyThreadState* __tstate = wxPyBeginAllowThreads();
40812 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40813 wxPyEndAllowThreads(__tstate);
40814 if (PyErr_Occurred()) SWIG_fail;
40815 }
40816 {
40817 resultobj = wxPyMake_wxObject(result, (bool)0);
40818 }
40819 return resultobj;
40820 fail:
40821 return NULL;
40822 }
40823
40824
40825 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40826 PyObject *resultobj = 0;
40827 wxMenu *arg1 = (wxMenu *) 0 ;
40828 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40829 void *argp1 = 0 ;
40830 int res1 = 0 ;
40831 void *argp2 = 0 ;
40832 int res2 = 0 ;
40833 PyObject * obj0 = 0 ;
40834 PyObject * obj1 = 0 ;
40835 char * kwnames[] = {
40836 (char *) "self",(char *) "menubar", NULL
40837 };
40838
40839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40841 if (!SWIG_IsOK(res1)) {
40842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40843 }
40844 arg1 = reinterpret_cast< wxMenu * >(argp1);
40845 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40846 if (!SWIG_IsOK(res2)) {
40847 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40848 }
40849 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40850 {
40851 PyThreadState* __tstate = wxPyBeginAllowThreads();
40852 (arg1)->Attach(arg2);
40853 wxPyEndAllowThreads(__tstate);
40854 if (PyErr_Occurred()) SWIG_fail;
40855 }
40856 resultobj = SWIG_Py_Void();
40857 return resultobj;
40858 fail:
40859 return NULL;
40860 }
40861
40862
40863 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40864 PyObject *resultobj = 0;
40865 wxMenu *arg1 = (wxMenu *) 0 ;
40866 void *argp1 = 0 ;
40867 int res1 = 0 ;
40868 PyObject *swig_obj[1] ;
40869
40870 if (!args) SWIG_fail;
40871 swig_obj[0] = args;
40872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40873 if (!SWIG_IsOK(res1)) {
40874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40875 }
40876 arg1 = reinterpret_cast< wxMenu * >(argp1);
40877 {
40878 PyThreadState* __tstate = wxPyBeginAllowThreads();
40879 (arg1)->Detach();
40880 wxPyEndAllowThreads(__tstate);
40881 if (PyErr_Occurred()) SWIG_fail;
40882 }
40883 resultobj = SWIG_Py_Void();
40884 return resultobj;
40885 fail:
40886 return NULL;
40887 }
40888
40889
40890 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40891 PyObject *resultobj = 0;
40892 wxMenu *arg1 = (wxMenu *) 0 ;
40893 bool result;
40894 void *argp1 = 0 ;
40895 int res1 = 0 ;
40896 PyObject *swig_obj[1] ;
40897
40898 if (!args) SWIG_fail;
40899 swig_obj[0] = args;
40900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40901 if (!SWIG_IsOK(res1)) {
40902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40903 }
40904 arg1 = reinterpret_cast< wxMenu * >(argp1);
40905 {
40906 PyThreadState* __tstate = wxPyBeginAllowThreads();
40907 result = (bool)((wxMenu const *)arg1)->IsAttached();
40908 wxPyEndAllowThreads(__tstate);
40909 if (PyErr_Occurred()) SWIG_fail;
40910 }
40911 {
40912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40913 }
40914 return resultobj;
40915 fail:
40916 return NULL;
40917 }
40918
40919
40920 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40921 PyObject *resultobj = 0;
40922 wxMenu *arg1 = (wxMenu *) 0 ;
40923 wxMenu *arg2 = (wxMenu *) 0 ;
40924 void *argp1 = 0 ;
40925 int res1 = 0 ;
40926 void *argp2 = 0 ;
40927 int res2 = 0 ;
40928 PyObject * obj0 = 0 ;
40929 PyObject * obj1 = 0 ;
40930 char * kwnames[] = {
40931 (char *) "self",(char *) "parent", NULL
40932 };
40933
40934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40936 if (!SWIG_IsOK(res1)) {
40937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40938 }
40939 arg1 = reinterpret_cast< wxMenu * >(argp1);
40940 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40941 if (!SWIG_IsOK(res2)) {
40942 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40943 }
40944 arg2 = reinterpret_cast< wxMenu * >(argp2);
40945 {
40946 PyThreadState* __tstate = wxPyBeginAllowThreads();
40947 (arg1)->SetParent(arg2);
40948 wxPyEndAllowThreads(__tstate);
40949 if (PyErr_Occurred()) SWIG_fail;
40950 }
40951 resultobj = SWIG_Py_Void();
40952 return resultobj;
40953 fail:
40954 return NULL;
40955 }
40956
40957
40958 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40959 PyObject *resultobj = 0;
40960 wxMenu *arg1 = (wxMenu *) 0 ;
40961 wxMenu *result = 0 ;
40962 void *argp1 = 0 ;
40963 int res1 = 0 ;
40964 PyObject *swig_obj[1] ;
40965
40966 if (!args) SWIG_fail;
40967 swig_obj[0] = args;
40968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40969 if (!SWIG_IsOK(res1)) {
40970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40971 }
40972 arg1 = reinterpret_cast< wxMenu * >(argp1);
40973 {
40974 PyThreadState* __tstate = wxPyBeginAllowThreads();
40975 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40976 wxPyEndAllowThreads(__tstate);
40977 if (PyErr_Occurred()) SWIG_fail;
40978 }
40979 {
40980 resultobj = wxPyMake_wxObject(result, 0);
40981 }
40982 return resultobj;
40983 fail:
40984 return NULL;
40985 }
40986
40987
40988 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40989 PyObject *obj;
40990 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40991 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40992 return SWIG_Py_Void();
40993 }
40994
40995 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40996 return SWIG_Python_InitShadowInstance(args);
40997 }
40998
40999 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41000 PyObject *resultobj = 0;
41001 long arg1 = (long) 0 ;
41002 wxMenuBar *result = 0 ;
41003 long val1 ;
41004 int ecode1 = 0 ;
41005 PyObject * obj0 = 0 ;
41006 char * kwnames[] = {
41007 (char *) "style", NULL
41008 };
41009
41010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41011 if (obj0) {
41012 ecode1 = SWIG_AsVal_long(obj0, &val1);
41013 if (!SWIG_IsOK(ecode1)) {
41014 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41015 }
41016 arg1 = static_cast< long >(val1);
41017 }
41018 {
41019 if (!wxPyCheckForApp()) SWIG_fail;
41020 PyThreadState* __tstate = wxPyBeginAllowThreads();
41021 result = (wxMenuBar *)new wxMenuBar(arg1);
41022 wxPyEndAllowThreads(__tstate);
41023 if (PyErr_Occurred()) SWIG_fail;
41024 }
41025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41026 return resultobj;
41027 fail:
41028 return NULL;
41029 }
41030
41031
41032 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41033 PyObject *resultobj = 0;
41034 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41035 wxMenu *arg2 = (wxMenu *) 0 ;
41036 wxString *arg3 = 0 ;
41037 bool result;
41038 void *argp1 = 0 ;
41039 int res1 = 0 ;
41040 void *argp2 = 0 ;
41041 int res2 = 0 ;
41042 bool temp3 = false ;
41043 PyObject * obj0 = 0 ;
41044 PyObject * obj1 = 0 ;
41045 PyObject * obj2 = 0 ;
41046 char * kwnames[] = {
41047 (char *) "self",(char *) "menu",(char *) "title", NULL
41048 };
41049
41050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41052 if (!SWIG_IsOK(res1)) {
41053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41054 }
41055 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41056 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41057 if (!SWIG_IsOK(res2)) {
41058 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41059 }
41060 arg2 = reinterpret_cast< wxMenu * >(argp2);
41061 {
41062 arg3 = wxString_in_helper(obj2);
41063 if (arg3 == NULL) SWIG_fail;
41064 temp3 = true;
41065 }
41066 {
41067 PyThreadState* __tstate = wxPyBeginAllowThreads();
41068 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41069 wxPyEndAllowThreads(__tstate);
41070 if (PyErr_Occurred()) SWIG_fail;
41071 }
41072 {
41073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41074 }
41075 {
41076 if (temp3)
41077 delete arg3;
41078 }
41079 return resultobj;
41080 fail:
41081 {
41082 if (temp3)
41083 delete arg3;
41084 }
41085 return NULL;
41086 }
41087
41088
41089 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41090 PyObject *resultobj = 0;
41091 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41092 size_t arg2 ;
41093 wxMenu *arg3 = (wxMenu *) 0 ;
41094 wxString *arg4 = 0 ;
41095 bool result;
41096 void *argp1 = 0 ;
41097 int res1 = 0 ;
41098 size_t val2 ;
41099 int ecode2 = 0 ;
41100 void *argp3 = 0 ;
41101 int res3 = 0 ;
41102 bool temp4 = false ;
41103 PyObject * obj0 = 0 ;
41104 PyObject * obj1 = 0 ;
41105 PyObject * obj2 = 0 ;
41106 PyObject * obj3 = 0 ;
41107 char * kwnames[] = {
41108 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41109 };
41110
41111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41113 if (!SWIG_IsOK(res1)) {
41114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41115 }
41116 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41117 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41118 if (!SWIG_IsOK(ecode2)) {
41119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41120 }
41121 arg2 = static_cast< size_t >(val2);
41122 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41123 if (!SWIG_IsOK(res3)) {
41124 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41125 }
41126 arg3 = reinterpret_cast< wxMenu * >(argp3);
41127 {
41128 arg4 = wxString_in_helper(obj3);
41129 if (arg4 == NULL) SWIG_fail;
41130 temp4 = true;
41131 }
41132 {
41133 PyThreadState* __tstate = wxPyBeginAllowThreads();
41134 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41135 wxPyEndAllowThreads(__tstate);
41136 if (PyErr_Occurred()) SWIG_fail;
41137 }
41138 {
41139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41140 }
41141 {
41142 if (temp4)
41143 delete arg4;
41144 }
41145 return resultobj;
41146 fail:
41147 {
41148 if (temp4)
41149 delete arg4;
41150 }
41151 return NULL;
41152 }
41153
41154
41155 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41156 PyObject *resultobj = 0;
41157 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41158 size_t result;
41159 void *argp1 = 0 ;
41160 int res1 = 0 ;
41161 PyObject *swig_obj[1] ;
41162
41163 if (!args) SWIG_fail;
41164 swig_obj[0] = args;
41165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41166 if (!SWIG_IsOK(res1)) {
41167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41168 }
41169 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41170 {
41171 PyThreadState* __tstate = wxPyBeginAllowThreads();
41172 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41173 wxPyEndAllowThreads(__tstate);
41174 if (PyErr_Occurred()) SWIG_fail;
41175 }
41176 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41177 return resultobj;
41178 fail:
41179 return NULL;
41180 }
41181
41182
41183 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41184 PyObject *resultobj = 0;
41185 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41186 size_t arg2 ;
41187 wxMenu *result = 0 ;
41188 void *argp1 = 0 ;
41189 int res1 = 0 ;
41190 size_t val2 ;
41191 int ecode2 = 0 ;
41192 PyObject * obj0 = 0 ;
41193 PyObject * obj1 = 0 ;
41194 char * kwnames[] = {
41195 (char *) "self",(char *) "pos", NULL
41196 };
41197
41198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41200 if (!SWIG_IsOK(res1)) {
41201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41202 }
41203 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41204 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41205 if (!SWIG_IsOK(ecode2)) {
41206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41207 }
41208 arg2 = static_cast< size_t >(val2);
41209 {
41210 PyThreadState* __tstate = wxPyBeginAllowThreads();
41211 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41212 wxPyEndAllowThreads(__tstate);
41213 if (PyErr_Occurred()) SWIG_fail;
41214 }
41215 {
41216 resultobj = wxPyMake_wxObject(result, 0);
41217 }
41218 return resultobj;
41219 fail:
41220 return NULL;
41221 }
41222
41223
41224 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41225 PyObject *resultobj = 0;
41226 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41227 size_t arg2 ;
41228 wxMenu *arg3 = (wxMenu *) 0 ;
41229 wxString *arg4 = 0 ;
41230 wxMenu *result = 0 ;
41231 void *argp1 = 0 ;
41232 int res1 = 0 ;
41233 size_t val2 ;
41234 int ecode2 = 0 ;
41235 void *argp3 = 0 ;
41236 int res3 = 0 ;
41237 bool temp4 = false ;
41238 PyObject * obj0 = 0 ;
41239 PyObject * obj1 = 0 ;
41240 PyObject * obj2 = 0 ;
41241 PyObject * obj3 = 0 ;
41242 char * kwnames[] = {
41243 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41244 };
41245
41246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41248 if (!SWIG_IsOK(res1)) {
41249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41250 }
41251 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41252 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41253 if (!SWIG_IsOK(ecode2)) {
41254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41255 }
41256 arg2 = static_cast< size_t >(val2);
41257 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41258 if (!SWIG_IsOK(res3)) {
41259 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41260 }
41261 arg3 = reinterpret_cast< wxMenu * >(argp3);
41262 {
41263 arg4 = wxString_in_helper(obj3);
41264 if (arg4 == NULL) SWIG_fail;
41265 temp4 = true;
41266 }
41267 {
41268 PyThreadState* __tstate = wxPyBeginAllowThreads();
41269 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41270 wxPyEndAllowThreads(__tstate);
41271 if (PyErr_Occurred()) SWIG_fail;
41272 }
41273 {
41274 resultobj = wxPyMake_wxObject(result, 0);
41275 }
41276 {
41277 if (temp4)
41278 delete arg4;
41279 }
41280 return resultobj;
41281 fail:
41282 {
41283 if (temp4)
41284 delete arg4;
41285 }
41286 return NULL;
41287 }
41288
41289
41290 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41291 PyObject *resultobj = 0;
41292 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41293 size_t arg2 ;
41294 wxMenu *result = 0 ;
41295 void *argp1 = 0 ;
41296 int res1 = 0 ;
41297 size_t val2 ;
41298 int ecode2 = 0 ;
41299 PyObject * obj0 = 0 ;
41300 PyObject * obj1 = 0 ;
41301 char * kwnames[] = {
41302 (char *) "self",(char *) "pos", NULL
41303 };
41304
41305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41307 if (!SWIG_IsOK(res1)) {
41308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41309 }
41310 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41311 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41312 if (!SWIG_IsOK(ecode2)) {
41313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41314 }
41315 arg2 = static_cast< size_t >(val2);
41316 {
41317 PyThreadState* __tstate = wxPyBeginAllowThreads();
41318 result = (wxMenu *)(arg1)->Remove(arg2);
41319 wxPyEndAllowThreads(__tstate);
41320 if (PyErr_Occurred()) SWIG_fail;
41321 }
41322 {
41323 resultobj = wxPyMake_wxObject(result, 0);
41324 }
41325 return resultobj;
41326 fail:
41327 return NULL;
41328 }
41329
41330
41331 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41332 PyObject *resultobj = 0;
41333 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41334 size_t arg2 ;
41335 bool arg3 ;
41336 void *argp1 = 0 ;
41337 int res1 = 0 ;
41338 size_t val2 ;
41339 int ecode2 = 0 ;
41340 bool val3 ;
41341 int ecode3 = 0 ;
41342 PyObject * obj0 = 0 ;
41343 PyObject * obj1 = 0 ;
41344 PyObject * obj2 = 0 ;
41345 char * kwnames[] = {
41346 (char *) "self",(char *) "pos",(char *) "enable", NULL
41347 };
41348
41349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41351 if (!SWIG_IsOK(res1)) {
41352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41353 }
41354 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41355 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41356 if (!SWIG_IsOK(ecode2)) {
41357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41358 }
41359 arg2 = static_cast< size_t >(val2);
41360 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41361 if (!SWIG_IsOK(ecode3)) {
41362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41363 }
41364 arg3 = static_cast< bool >(val3);
41365 {
41366 PyThreadState* __tstate = wxPyBeginAllowThreads();
41367 (arg1)->EnableTop(arg2,arg3);
41368 wxPyEndAllowThreads(__tstate);
41369 if (PyErr_Occurred()) SWIG_fail;
41370 }
41371 resultobj = SWIG_Py_Void();
41372 return resultobj;
41373 fail:
41374 return NULL;
41375 }
41376
41377
41378 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41379 PyObject *resultobj = 0;
41380 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41381 size_t arg2 ;
41382 bool result;
41383 void *argp1 = 0 ;
41384 int res1 = 0 ;
41385 size_t val2 ;
41386 int ecode2 = 0 ;
41387 PyObject * obj0 = 0 ;
41388 PyObject * obj1 = 0 ;
41389 char * kwnames[] = {
41390 (char *) "self",(char *) "pos", NULL
41391 };
41392
41393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41395 if (!SWIG_IsOK(res1)) {
41396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41397 }
41398 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41399 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41400 if (!SWIG_IsOK(ecode2)) {
41401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41402 }
41403 arg2 = static_cast< size_t >(val2);
41404 {
41405 PyThreadState* __tstate = wxPyBeginAllowThreads();
41406 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41407 wxPyEndAllowThreads(__tstate);
41408 if (PyErr_Occurred()) SWIG_fail;
41409 }
41410 {
41411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41412 }
41413 return resultobj;
41414 fail:
41415 return NULL;
41416 }
41417
41418
41419 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41420 PyObject *resultobj = 0;
41421 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41422 size_t arg2 ;
41423 wxString *arg3 = 0 ;
41424 void *argp1 = 0 ;
41425 int res1 = 0 ;
41426 size_t val2 ;
41427 int ecode2 = 0 ;
41428 bool temp3 = false ;
41429 PyObject * obj0 = 0 ;
41430 PyObject * obj1 = 0 ;
41431 PyObject * obj2 = 0 ;
41432 char * kwnames[] = {
41433 (char *) "self",(char *) "pos",(char *) "label", NULL
41434 };
41435
41436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41438 if (!SWIG_IsOK(res1)) {
41439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41440 }
41441 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41442 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41443 if (!SWIG_IsOK(ecode2)) {
41444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41445 }
41446 arg2 = static_cast< size_t >(val2);
41447 {
41448 arg3 = wxString_in_helper(obj2);
41449 if (arg3 == NULL) SWIG_fail;
41450 temp3 = true;
41451 }
41452 {
41453 PyThreadState* __tstate = wxPyBeginAllowThreads();
41454 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41455 wxPyEndAllowThreads(__tstate);
41456 if (PyErr_Occurred()) SWIG_fail;
41457 }
41458 resultobj = SWIG_Py_Void();
41459 {
41460 if (temp3)
41461 delete arg3;
41462 }
41463 return resultobj;
41464 fail:
41465 {
41466 if (temp3)
41467 delete arg3;
41468 }
41469 return NULL;
41470 }
41471
41472
41473 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41474 PyObject *resultobj = 0;
41475 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41476 size_t arg2 ;
41477 wxString result;
41478 void *argp1 = 0 ;
41479 int res1 = 0 ;
41480 size_t val2 ;
41481 int ecode2 = 0 ;
41482 PyObject * obj0 = 0 ;
41483 PyObject * obj1 = 0 ;
41484 char * kwnames[] = {
41485 (char *) "self",(char *) "pos", NULL
41486 };
41487
41488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41490 if (!SWIG_IsOK(res1)) {
41491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41492 }
41493 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41494 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41495 if (!SWIG_IsOK(ecode2)) {
41496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41497 }
41498 arg2 = static_cast< size_t >(val2);
41499 {
41500 PyThreadState* __tstate = wxPyBeginAllowThreads();
41501 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41502 wxPyEndAllowThreads(__tstate);
41503 if (PyErr_Occurred()) SWIG_fail;
41504 }
41505 {
41506 #if wxUSE_UNICODE
41507 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41508 #else
41509 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41510 #endif
41511 }
41512 return resultobj;
41513 fail:
41514 return NULL;
41515 }
41516
41517
41518 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41519 PyObject *resultobj = 0;
41520 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41521 wxString *arg2 = 0 ;
41522 wxString *arg3 = 0 ;
41523 int result;
41524 void *argp1 = 0 ;
41525 int res1 = 0 ;
41526 bool temp2 = false ;
41527 bool temp3 = false ;
41528 PyObject * obj0 = 0 ;
41529 PyObject * obj1 = 0 ;
41530 PyObject * obj2 = 0 ;
41531 char * kwnames[] = {
41532 (char *) "self",(char *) "menu",(char *) "item", NULL
41533 };
41534
41535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41537 if (!SWIG_IsOK(res1)) {
41538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41539 }
41540 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41541 {
41542 arg2 = wxString_in_helper(obj1);
41543 if (arg2 == NULL) SWIG_fail;
41544 temp2 = true;
41545 }
41546 {
41547 arg3 = wxString_in_helper(obj2);
41548 if (arg3 == NULL) SWIG_fail;
41549 temp3 = true;
41550 }
41551 {
41552 PyThreadState* __tstate = wxPyBeginAllowThreads();
41553 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41554 wxPyEndAllowThreads(__tstate);
41555 if (PyErr_Occurred()) SWIG_fail;
41556 }
41557 resultobj = SWIG_From_int(static_cast< int >(result));
41558 {
41559 if (temp2)
41560 delete arg2;
41561 }
41562 {
41563 if (temp3)
41564 delete arg3;
41565 }
41566 return resultobj;
41567 fail:
41568 {
41569 if (temp2)
41570 delete arg2;
41571 }
41572 {
41573 if (temp3)
41574 delete arg3;
41575 }
41576 return NULL;
41577 }
41578
41579
41580 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41581 PyObject *resultobj = 0;
41582 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41583 int arg2 ;
41584 wxMenuItem *result = 0 ;
41585 void *argp1 = 0 ;
41586 int res1 = 0 ;
41587 int val2 ;
41588 int ecode2 = 0 ;
41589 PyObject * obj0 = 0 ;
41590 PyObject * obj1 = 0 ;
41591 char * kwnames[] = {
41592 (char *) "self",(char *) "id", NULL
41593 };
41594
41595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41597 if (!SWIG_IsOK(res1)) {
41598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41599 }
41600 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41601 ecode2 = SWIG_AsVal_int(obj1, &val2);
41602 if (!SWIG_IsOK(ecode2)) {
41603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41604 }
41605 arg2 = static_cast< int >(val2);
41606 {
41607 PyThreadState* __tstate = wxPyBeginAllowThreads();
41608 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41609 wxPyEndAllowThreads(__tstate);
41610 if (PyErr_Occurred()) SWIG_fail;
41611 }
41612 {
41613 resultobj = wxPyMake_wxObject(result, (bool)0);
41614 }
41615 return resultobj;
41616 fail:
41617 return NULL;
41618 }
41619
41620
41621 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41622 PyObject *resultobj = 0;
41623 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41624 wxString *arg2 = 0 ;
41625 int result;
41626 void *argp1 = 0 ;
41627 int res1 = 0 ;
41628 bool temp2 = false ;
41629 PyObject * obj0 = 0 ;
41630 PyObject * obj1 = 0 ;
41631 char * kwnames[] = {
41632 (char *) "self",(char *) "title", NULL
41633 };
41634
41635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41637 if (!SWIG_IsOK(res1)) {
41638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41639 }
41640 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41641 {
41642 arg2 = wxString_in_helper(obj1);
41643 if (arg2 == NULL) SWIG_fail;
41644 temp2 = true;
41645 }
41646 {
41647 PyThreadState* __tstate = wxPyBeginAllowThreads();
41648 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41649 wxPyEndAllowThreads(__tstate);
41650 if (PyErr_Occurred()) SWIG_fail;
41651 }
41652 resultobj = SWIG_From_int(static_cast< int >(result));
41653 {
41654 if (temp2)
41655 delete arg2;
41656 }
41657 return resultobj;
41658 fail:
41659 {
41660 if (temp2)
41661 delete arg2;
41662 }
41663 return NULL;
41664 }
41665
41666
41667 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41668 PyObject *resultobj = 0;
41669 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41670 int arg2 ;
41671 bool arg3 ;
41672 void *argp1 = 0 ;
41673 int res1 = 0 ;
41674 int val2 ;
41675 int ecode2 = 0 ;
41676 bool val3 ;
41677 int ecode3 = 0 ;
41678 PyObject * obj0 = 0 ;
41679 PyObject * obj1 = 0 ;
41680 PyObject * obj2 = 0 ;
41681 char * kwnames[] = {
41682 (char *) "self",(char *) "id",(char *) "enable", NULL
41683 };
41684
41685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41687 if (!SWIG_IsOK(res1)) {
41688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41689 }
41690 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41691 ecode2 = SWIG_AsVal_int(obj1, &val2);
41692 if (!SWIG_IsOK(ecode2)) {
41693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41694 }
41695 arg2 = static_cast< int >(val2);
41696 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41697 if (!SWIG_IsOK(ecode3)) {
41698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41699 }
41700 arg3 = static_cast< bool >(val3);
41701 {
41702 PyThreadState* __tstate = wxPyBeginAllowThreads();
41703 (arg1)->Enable(arg2,arg3);
41704 wxPyEndAllowThreads(__tstate);
41705 if (PyErr_Occurred()) SWIG_fail;
41706 }
41707 resultobj = SWIG_Py_Void();
41708 return resultobj;
41709 fail:
41710 return NULL;
41711 }
41712
41713
41714 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41715 PyObject *resultobj = 0;
41716 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41717 int arg2 ;
41718 bool arg3 ;
41719 void *argp1 = 0 ;
41720 int res1 = 0 ;
41721 int val2 ;
41722 int ecode2 = 0 ;
41723 bool val3 ;
41724 int ecode3 = 0 ;
41725 PyObject * obj0 = 0 ;
41726 PyObject * obj1 = 0 ;
41727 PyObject * obj2 = 0 ;
41728 char * kwnames[] = {
41729 (char *) "self",(char *) "id",(char *) "check", NULL
41730 };
41731
41732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41734 if (!SWIG_IsOK(res1)) {
41735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41736 }
41737 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41738 ecode2 = SWIG_AsVal_int(obj1, &val2);
41739 if (!SWIG_IsOK(ecode2)) {
41740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41741 }
41742 arg2 = static_cast< int >(val2);
41743 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41744 if (!SWIG_IsOK(ecode3)) {
41745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41746 }
41747 arg3 = static_cast< bool >(val3);
41748 {
41749 PyThreadState* __tstate = wxPyBeginAllowThreads();
41750 (arg1)->Check(arg2,arg3);
41751 wxPyEndAllowThreads(__tstate);
41752 if (PyErr_Occurred()) SWIG_fail;
41753 }
41754 resultobj = SWIG_Py_Void();
41755 return resultobj;
41756 fail:
41757 return NULL;
41758 }
41759
41760
41761 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41762 PyObject *resultobj = 0;
41763 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41764 int arg2 ;
41765 bool result;
41766 void *argp1 = 0 ;
41767 int res1 = 0 ;
41768 int val2 ;
41769 int ecode2 = 0 ;
41770 PyObject * obj0 = 0 ;
41771 PyObject * obj1 = 0 ;
41772 char * kwnames[] = {
41773 (char *) "self",(char *) "id", NULL
41774 };
41775
41776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41778 if (!SWIG_IsOK(res1)) {
41779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41780 }
41781 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41782 ecode2 = SWIG_AsVal_int(obj1, &val2);
41783 if (!SWIG_IsOK(ecode2)) {
41784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41785 }
41786 arg2 = static_cast< int >(val2);
41787 {
41788 PyThreadState* __tstate = wxPyBeginAllowThreads();
41789 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41790 wxPyEndAllowThreads(__tstate);
41791 if (PyErr_Occurred()) SWIG_fail;
41792 }
41793 {
41794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41795 }
41796 return resultobj;
41797 fail:
41798 return NULL;
41799 }
41800
41801
41802 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41803 PyObject *resultobj = 0;
41804 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41805 int arg2 ;
41806 bool result;
41807 void *argp1 = 0 ;
41808 int res1 = 0 ;
41809 int val2 ;
41810 int ecode2 = 0 ;
41811 PyObject * obj0 = 0 ;
41812 PyObject * obj1 = 0 ;
41813 char * kwnames[] = {
41814 (char *) "self",(char *) "id", NULL
41815 };
41816
41817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41819 if (!SWIG_IsOK(res1)) {
41820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41821 }
41822 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41823 ecode2 = SWIG_AsVal_int(obj1, &val2);
41824 if (!SWIG_IsOK(ecode2)) {
41825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41826 }
41827 arg2 = static_cast< int >(val2);
41828 {
41829 PyThreadState* __tstate = wxPyBeginAllowThreads();
41830 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41831 wxPyEndAllowThreads(__tstate);
41832 if (PyErr_Occurred()) SWIG_fail;
41833 }
41834 {
41835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41836 }
41837 return resultobj;
41838 fail:
41839 return NULL;
41840 }
41841
41842
41843 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41844 PyObject *resultobj = 0;
41845 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41846 int arg2 ;
41847 wxString *arg3 = 0 ;
41848 void *argp1 = 0 ;
41849 int res1 = 0 ;
41850 int val2 ;
41851 int ecode2 = 0 ;
41852 bool temp3 = false ;
41853 PyObject * obj0 = 0 ;
41854 PyObject * obj1 = 0 ;
41855 PyObject * obj2 = 0 ;
41856 char * kwnames[] = {
41857 (char *) "self",(char *) "id",(char *) "label", NULL
41858 };
41859
41860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41862 if (!SWIG_IsOK(res1)) {
41863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41864 }
41865 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41866 ecode2 = SWIG_AsVal_int(obj1, &val2);
41867 if (!SWIG_IsOK(ecode2)) {
41868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41869 }
41870 arg2 = static_cast< int >(val2);
41871 {
41872 arg3 = wxString_in_helper(obj2);
41873 if (arg3 == NULL) SWIG_fail;
41874 temp3 = true;
41875 }
41876 {
41877 PyThreadState* __tstate = wxPyBeginAllowThreads();
41878 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41879 wxPyEndAllowThreads(__tstate);
41880 if (PyErr_Occurred()) SWIG_fail;
41881 }
41882 resultobj = SWIG_Py_Void();
41883 {
41884 if (temp3)
41885 delete arg3;
41886 }
41887 return resultobj;
41888 fail:
41889 {
41890 if (temp3)
41891 delete arg3;
41892 }
41893 return NULL;
41894 }
41895
41896
41897 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41898 PyObject *resultobj = 0;
41899 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41900 int arg2 ;
41901 wxString result;
41902 void *argp1 = 0 ;
41903 int res1 = 0 ;
41904 int val2 ;
41905 int ecode2 = 0 ;
41906 PyObject * obj0 = 0 ;
41907 PyObject * obj1 = 0 ;
41908 char * kwnames[] = {
41909 (char *) "self",(char *) "id", NULL
41910 };
41911
41912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41914 if (!SWIG_IsOK(res1)) {
41915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41916 }
41917 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41918 ecode2 = SWIG_AsVal_int(obj1, &val2);
41919 if (!SWIG_IsOK(ecode2)) {
41920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41921 }
41922 arg2 = static_cast< int >(val2);
41923 {
41924 PyThreadState* __tstate = wxPyBeginAllowThreads();
41925 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41926 wxPyEndAllowThreads(__tstate);
41927 if (PyErr_Occurred()) SWIG_fail;
41928 }
41929 {
41930 #if wxUSE_UNICODE
41931 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41932 #else
41933 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41934 #endif
41935 }
41936 return resultobj;
41937 fail:
41938 return NULL;
41939 }
41940
41941
41942 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41943 PyObject *resultobj = 0;
41944 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41945 int arg2 ;
41946 wxString *arg3 = 0 ;
41947 void *argp1 = 0 ;
41948 int res1 = 0 ;
41949 int val2 ;
41950 int ecode2 = 0 ;
41951 bool temp3 = false ;
41952 PyObject * obj0 = 0 ;
41953 PyObject * obj1 = 0 ;
41954 PyObject * obj2 = 0 ;
41955 char * kwnames[] = {
41956 (char *) "self",(char *) "id",(char *) "helpString", NULL
41957 };
41958
41959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41961 if (!SWIG_IsOK(res1)) {
41962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41963 }
41964 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41965 ecode2 = SWIG_AsVal_int(obj1, &val2);
41966 if (!SWIG_IsOK(ecode2)) {
41967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41968 }
41969 arg2 = static_cast< int >(val2);
41970 {
41971 arg3 = wxString_in_helper(obj2);
41972 if (arg3 == NULL) SWIG_fail;
41973 temp3 = true;
41974 }
41975 {
41976 PyThreadState* __tstate = wxPyBeginAllowThreads();
41977 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41978 wxPyEndAllowThreads(__tstate);
41979 if (PyErr_Occurred()) SWIG_fail;
41980 }
41981 resultobj = SWIG_Py_Void();
41982 {
41983 if (temp3)
41984 delete arg3;
41985 }
41986 return resultobj;
41987 fail:
41988 {
41989 if (temp3)
41990 delete arg3;
41991 }
41992 return NULL;
41993 }
41994
41995
41996 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41997 PyObject *resultobj = 0;
41998 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41999 int arg2 ;
42000 wxString result;
42001 void *argp1 = 0 ;
42002 int res1 = 0 ;
42003 int val2 ;
42004 int ecode2 = 0 ;
42005 PyObject * obj0 = 0 ;
42006 PyObject * obj1 = 0 ;
42007 char * kwnames[] = {
42008 (char *) "self",(char *) "id", NULL
42009 };
42010
42011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42013 if (!SWIG_IsOK(res1)) {
42014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42015 }
42016 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42017 ecode2 = SWIG_AsVal_int(obj1, &val2);
42018 if (!SWIG_IsOK(ecode2)) {
42019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42020 }
42021 arg2 = static_cast< int >(val2);
42022 {
42023 PyThreadState* __tstate = wxPyBeginAllowThreads();
42024 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42025 wxPyEndAllowThreads(__tstate);
42026 if (PyErr_Occurred()) SWIG_fail;
42027 }
42028 {
42029 #if wxUSE_UNICODE
42030 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42031 #else
42032 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42033 #endif
42034 }
42035 return resultobj;
42036 fail:
42037 return NULL;
42038 }
42039
42040
42041 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42042 PyObject *resultobj = 0;
42043 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42044 wxFrame *result = 0 ;
42045 void *argp1 = 0 ;
42046 int res1 = 0 ;
42047 PyObject *swig_obj[1] ;
42048
42049 if (!args) SWIG_fail;
42050 swig_obj[0] = args;
42051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42052 if (!SWIG_IsOK(res1)) {
42053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42054 }
42055 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42056 {
42057 PyThreadState* __tstate = wxPyBeginAllowThreads();
42058 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42059 wxPyEndAllowThreads(__tstate);
42060 if (PyErr_Occurred()) SWIG_fail;
42061 }
42062 {
42063 resultobj = wxPyMake_wxObject(result, (bool)0);
42064 }
42065 return resultobj;
42066 fail:
42067 return NULL;
42068 }
42069
42070
42071 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42072 PyObject *resultobj = 0;
42073 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42074 bool result;
42075 void *argp1 = 0 ;
42076 int res1 = 0 ;
42077 PyObject *swig_obj[1] ;
42078
42079 if (!args) SWIG_fail;
42080 swig_obj[0] = args;
42081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42082 if (!SWIG_IsOK(res1)) {
42083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42084 }
42085 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42086 {
42087 PyThreadState* __tstate = wxPyBeginAllowThreads();
42088 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42089 wxPyEndAllowThreads(__tstate);
42090 if (PyErr_Occurred()) SWIG_fail;
42091 }
42092 {
42093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42094 }
42095 return resultobj;
42096 fail:
42097 return NULL;
42098 }
42099
42100
42101 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42102 PyObject *resultobj = 0;
42103 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42104 wxFrame *arg2 = (wxFrame *) 0 ;
42105 void *argp1 = 0 ;
42106 int res1 = 0 ;
42107 void *argp2 = 0 ;
42108 int res2 = 0 ;
42109 PyObject * obj0 = 0 ;
42110 PyObject * obj1 = 0 ;
42111 char * kwnames[] = {
42112 (char *) "self",(char *) "frame", NULL
42113 };
42114
42115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42117 if (!SWIG_IsOK(res1)) {
42118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42119 }
42120 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42121 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42122 if (!SWIG_IsOK(res2)) {
42123 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42124 }
42125 arg2 = reinterpret_cast< wxFrame * >(argp2);
42126 {
42127 PyThreadState* __tstate = wxPyBeginAllowThreads();
42128 (arg1)->Attach(arg2);
42129 wxPyEndAllowThreads(__tstate);
42130 if (PyErr_Occurred()) SWIG_fail;
42131 }
42132 resultobj = SWIG_Py_Void();
42133 return resultobj;
42134 fail:
42135 return NULL;
42136 }
42137
42138
42139 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42140 PyObject *resultobj = 0;
42141 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42142 void *argp1 = 0 ;
42143 int res1 = 0 ;
42144 PyObject *swig_obj[1] ;
42145
42146 if (!args) SWIG_fail;
42147 swig_obj[0] = args;
42148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42149 if (!SWIG_IsOK(res1)) {
42150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42151 }
42152 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42153 {
42154 PyThreadState* __tstate = wxPyBeginAllowThreads();
42155 (arg1)->Detach();
42156 wxPyEndAllowThreads(__tstate);
42157 if (PyErr_Occurred()) SWIG_fail;
42158 }
42159 resultobj = SWIG_Py_Void();
42160 return resultobj;
42161 fail:
42162 return NULL;
42163 }
42164
42165
42166 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42167 PyObject *resultobj = 0;
42168 bool arg1 ;
42169 bool val1 ;
42170 int ecode1 = 0 ;
42171 PyObject * obj0 = 0 ;
42172 char * kwnames[] = {
42173 (char *) "enable", NULL
42174 };
42175
42176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42177 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42178 if (!SWIG_IsOK(ecode1)) {
42179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42180 }
42181 arg1 = static_cast< bool >(val1);
42182 {
42183 PyThreadState* __tstate = wxPyBeginAllowThreads();
42184 wxMenuBar_SetAutoWindowMenu(arg1);
42185 wxPyEndAllowThreads(__tstate);
42186 if (PyErr_Occurred()) SWIG_fail;
42187 }
42188 resultobj = SWIG_Py_Void();
42189 return resultobj;
42190 fail:
42191 return NULL;
42192 }
42193
42194
42195 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42196 PyObject *resultobj = 0;
42197 bool result;
42198
42199 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42200 {
42201 PyThreadState* __tstate = wxPyBeginAllowThreads();
42202 result = (bool)wxMenuBar_GetAutoWindowMenu();
42203 wxPyEndAllowThreads(__tstate);
42204 if (PyErr_Occurred()) SWIG_fail;
42205 }
42206 {
42207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42208 }
42209 return resultobj;
42210 fail:
42211 return NULL;
42212 }
42213
42214
42215 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42216 PyObject *obj;
42217 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42218 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42219 return SWIG_Py_Void();
42220 }
42221
42222 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42223 return SWIG_Python_InitShadowInstance(args);
42224 }
42225
42226 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42227 PyObject *resultobj = 0;
42228 wxMenu *arg1 = (wxMenu *) NULL ;
42229 int arg2 = (int) wxID_ANY ;
42230 wxString const &arg3_defvalue = wxPyEmptyString ;
42231 wxString *arg3 = (wxString *) &arg3_defvalue ;
42232 wxString const &arg4_defvalue = wxPyEmptyString ;
42233 wxString *arg4 = (wxString *) &arg4_defvalue ;
42234 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42235 wxMenu *arg6 = (wxMenu *) NULL ;
42236 wxMenuItem *result = 0 ;
42237 void *argp1 = 0 ;
42238 int res1 = 0 ;
42239 int val2 ;
42240 int ecode2 = 0 ;
42241 bool temp3 = false ;
42242 bool temp4 = false ;
42243 int val5 ;
42244 int ecode5 = 0 ;
42245 void *argp6 = 0 ;
42246 int res6 = 0 ;
42247 PyObject * obj0 = 0 ;
42248 PyObject * obj1 = 0 ;
42249 PyObject * obj2 = 0 ;
42250 PyObject * obj3 = 0 ;
42251 PyObject * obj4 = 0 ;
42252 PyObject * obj5 = 0 ;
42253 char * kwnames[] = {
42254 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42255 };
42256
42257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42258 if (obj0) {
42259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42260 if (!SWIG_IsOK(res1)) {
42261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42262 }
42263 arg1 = reinterpret_cast< wxMenu * >(argp1);
42264 }
42265 if (obj1) {
42266 ecode2 = SWIG_AsVal_int(obj1, &val2);
42267 if (!SWIG_IsOK(ecode2)) {
42268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42269 }
42270 arg2 = static_cast< int >(val2);
42271 }
42272 if (obj2) {
42273 {
42274 arg3 = wxString_in_helper(obj2);
42275 if (arg3 == NULL) SWIG_fail;
42276 temp3 = true;
42277 }
42278 }
42279 if (obj3) {
42280 {
42281 arg4 = wxString_in_helper(obj3);
42282 if (arg4 == NULL) SWIG_fail;
42283 temp4 = true;
42284 }
42285 }
42286 if (obj4) {
42287 ecode5 = SWIG_AsVal_int(obj4, &val5);
42288 if (!SWIG_IsOK(ecode5)) {
42289 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42290 }
42291 arg5 = static_cast< wxItemKind >(val5);
42292 }
42293 if (obj5) {
42294 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42295 if (!SWIG_IsOK(res6)) {
42296 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42297 }
42298 arg6 = reinterpret_cast< wxMenu * >(argp6);
42299 }
42300 {
42301 PyThreadState* __tstate = wxPyBeginAllowThreads();
42302 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42303 wxPyEndAllowThreads(__tstate);
42304 if (PyErr_Occurred()) SWIG_fail;
42305 }
42306 {
42307 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42308 }
42309 {
42310 if (temp3)
42311 delete arg3;
42312 }
42313 {
42314 if (temp4)
42315 delete arg4;
42316 }
42317 return resultobj;
42318 fail:
42319 {
42320 if (temp3)
42321 delete arg3;
42322 }
42323 {
42324 if (temp4)
42325 delete arg4;
42326 }
42327 return NULL;
42328 }
42329
42330
42331 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42332 PyObject *resultobj = 0;
42333 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42334 void *argp1 = 0 ;
42335 int res1 = 0 ;
42336 PyObject *swig_obj[1] ;
42337
42338 if (!args) SWIG_fail;
42339 swig_obj[0] = args;
42340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42341 if (!SWIG_IsOK(res1)) {
42342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42343 }
42344 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42345 {
42346 PyThreadState* __tstate = wxPyBeginAllowThreads();
42347 delete arg1;
42348
42349 wxPyEndAllowThreads(__tstate);
42350 if (PyErr_Occurred()) SWIG_fail;
42351 }
42352 resultobj = SWIG_Py_Void();
42353 return resultobj;
42354 fail:
42355 return NULL;
42356 }
42357
42358
42359 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42360 PyObject *resultobj = 0;
42361 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42362 wxMenu *result = 0 ;
42363 void *argp1 = 0 ;
42364 int res1 = 0 ;
42365 PyObject *swig_obj[1] ;
42366
42367 if (!args) SWIG_fail;
42368 swig_obj[0] = args;
42369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42370 if (!SWIG_IsOK(res1)) {
42371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42372 }
42373 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42374 {
42375 PyThreadState* __tstate = wxPyBeginAllowThreads();
42376 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42377 wxPyEndAllowThreads(__tstate);
42378 if (PyErr_Occurred()) SWIG_fail;
42379 }
42380 {
42381 resultobj = wxPyMake_wxObject(result, 0);
42382 }
42383 return resultobj;
42384 fail:
42385 return NULL;
42386 }
42387
42388
42389 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42390 PyObject *resultobj = 0;
42391 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42392 wxMenu *arg2 = (wxMenu *) 0 ;
42393 void *argp1 = 0 ;
42394 int res1 = 0 ;
42395 void *argp2 = 0 ;
42396 int res2 = 0 ;
42397 PyObject * obj0 = 0 ;
42398 PyObject * obj1 = 0 ;
42399 char * kwnames[] = {
42400 (char *) "self",(char *) "menu", NULL
42401 };
42402
42403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42405 if (!SWIG_IsOK(res1)) {
42406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42407 }
42408 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42409 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42410 if (!SWIG_IsOK(res2)) {
42411 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42412 }
42413 arg2 = reinterpret_cast< wxMenu * >(argp2);
42414 {
42415 PyThreadState* __tstate = wxPyBeginAllowThreads();
42416 (arg1)->SetMenu(arg2);
42417 wxPyEndAllowThreads(__tstate);
42418 if (PyErr_Occurred()) SWIG_fail;
42419 }
42420 resultobj = SWIG_Py_Void();
42421 return resultobj;
42422 fail:
42423 return NULL;
42424 }
42425
42426
42427 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42428 PyObject *resultobj = 0;
42429 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42430 int arg2 ;
42431 void *argp1 = 0 ;
42432 int res1 = 0 ;
42433 int val2 ;
42434 int ecode2 = 0 ;
42435 PyObject * obj0 = 0 ;
42436 PyObject * obj1 = 0 ;
42437 char * kwnames[] = {
42438 (char *) "self",(char *) "id", NULL
42439 };
42440
42441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42443 if (!SWIG_IsOK(res1)) {
42444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42445 }
42446 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42447 ecode2 = SWIG_AsVal_int(obj1, &val2);
42448 if (!SWIG_IsOK(ecode2)) {
42449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42450 }
42451 arg2 = static_cast< int >(val2);
42452 {
42453 PyThreadState* __tstate = wxPyBeginAllowThreads();
42454 (arg1)->SetId(arg2);
42455 wxPyEndAllowThreads(__tstate);
42456 if (PyErr_Occurred()) SWIG_fail;
42457 }
42458 resultobj = SWIG_Py_Void();
42459 return resultobj;
42460 fail:
42461 return NULL;
42462 }
42463
42464
42465 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42466 PyObject *resultobj = 0;
42467 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42468 int result;
42469 void *argp1 = 0 ;
42470 int res1 = 0 ;
42471 PyObject *swig_obj[1] ;
42472
42473 if (!args) SWIG_fail;
42474 swig_obj[0] = args;
42475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42476 if (!SWIG_IsOK(res1)) {
42477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42478 }
42479 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42480 {
42481 PyThreadState* __tstate = wxPyBeginAllowThreads();
42482 result = (int)((wxMenuItem const *)arg1)->GetId();
42483 wxPyEndAllowThreads(__tstate);
42484 if (PyErr_Occurred()) SWIG_fail;
42485 }
42486 resultobj = SWIG_From_int(static_cast< int >(result));
42487 return resultobj;
42488 fail:
42489 return NULL;
42490 }
42491
42492
42493 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42494 PyObject *resultobj = 0;
42495 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42496 bool result;
42497 void *argp1 = 0 ;
42498 int res1 = 0 ;
42499 PyObject *swig_obj[1] ;
42500
42501 if (!args) SWIG_fail;
42502 swig_obj[0] = args;
42503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42504 if (!SWIG_IsOK(res1)) {
42505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42506 }
42507 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42508 {
42509 PyThreadState* __tstate = wxPyBeginAllowThreads();
42510 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42511 wxPyEndAllowThreads(__tstate);
42512 if (PyErr_Occurred()) SWIG_fail;
42513 }
42514 {
42515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42516 }
42517 return resultobj;
42518 fail:
42519 return NULL;
42520 }
42521
42522
42523 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42524 PyObject *resultobj = 0;
42525 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42526 wxString *arg2 = 0 ;
42527 void *argp1 = 0 ;
42528 int res1 = 0 ;
42529 bool temp2 = false ;
42530 PyObject * obj0 = 0 ;
42531 PyObject * obj1 = 0 ;
42532 char * kwnames[] = {
42533 (char *) "self",(char *) "str", NULL
42534 };
42535
42536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42538 if (!SWIG_IsOK(res1)) {
42539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42540 }
42541 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42542 {
42543 arg2 = wxString_in_helper(obj1);
42544 if (arg2 == NULL) SWIG_fail;
42545 temp2 = true;
42546 }
42547 {
42548 PyThreadState* __tstate = wxPyBeginAllowThreads();
42549 (arg1)->SetText((wxString const &)*arg2);
42550 wxPyEndAllowThreads(__tstate);
42551 if (PyErr_Occurred()) SWIG_fail;
42552 }
42553 resultobj = SWIG_Py_Void();
42554 {
42555 if (temp2)
42556 delete arg2;
42557 }
42558 return resultobj;
42559 fail:
42560 {
42561 if (temp2)
42562 delete arg2;
42563 }
42564 return NULL;
42565 }
42566
42567
42568 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42569 PyObject *resultobj = 0;
42570 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42571 wxString result;
42572 void *argp1 = 0 ;
42573 int res1 = 0 ;
42574 PyObject *swig_obj[1] ;
42575
42576 if (!args) SWIG_fail;
42577 swig_obj[0] = args;
42578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42579 if (!SWIG_IsOK(res1)) {
42580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42581 }
42582 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42583 {
42584 PyThreadState* __tstate = wxPyBeginAllowThreads();
42585 result = ((wxMenuItem const *)arg1)->GetLabel();
42586 wxPyEndAllowThreads(__tstate);
42587 if (PyErr_Occurred()) SWIG_fail;
42588 }
42589 {
42590 #if wxUSE_UNICODE
42591 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42592 #else
42593 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42594 #endif
42595 }
42596 return resultobj;
42597 fail:
42598 return NULL;
42599 }
42600
42601
42602 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42603 PyObject *resultobj = 0;
42604 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42605 wxString *result = 0 ;
42606 void *argp1 = 0 ;
42607 int res1 = 0 ;
42608 PyObject *swig_obj[1] ;
42609
42610 if (!args) SWIG_fail;
42611 swig_obj[0] = args;
42612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42613 if (!SWIG_IsOK(res1)) {
42614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42615 }
42616 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42617 {
42618 PyThreadState* __tstate = wxPyBeginAllowThreads();
42619 {
42620 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42621 result = (wxString *) &_result_ref;
42622 }
42623 wxPyEndAllowThreads(__tstate);
42624 if (PyErr_Occurred()) SWIG_fail;
42625 }
42626 {
42627 #if wxUSE_UNICODE
42628 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42629 #else
42630 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42631 #endif
42632 }
42633 return resultobj;
42634 fail:
42635 return NULL;
42636 }
42637
42638
42639 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42640 PyObject *resultobj = 0;
42641 wxString *arg1 = 0 ;
42642 wxString result;
42643 bool temp1 = false ;
42644 PyObject * obj0 = 0 ;
42645 char * kwnames[] = {
42646 (char *) "text", NULL
42647 };
42648
42649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42650 {
42651 arg1 = wxString_in_helper(obj0);
42652 if (arg1 == NULL) SWIG_fail;
42653 temp1 = true;
42654 }
42655 {
42656 PyThreadState* __tstate = wxPyBeginAllowThreads();
42657 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42658 wxPyEndAllowThreads(__tstate);
42659 if (PyErr_Occurred()) SWIG_fail;
42660 }
42661 {
42662 #if wxUSE_UNICODE
42663 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42664 #else
42665 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42666 #endif
42667 }
42668 {
42669 if (temp1)
42670 delete arg1;
42671 }
42672 return resultobj;
42673 fail:
42674 {
42675 if (temp1)
42676 delete arg1;
42677 }
42678 return NULL;
42679 }
42680
42681
42682 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42683 PyObject *resultobj = 0;
42684 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42685 wxItemKind result;
42686 void *argp1 = 0 ;
42687 int res1 = 0 ;
42688 PyObject *swig_obj[1] ;
42689
42690 if (!args) SWIG_fail;
42691 swig_obj[0] = args;
42692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42693 if (!SWIG_IsOK(res1)) {
42694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42695 }
42696 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42697 {
42698 PyThreadState* __tstate = wxPyBeginAllowThreads();
42699 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42700 wxPyEndAllowThreads(__tstate);
42701 if (PyErr_Occurred()) SWIG_fail;
42702 }
42703 resultobj = SWIG_From_int(static_cast< int >(result));
42704 return resultobj;
42705 fail:
42706 return NULL;
42707 }
42708
42709
42710 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42711 PyObject *resultobj = 0;
42712 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42713 wxItemKind arg2 ;
42714 void *argp1 = 0 ;
42715 int res1 = 0 ;
42716 int val2 ;
42717 int ecode2 = 0 ;
42718 PyObject * obj0 = 0 ;
42719 PyObject * obj1 = 0 ;
42720 char * kwnames[] = {
42721 (char *) "self",(char *) "kind", NULL
42722 };
42723
42724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42726 if (!SWIG_IsOK(res1)) {
42727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42728 }
42729 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42730 ecode2 = SWIG_AsVal_int(obj1, &val2);
42731 if (!SWIG_IsOK(ecode2)) {
42732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42733 }
42734 arg2 = static_cast< wxItemKind >(val2);
42735 {
42736 PyThreadState* __tstate = wxPyBeginAllowThreads();
42737 (arg1)->SetKind(arg2);
42738 wxPyEndAllowThreads(__tstate);
42739 if (PyErr_Occurred()) SWIG_fail;
42740 }
42741 resultobj = SWIG_Py_Void();
42742 return resultobj;
42743 fail:
42744 return NULL;
42745 }
42746
42747
42748 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42749 PyObject *resultobj = 0;
42750 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42751 bool arg2 ;
42752 void *argp1 = 0 ;
42753 int res1 = 0 ;
42754 bool val2 ;
42755 int ecode2 = 0 ;
42756 PyObject * obj0 = 0 ;
42757 PyObject * obj1 = 0 ;
42758 char * kwnames[] = {
42759 (char *) "self",(char *) "checkable", NULL
42760 };
42761
42762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42764 if (!SWIG_IsOK(res1)) {
42765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42766 }
42767 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42768 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42769 if (!SWIG_IsOK(ecode2)) {
42770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42771 }
42772 arg2 = static_cast< bool >(val2);
42773 {
42774 PyThreadState* __tstate = wxPyBeginAllowThreads();
42775 (arg1)->SetCheckable(arg2);
42776 wxPyEndAllowThreads(__tstate);
42777 if (PyErr_Occurred()) SWIG_fail;
42778 }
42779 resultobj = SWIG_Py_Void();
42780 return resultobj;
42781 fail:
42782 return NULL;
42783 }
42784
42785
42786 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42787 PyObject *resultobj = 0;
42788 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42789 bool result;
42790 void *argp1 = 0 ;
42791 int res1 = 0 ;
42792 PyObject *swig_obj[1] ;
42793
42794 if (!args) SWIG_fail;
42795 swig_obj[0] = args;
42796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42797 if (!SWIG_IsOK(res1)) {
42798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42799 }
42800 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42801 {
42802 PyThreadState* __tstate = wxPyBeginAllowThreads();
42803 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42804 wxPyEndAllowThreads(__tstate);
42805 if (PyErr_Occurred()) SWIG_fail;
42806 }
42807 {
42808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42809 }
42810 return resultobj;
42811 fail:
42812 return NULL;
42813 }
42814
42815
42816 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42817 PyObject *resultobj = 0;
42818 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42819 bool result;
42820 void *argp1 = 0 ;
42821 int res1 = 0 ;
42822 PyObject *swig_obj[1] ;
42823
42824 if (!args) SWIG_fail;
42825 swig_obj[0] = args;
42826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42827 if (!SWIG_IsOK(res1)) {
42828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42829 }
42830 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42831 {
42832 PyThreadState* __tstate = wxPyBeginAllowThreads();
42833 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42834 wxPyEndAllowThreads(__tstate);
42835 if (PyErr_Occurred()) SWIG_fail;
42836 }
42837 {
42838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42839 }
42840 return resultobj;
42841 fail:
42842 return NULL;
42843 }
42844
42845
42846 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42847 PyObject *resultobj = 0;
42848 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42849 wxMenu *arg2 = (wxMenu *) 0 ;
42850 void *argp1 = 0 ;
42851 int res1 = 0 ;
42852 void *argp2 = 0 ;
42853 int res2 = 0 ;
42854 PyObject * obj0 = 0 ;
42855 PyObject * obj1 = 0 ;
42856 char * kwnames[] = {
42857 (char *) "self",(char *) "menu", NULL
42858 };
42859
42860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42862 if (!SWIG_IsOK(res1)) {
42863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42864 }
42865 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42866 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42867 if (!SWIG_IsOK(res2)) {
42868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42869 }
42870 arg2 = reinterpret_cast< wxMenu * >(argp2);
42871 {
42872 PyThreadState* __tstate = wxPyBeginAllowThreads();
42873 (arg1)->SetSubMenu(arg2);
42874 wxPyEndAllowThreads(__tstate);
42875 if (PyErr_Occurred()) SWIG_fail;
42876 }
42877 resultobj = SWIG_Py_Void();
42878 return resultobj;
42879 fail:
42880 return NULL;
42881 }
42882
42883
42884 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42885 PyObject *resultobj = 0;
42886 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42887 wxMenu *result = 0 ;
42888 void *argp1 = 0 ;
42889 int res1 = 0 ;
42890 PyObject *swig_obj[1] ;
42891
42892 if (!args) SWIG_fail;
42893 swig_obj[0] = args;
42894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42895 if (!SWIG_IsOK(res1)) {
42896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42897 }
42898 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42899 {
42900 PyThreadState* __tstate = wxPyBeginAllowThreads();
42901 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42902 wxPyEndAllowThreads(__tstate);
42903 if (PyErr_Occurred()) SWIG_fail;
42904 }
42905 {
42906 resultobj = wxPyMake_wxObject(result, 0);
42907 }
42908 return resultobj;
42909 fail:
42910 return NULL;
42911 }
42912
42913
42914 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42915 PyObject *resultobj = 0;
42916 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42917 bool arg2 = (bool) true ;
42918 void *argp1 = 0 ;
42919 int res1 = 0 ;
42920 bool val2 ;
42921 int ecode2 = 0 ;
42922 PyObject * obj0 = 0 ;
42923 PyObject * obj1 = 0 ;
42924 char * kwnames[] = {
42925 (char *) "self",(char *) "enable", NULL
42926 };
42927
42928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42930 if (!SWIG_IsOK(res1)) {
42931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42932 }
42933 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42934 if (obj1) {
42935 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42936 if (!SWIG_IsOK(ecode2)) {
42937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42938 }
42939 arg2 = static_cast< bool >(val2);
42940 }
42941 {
42942 PyThreadState* __tstate = wxPyBeginAllowThreads();
42943 (arg1)->Enable(arg2);
42944 wxPyEndAllowThreads(__tstate);
42945 if (PyErr_Occurred()) SWIG_fail;
42946 }
42947 resultobj = SWIG_Py_Void();
42948 return resultobj;
42949 fail:
42950 return NULL;
42951 }
42952
42953
42954 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42955 PyObject *resultobj = 0;
42956 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42957 bool result;
42958 void *argp1 = 0 ;
42959 int res1 = 0 ;
42960 PyObject *swig_obj[1] ;
42961
42962 if (!args) SWIG_fail;
42963 swig_obj[0] = args;
42964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42965 if (!SWIG_IsOK(res1)) {
42966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42967 }
42968 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42969 {
42970 PyThreadState* __tstate = wxPyBeginAllowThreads();
42971 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42972 wxPyEndAllowThreads(__tstate);
42973 if (PyErr_Occurred()) SWIG_fail;
42974 }
42975 {
42976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42977 }
42978 return resultobj;
42979 fail:
42980 return NULL;
42981 }
42982
42983
42984 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42985 PyObject *resultobj = 0;
42986 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42987 bool arg2 = (bool) true ;
42988 void *argp1 = 0 ;
42989 int res1 = 0 ;
42990 bool val2 ;
42991 int ecode2 = 0 ;
42992 PyObject * obj0 = 0 ;
42993 PyObject * obj1 = 0 ;
42994 char * kwnames[] = {
42995 (char *) "self",(char *) "check", NULL
42996 };
42997
42998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43000 if (!SWIG_IsOK(res1)) {
43001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43002 }
43003 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43004 if (obj1) {
43005 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43006 if (!SWIG_IsOK(ecode2)) {
43007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43008 }
43009 arg2 = static_cast< bool >(val2);
43010 }
43011 {
43012 PyThreadState* __tstate = wxPyBeginAllowThreads();
43013 (arg1)->Check(arg2);
43014 wxPyEndAllowThreads(__tstate);
43015 if (PyErr_Occurred()) SWIG_fail;
43016 }
43017 resultobj = SWIG_Py_Void();
43018 return resultobj;
43019 fail:
43020 return NULL;
43021 }
43022
43023
43024 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43025 PyObject *resultobj = 0;
43026 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43027 bool result;
43028 void *argp1 = 0 ;
43029 int res1 = 0 ;
43030 PyObject *swig_obj[1] ;
43031
43032 if (!args) SWIG_fail;
43033 swig_obj[0] = args;
43034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43035 if (!SWIG_IsOK(res1)) {
43036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43037 }
43038 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43039 {
43040 PyThreadState* __tstate = wxPyBeginAllowThreads();
43041 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43042 wxPyEndAllowThreads(__tstate);
43043 if (PyErr_Occurred()) SWIG_fail;
43044 }
43045 {
43046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43047 }
43048 return resultobj;
43049 fail:
43050 return NULL;
43051 }
43052
43053
43054 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43055 PyObject *resultobj = 0;
43056 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43057 void *argp1 = 0 ;
43058 int res1 = 0 ;
43059 PyObject *swig_obj[1] ;
43060
43061 if (!args) SWIG_fail;
43062 swig_obj[0] = args;
43063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43064 if (!SWIG_IsOK(res1)) {
43065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43066 }
43067 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43068 {
43069 PyThreadState* __tstate = wxPyBeginAllowThreads();
43070 (arg1)->Toggle();
43071 wxPyEndAllowThreads(__tstate);
43072 if (PyErr_Occurred()) SWIG_fail;
43073 }
43074 resultobj = SWIG_Py_Void();
43075 return resultobj;
43076 fail:
43077 return NULL;
43078 }
43079
43080
43081 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43082 PyObject *resultobj = 0;
43083 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43084 wxString *arg2 = 0 ;
43085 void *argp1 = 0 ;
43086 int res1 = 0 ;
43087 bool temp2 = false ;
43088 PyObject * obj0 = 0 ;
43089 PyObject * obj1 = 0 ;
43090 char * kwnames[] = {
43091 (char *) "self",(char *) "str", NULL
43092 };
43093
43094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43096 if (!SWIG_IsOK(res1)) {
43097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43098 }
43099 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43100 {
43101 arg2 = wxString_in_helper(obj1);
43102 if (arg2 == NULL) SWIG_fail;
43103 temp2 = true;
43104 }
43105 {
43106 PyThreadState* __tstate = wxPyBeginAllowThreads();
43107 (arg1)->SetHelp((wxString const &)*arg2);
43108 wxPyEndAllowThreads(__tstate);
43109 if (PyErr_Occurred()) SWIG_fail;
43110 }
43111 resultobj = SWIG_Py_Void();
43112 {
43113 if (temp2)
43114 delete arg2;
43115 }
43116 return resultobj;
43117 fail:
43118 {
43119 if (temp2)
43120 delete arg2;
43121 }
43122 return NULL;
43123 }
43124
43125
43126 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43127 PyObject *resultobj = 0;
43128 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43129 wxString *result = 0 ;
43130 void *argp1 = 0 ;
43131 int res1 = 0 ;
43132 PyObject *swig_obj[1] ;
43133
43134 if (!args) SWIG_fail;
43135 swig_obj[0] = args;
43136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43137 if (!SWIG_IsOK(res1)) {
43138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43139 }
43140 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43141 {
43142 PyThreadState* __tstate = wxPyBeginAllowThreads();
43143 {
43144 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43145 result = (wxString *) &_result_ref;
43146 }
43147 wxPyEndAllowThreads(__tstate);
43148 if (PyErr_Occurred()) SWIG_fail;
43149 }
43150 {
43151 #if wxUSE_UNICODE
43152 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43153 #else
43154 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43155 #endif
43156 }
43157 return resultobj;
43158 fail:
43159 return NULL;
43160 }
43161
43162
43163 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43164 PyObject *resultobj = 0;
43165 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43166 wxAcceleratorEntry *result = 0 ;
43167 void *argp1 = 0 ;
43168 int res1 = 0 ;
43169 PyObject *swig_obj[1] ;
43170
43171 if (!args) SWIG_fail;
43172 swig_obj[0] = args;
43173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43174 if (!SWIG_IsOK(res1)) {
43175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43176 }
43177 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43178 {
43179 PyThreadState* __tstate = wxPyBeginAllowThreads();
43180 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43181 wxPyEndAllowThreads(__tstate);
43182 if (PyErr_Occurred()) SWIG_fail;
43183 }
43184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43185 return resultobj;
43186 fail:
43187 return NULL;
43188 }
43189
43190
43191 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43192 PyObject *resultobj = 0;
43193 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43194 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43195 void *argp1 = 0 ;
43196 int res1 = 0 ;
43197 void *argp2 = 0 ;
43198 int res2 = 0 ;
43199 PyObject * obj0 = 0 ;
43200 PyObject * obj1 = 0 ;
43201 char * kwnames[] = {
43202 (char *) "self",(char *) "accel", NULL
43203 };
43204
43205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43207 if (!SWIG_IsOK(res1)) {
43208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43209 }
43210 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43211 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43212 if (!SWIG_IsOK(res2)) {
43213 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43214 }
43215 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43216 {
43217 PyThreadState* __tstate = wxPyBeginAllowThreads();
43218 (arg1)->SetAccel(arg2);
43219 wxPyEndAllowThreads(__tstate);
43220 if (PyErr_Occurred()) SWIG_fail;
43221 }
43222 resultobj = SWIG_Py_Void();
43223 return resultobj;
43224 fail:
43225 return NULL;
43226 }
43227
43228
43229 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43230 PyObject *resultobj = 0;
43231 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43232 wxBitmap *arg2 = 0 ;
43233 void *argp1 = 0 ;
43234 int res1 = 0 ;
43235 void *argp2 = 0 ;
43236 int res2 = 0 ;
43237 PyObject * obj0 = 0 ;
43238 PyObject * obj1 = 0 ;
43239 char * kwnames[] = {
43240 (char *) "self",(char *) "bitmap", NULL
43241 };
43242
43243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43245 if (!SWIG_IsOK(res1)) {
43246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43247 }
43248 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43249 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43250 if (!SWIG_IsOK(res2)) {
43251 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43252 }
43253 if (!argp2) {
43254 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43255 }
43256 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43257 {
43258 PyThreadState* __tstate = wxPyBeginAllowThreads();
43259 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43260 wxPyEndAllowThreads(__tstate);
43261 if (PyErr_Occurred()) SWIG_fail;
43262 }
43263 resultobj = SWIG_Py_Void();
43264 return resultobj;
43265 fail:
43266 return NULL;
43267 }
43268
43269
43270 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43271 PyObject *resultobj = 0;
43272 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43273 wxBitmap *result = 0 ;
43274 void *argp1 = 0 ;
43275 int res1 = 0 ;
43276 PyObject *swig_obj[1] ;
43277
43278 if (!args) SWIG_fail;
43279 swig_obj[0] = args;
43280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43281 if (!SWIG_IsOK(res1)) {
43282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43283 }
43284 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43285 {
43286 PyThreadState* __tstate = wxPyBeginAllowThreads();
43287 {
43288 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43289 result = (wxBitmap *) &_result_ref;
43290 }
43291 wxPyEndAllowThreads(__tstate);
43292 if (PyErr_Occurred()) SWIG_fail;
43293 }
43294 {
43295 wxBitmap* resultptr = new wxBitmap(*result);
43296 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43297 }
43298 return resultobj;
43299 fail:
43300 return NULL;
43301 }
43302
43303
43304 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43305 PyObject *resultobj = 0;
43306 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43307 wxFont *arg2 = 0 ;
43308 void *argp1 = 0 ;
43309 int res1 = 0 ;
43310 void *argp2 = 0 ;
43311 int res2 = 0 ;
43312 PyObject * obj0 = 0 ;
43313 PyObject * obj1 = 0 ;
43314 char * kwnames[] = {
43315 (char *) "self",(char *) "font", NULL
43316 };
43317
43318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43320 if (!SWIG_IsOK(res1)) {
43321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43322 }
43323 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43324 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43325 if (!SWIG_IsOK(res2)) {
43326 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43327 }
43328 if (!argp2) {
43329 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43330 }
43331 arg2 = reinterpret_cast< wxFont * >(argp2);
43332 {
43333 PyThreadState* __tstate = wxPyBeginAllowThreads();
43334 (arg1)->SetFont((wxFont const &)*arg2);
43335 wxPyEndAllowThreads(__tstate);
43336 if (PyErr_Occurred()) SWIG_fail;
43337 }
43338 resultobj = SWIG_Py_Void();
43339 return resultobj;
43340 fail:
43341 return NULL;
43342 }
43343
43344
43345 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43346 PyObject *resultobj = 0;
43347 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43348 wxFont result;
43349 void *argp1 = 0 ;
43350 int res1 = 0 ;
43351 PyObject *swig_obj[1] ;
43352
43353 if (!args) SWIG_fail;
43354 swig_obj[0] = args;
43355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43356 if (!SWIG_IsOK(res1)) {
43357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43358 }
43359 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43360 {
43361 PyThreadState* __tstate = wxPyBeginAllowThreads();
43362 result = (arg1)->GetFont();
43363 wxPyEndAllowThreads(__tstate);
43364 if (PyErr_Occurred()) SWIG_fail;
43365 }
43366 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43367 return resultobj;
43368 fail:
43369 return NULL;
43370 }
43371
43372
43373 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43374 PyObject *resultobj = 0;
43375 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43376 wxColour *arg2 = 0 ;
43377 void *argp1 = 0 ;
43378 int res1 = 0 ;
43379 wxColour temp2 ;
43380 PyObject * obj0 = 0 ;
43381 PyObject * obj1 = 0 ;
43382 char * kwnames[] = {
43383 (char *) "self",(char *) "colText", NULL
43384 };
43385
43386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43388 if (!SWIG_IsOK(res1)) {
43389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43390 }
43391 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43392 {
43393 arg2 = &temp2;
43394 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43395 }
43396 {
43397 PyThreadState* __tstate = wxPyBeginAllowThreads();
43398 (arg1)->SetTextColour((wxColour const &)*arg2);
43399 wxPyEndAllowThreads(__tstate);
43400 if (PyErr_Occurred()) SWIG_fail;
43401 }
43402 resultobj = SWIG_Py_Void();
43403 return resultobj;
43404 fail:
43405 return NULL;
43406 }
43407
43408
43409 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43410 PyObject *resultobj = 0;
43411 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43412 wxColour result;
43413 void *argp1 = 0 ;
43414 int res1 = 0 ;
43415 PyObject *swig_obj[1] ;
43416
43417 if (!args) SWIG_fail;
43418 swig_obj[0] = args;
43419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43420 if (!SWIG_IsOK(res1)) {
43421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43422 }
43423 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43424 {
43425 PyThreadState* __tstate = wxPyBeginAllowThreads();
43426 result = (arg1)->GetTextColour();
43427 wxPyEndAllowThreads(__tstate);
43428 if (PyErr_Occurred()) SWIG_fail;
43429 }
43430 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43431 return resultobj;
43432 fail:
43433 return NULL;
43434 }
43435
43436
43437 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43438 PyObject *resultobj = 0;
43439 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43440 wxColour *arg2 = 0 ;
43441 void *argp1 = 0 ;
43442 int res1 = 0 ;
43443 wxColour temp2 ;
43444 PyObject * obj0 = 0 ;
43445 PyObject * obj1 = 0 ;
43446 char * kwnames[] = {
43447 (char *) "self",(char *) "colBack", NULL
43448 };
43449
43450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43452 if (!SWIG_IsOK(res1)) {
43453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43454 }
43455 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43456 {
43457 arg2 = &temp2;
43458 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43459 }
43460 {
43461 PyThreadState* __tstate = wxPyBeginAllowThreads();
43462 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
43463 wxPyEndAllowThreads(__tstate);
43464 if (PyErr_Occurred()) SWIG_fail;
43465 }
43466 resultobj = SWIG_Py_Void();
43467 return resultobj;
43468 fail:
43469 return NULL;
43470 }
43471
43472
43473 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43474 PyObject *resultobj = 0;
43475 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43476 wxColour result;
43477 void *argp1 = 0 ;
43478 int res1 = 0 ;
43479 PyObject *swig_obj[1] ;
43480
43481 if (!args) SWIG_fail;
43482 swig_obj[0] = args;
43483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43484 if (!SWIG_IsOK(res1)) {
43485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43486 }
43487 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43488 {
43489 PyThreadState* __tstate = wxPyBeginAllowThreads();
43490 result = (arg1)->GetBackgroundColour();
43491 wxPyEndAllowThreads(__tstate);
43492 if (PyErr_Occurred()) SWIG_fail;
43493 }
43494 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43495 return resultobj;
43496 fail:
43497 return NULL;
43498 }
43499
43500
43501 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43502 PyObject *resultobj = 0;
43503 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43504 wxBitmap *arg2 = 0 ;
43505 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43506 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43507 void *argp1 = 0 ;
43508 int res1 = 0 ;
43509 void *argp2 = 0 ;
43510 int res2 = 0 ;
43511 void *argp3 = 0 ;
43512 int res3 = 0 ;
43513 PyObject * obj0 = 0 ;
43514 PyObject * obj1 = 0 ;
43515 PyObject * obj2 = 0 ;
43516 char * kwnames[] = {
43517 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43518 };
43519
43520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43522 if (!SWIG_IsOK(res1)) {
43523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43524 }
43525 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43526 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43527 if (!SWIG_IsOK(res2)) {
43528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43529 }
43530 if (!argp2) {
43531 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43532 }
43533 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43534 if (obj2) {
43535 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43536 if (!SWIG_IsOK(res3)) {
43537 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43538 }
43539 if (!argp3) {
43540 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43541 }
43542 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43543 }
43544 {
43545 PyThreadState* __tstate = wxPyBeginAllowThreads();
43546 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43547 wxPyEndAllowThreads(__tstate);
43548 if (PyErr_Occurred()) SWIG_fail;
43549 }
43550 resultobj = SWIG_Py_Void();
43551 return resultobj;
43552 fail:
43553 return NULL;
43554 }
43555
43556
43557 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43558 PyObject *resultobj = 0;
43559 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43560 wxBitmap *arg2 = 0 ;
43561 void *argp1 = 0 ;
43562 int res1 = 0 ;
43563 void *argp2 = 0 ;
43564 int res2 = 0 ;
43565 PyObject * obj0 = 0 ;
43566 PyObject * obj1 = 0 ;
43567 char * kwnames[] = {
43568 (char *) "self",(char *) "bmpDisabled", NULL
43569 };
43570
43571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43573 if (!SWIG_IsOK(res1)) {
43574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43575 }
43576 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43577 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43578 if (!SWIG_IsOK(res2)) {
43579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43580 }
43581 if (!argp2) {
43582 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43583 }
43584 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43585 {
43586 PyThreadState* __tstate = wxPyBeginAllowThreads();
43587 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
43588 wxPyEndAllowThreads(__tstate);
43589 if (PyErr_Occurred()) SWIG_fail;
43590 }
43591 resultobj = SWIG_Py_Void();
43592 return resultobj;
43593 fail:
43594 return NULL;
43595 }
43596
43597
43598 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43599 PyObject *resultobj = 0;
43600 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43601 wxBitmap *result = 0 ;
43602 void *argp1 = 0 ;
43603 int res1 = 0 ;
43604 PyObject *swig_obj[1] ;
43605
43606 if (!args) SWIG_fail;
43607 swig_obj[0] = args;
43608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43609 if (!SWIG_IsOK(res1)) {
43610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43611 }
43612 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43613 {
43614 PyThreadState* __tstate = wxPyBeginAllowThreads();
43615 {
43616 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
43617 result = (wxBitmap *) &_result_ref;
43618 }
43619 wxPyEndAllowThreads(__tstate);
43620 if (PyErr_Occurred()) SWIG_fail;
43621 }
43622 {
43623 wxBitmap* resultptr = new wxBitmap(*result);
43624 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43625 }
43626 return resultobj;
43627 fail:
43628 return NULL;
43629 }
43630
43631
43632 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43633 PyObject *resultobj = 0;
43634 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43635 int arg2 ;
43636 void *argp1 = 0 ;
43637 int res1 = 0 ;
43638 int val2 ;
43639 int ecode2 = 0 ;
43640 PyObject * obj0 = 0 ;
43641 PyObject * obj1 = 0 ;
43642 char * kwnames[] = {
43643 (char *) "self",(char *) "nWidth", NULL
43644 };
43645
43646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43648 if (!SWIG_IsOK(res1)) {
43649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43650 }
43651 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43652 ecode2 = SWIG_AsVal_int(obj1, &val2);
43653 if (!SWIG_IsOK(ecode2)) {
43654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43655 }
43656 arg2 = static_cast< int >(val2);
43657 {
43658 PyThreadState* __tstate = wxPyBeginAllowThreads();
43659 (arg1)->SetMarginWidth(arg2);
43660 wxPyEndAllowThreads(__tstate);
43661 if (PyErr_Occurred()) SWIG_fail;
43662 }
43663 resultobj = SWIG_Py_Void();
43664 return resultobj;
43665 fail:
43666 return NULL;
43667 }
43668
43669
43670 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43671 PyObject *resultobj = 0;
43672 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43673 int result;
43674 void *argp1 = 0 ;
43675 int res1 = 0 ;
43676 PyObject *swig_obj[1] ;
43677
43678 if (!args) SWIG_fail;
43679 swig_obj[0] = args;
43680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43681 if (!SWIG_IsOK(res1)) {
43682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43683 }
43684 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43685 {
43686 PyThreadState* __tstate = wxPyBeginAllowThreads();
43687 result = (int)(arg1)->GetMarginWidth();
43688 wxPyEndAllowThreads(__tstate);
43689 if (PyErr_Occurred()) SWIG_fail;
43690 }
43691 resultobj = SWIG_From_int(static_cast< int >(result));
43692 return resultobj;
43693 fail:
43694 return NULL;
43695 }
43696
43697
43698 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43699 PyObject *resultobj = 0;
43700 int result;
43701
43702 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43703 {
43704 PyThreadState* __tstate = wxPyBeginAllowThreads();
43705 result = (int)wxMenuItem::GetDefaultMarginWidth();
43706 wxPyEndAllowThreads(__tstate);
43707 if (PyErr_Occurred()) SWIG_fail;
43708 }
43709 resultobj = SWIG_From_int(static_cast< int >(result));
43710 return resultobj;
43711 fail:
43712 return NULL;
43713 }
43714
43715
43716 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43717 PyObject *resultobj = 0;
43718 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43719 bool result;
43720 void *argp1 = 0 ;
43721 int res1 = 0 ;
43722 PyObject *swig_obj[1] ;
43723
43724 if (!args) SWIG_fail;
43725 swig_obj[0] = args;
43726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43727 if (!SWIG_IsOK(res1)) {
43728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43729 }
43730 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43731 {
43732 PyThreadState* __tstate = wxPyBeginAllowThreads();
43733 result = (bool)(arg1)->IsOwnerDrawn();
43734 wxPyEndAllowThreads(__tstate);
43735 if (PyErr_Occurred()) SWIG_fail;
43736 }
43737 {
43738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43739 }
43740 return resultobj;
43741 fail:
43742 return NULL;
43743 }
43744
43745
43746 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43747 PyObject *resultobj = 0;
43748 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43749 bool arg2 = (bool) true ;
43750 void *argp1 = 0 ;
43751 int res1 = 0 ;
43752 bool val2 ;
43753 int ecode2 = 0 ;
43754 PyObject * obj0 = 0 ;
43755 PyObject * obj1 = 0 ;
43756 char * kwnames[] = {
43757 (char *) "self",(char *) "ownerDrawn", NULL
43758 };
43759
43760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43762 if (!SWIG_IsOK(res1)) {
43763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43764 }
43765 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43766 if (obj1) {
43767 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43768 if (!SWIG_IsOK(ecode2)) {
43769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43770 }
43771 arg2 = static_cast< bool >(val2);
43772 }
43773 {
43774 PyThreadState* __tstate = wxPyBeginAllowThreads();
43775 (arg1)->SetOwnerDrawn(arg2);
43776 wxPyEndAllowThreads(__tstate);
43777 if (PyErr_Occurred()) SWIG_fail;
43778 }
43779 resultobj = SWIG_Py_Void();
43780 return resultobj;
43781 fail:
43782 return NULL;
43783 }
43784
43785
43786 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43787 PyObject *resultobj = 0;
43788 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43789 void *argp1 = 0 ;
43790 int res1 = 0 ;
43791 PyObject *swig_obj[1] ;
43792
43793 if (!args) SWIG_fail;
43794 swig_obj[0] = args;
43795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43796 if (!SWIG_IsOK(res1)) {
43797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43798 }
43799 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43800 {
43801 PyThreadState* __tstate = wxPyBeginAllowThreads();
43802 (arg1)->ResetOwnerDrawn();
43803 wxPyEndAllowThreads(__tstate);
43804 if (PyErr_Occurred()) SWIG_fail;
43805 }
43806 resultobj = SWIG_Py_Void();
43807 return resultobj;
43808 fail:
43809 return NULL;
43810 }
43811
43812
43813 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43814 PyObject *obj;
43815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43816 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43817 return SWIG_Py_Void();
43818 }
43819
43820 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43821 return SWIG_Python_InitShadowInstance(args);
43822 }
43823
43824 SWIGINTERN int ControlNameStr_set(PyObject *) {
43825 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43826 return 1;
43827 }
43828
43829
43830 SWIGINTERN PyObject *ControlNameStr_get(void) {
43831 PyObject *pyobj = 0;
43832
43833 {
43834 #if wxUSE_UNICODE
43835 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43836 #else
43837 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43838 #endif
43839 }
43840 return pyobj;
43841 }
43842
43843
43844 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43845 PyObject *resultobj = 0;
43846 wxWindow *arg1 = (wxWindow *) 0 ;
43847 int arg2 = (int) -1 ;
43848 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43849 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43850 wxSize const &arg4_defvalue = wxDefaultSize ;
43851 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43852 long arg5 = (long) 0 ;
43853 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43854 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43855 wxString const &arg7_defvalue = wxPyControlNameStr ;
43856 wxString *arg7 = (wxString *) &arg7_defvalue ;
43857 wxControl *result = 0 ;
43858 void *argp1 = 0 ;
43859 int res1 = 0 ;
43860 int val2 ;
43861 int ecode2 = 0 ;
43862 wxPoint temp3 ;
43863 wxSize temp4 ;
43864 long val5 ;
43865 int ecode5 = 0 ;
43866 void *argp6 = 0 ;
43867 int res6 = 0 ;
43868 bool temp7 = false ;
43869 PyObject * obj0 = 0 ;
43870 PyObject * obj1 = 0 ;
43871 PyObject * obj2 = 0 ;
43872 PyObject * obj3 = 0 ;
43873 PyObject * obj4 = 0 ;
43874 PyObject * obj5 = 0 ;
43875 PyObject * obj6 = 0 ;
43876 char * kwnames[] = {
43877 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43878 };
43879
43880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43882 if (!SWIG_IsOK(res1)) {
43883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43884 }
43885 arg1 = reinterpret_cast< wxWindow * >(argp1);
43886 if (obj1) {
43887 ecode2 = SWIG_AsVal_int(obj1, &val2);
43888 if (!SWIG_IsOK(ecode2)) {
43889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43890 }
43891 arg2 = static_cast< int >(val2);
43892 }
43893 if (obj2) {
43894 {
43895 arg3 = &temp3;
43896 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43897 }
43898 }
43899 if (obj3) {
43900 {
43901 arg4 = &temp4;
43902 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43903 }
43904 }
43905 if (obj4) {
43906 ecode5 = SWIG_AsVal_long(obj4, &val5);
43907 if (!SWIG_IsOK(ecode5)) {
43908 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43909 }
43910 arg5 = static_cast< long >(val5);
43911 }
43912 if (obj5) {
43913 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43914 if (!SWIG_IsOK(res6)) {
43915 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43916 }
43917 if (!argp6) {
43918 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43919 }
43920 arg6 = reinterpret_cast< wxValidator * >(argp6);
43921 }
43922 if (obj6) {
43923 {
43924 arg7 = wxString_in_helper(obj6);
43925 if (arg7 == NULL) SWIG_fail;
43926 temp7 = true;
43927 }
43928 }
43929 {
43930 if (!wxPyCheckForApp()) SWIG_fail;
43931 PyThreadState* __tstate = wxPyBeginAllowThreads();
43932 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43933 wxPyEndAllowThreads(__tstate);
43934 if (PyErr_Occurred()) SWIG_fail;
43935 }
43936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43937 {
43938 if (temp7)
43939 delete arg7;
43940 }
43941 return resultobj;
43942 fail:
43943 {
43944 if (temp7)
43945 delete arg7;
43946 }
43947 return NULL;
43948 }
43949
43950
43951 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43952 PyObject *resultobj = 0;
43953 wxControl *result = 0 ;
43954
43955 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43956 {
43957 if (!wxPyCheckForApp()) SWIG_fail;
43958 PyThreadState* __tstate = wxPyBeginAllowThreads();
43959 result = (wxControl *)new wxControl();
43960 wxPyEndAllowThreads(__tstate);
43961 if (PyErr_Occurred()) SWIG_fail;
43962 }
43963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43964 return resultobj;
43965 fail:
43966 return NULL;
43967 }
43968
43969
43970 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43971 PyObject *resultobj = 0;
43972 wxControl *arg1 = (wxControl *) 0 ;
43973 wxWindow *arg2 = (wxWindow *) 0 ;
43974 int arg3 = (int) -1 ;
43975 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43976 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43977 wxSize const &arg5_defvalue = wxDefaultSize ;
43978 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43979 long arg6 = (long) 0 ;
43980 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43981 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43982 wxString const &arg8_defvalue = wxPyControlNameStr ;
43983 wxString *arg8 = (wxString *) &arg8_defvalue ;
43984 bool result;
43985 void *argp1 = 0 ;
43986 int res1 = 0 ;
43987 void *argp2 = 0 ;
43988 int res2 = 0 ;
43989 int val3 ;
43990 int ecode3 = 0 ;
43991 wxPoint temp4 ;
43992 wxSize temp5 ;
43993 long val6 ;
43994 int ecode6 = 0 ;
43995 void *argp7 = 0 ;
43996 int res7 = 0 ;
43997 bool temp8 = false ;
43998 PyObject * obj0 = 0 ;
43999 PyObject * obj1 = 0 ;
44000 PyObject * obj2 = 0 ;
44001 PyObject * obj3 = 0 ;
44002 PyObject * obj4 = 0 ;
44003 PyObject * obj5 = 0 ;
44004 PyObject * obj6 = 0 ;
44005 PyObject * obj7 = 0 ;
44006 char * kwnames[] = {
44007 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44008 };
44009
44010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44012 if (!SWIG_IsOK(res1)) {
44013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44014 }
44015 arg1 = reinterpret_cast< wxControl * >(argp1);
44016 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44017 if (!SWIG_IsOK(res2)) {
44018 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44019 }
44020 arg2 = reinterpret_cast< wxWindow * >(argp2);
44021 if (obj2) {
44022 ecode3 = SWIG_AsVal_int(obj2, &val3);
44023 if (!SWIG_IsOK(ecode3)) {
44024 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44025 }
44026 arg3 = static_cast< int >(val3);
44027 }
44028 if (obj3) {
44029 {
44030 arg4 = &temp4;
44031 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44032 }
44033 }
44034 if (obj4) {
44035 {
44036 arg5 = &temp5;
44037 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44038 }
44039 }
44040 if (obj5) {
44041 ecode6 = SWIG_AsVal_long(obj5, &val6);
44042 if (!SWIG_IsOK(ecode6)) {
44043 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44044 }
44045 arg6 = static_cast< long >(val6);
44046 }
44047 if (obj6) {
44048 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44049 if (!SWIG_IsOK(res7)) {
44050 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44051 }
44052 if (!argp7) {
44053 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44054 }
44055 arg7 = reinterpret_cast< wxValidator * >(argp7);
44056 }
44057 if (obj7) {
44058 {
44059 arg8 = wxString_in_helper(obj7);
44060 if (arg8 == NULL) SWIG_fail;
44061 temp8 = true;
44062 }
44063 }
44064 {
44065 PyThreadState* __tstate = wxPyBeginAllowThreads();
44066 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44067 wxPyEndAllowThreads(__tstate);
44068 if (PyErr_Occurred()) SWIG_fail;
44069 }
44070 {
44071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44072 }
44073 {
44074 if (temp8)
44075 delete arg8;
44076 }
44077 return resultobj;
44078 fail:
44079 {
44080 if (temp8)
44081 delete arg8;
44082 }
44083 return NULL;
44084 }
44085
44086
44087 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44088 PyObject *resultobj = 0;
44089 wxControl *arg1 = (wxControl *) 0 ;
44090 wxCommandEvent *arg2 = 0 ;
44091 void *argp1 = 0 ;
44092 int res1 = 0 ;
44093 void *argp2 = 0 ;
44094 int res2 = 0 ;
44095 PyObject * obj0 = 0 ;
44096 PyObject * obj1 = 0 ;
44097 char * kwnames[] = {
44098 (char *) "self",(char *) "event", NULL
44099 };
44100
44101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44103 if (!SWIG_IsOK(res1)) {
44104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44105 }
44106 arg1 = reinterpret_cast< wxControl * >(argp1);
44107 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44108 if (!SWIG_IsOK(res2)) {
44109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44110 }
44111 if (!argp2) {
44112 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44113 }
44114 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44115 {
44116 PyThreadState* __tstate = wxPyBeginAllowThreads();
44117 (arg1)->Command(*arg2);
44118 wxPyEndAllowThreads(__tstate);
44119 if (PyErr_Occurred()) SWIG_fail;
44120 }
44121 resultobj = SWIG_Py_Void();
44122 return resultobj;
44123 fail:
44124 return NULL;
44125 }
44126
44127
44128 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44129 PyObject *resultobj = 0;
44130 wxControl *arg1 = (wxControl *) 0 ;
44131 wxString result;
44132 void *argp1 = 0 ;
44133 int res1 = 0 ;
44134 PyObject *swig_obj[1] ;
44135
44136 if (!args) SWIG_fail;
44137 swig_obj[0] = args;
44138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44139 if (!SWIG_IsOK(res1)) {
44140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44141 }
44142 arg1 = reinterpret_cast< wxControl * >(argp1);
44143 {
44144 PyThreadState* __tstate = wxPyBeginAllowThreads();
44145 result = (arg1)->GetLabel();
44146 wxPyEndAllowThreads(__tstate);
44147 if (PyErr_Occurred()) SWIG_fail;
44148 }
44149 {
44150 #if wxUSE_UNICODE
44151 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44152 #else
44153 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44154 #endif
44155 }
44156 return resultobj;
44157 fail:
44158 return NULL;
44159 }
44160
44161
44162 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44163 PyObject *resultobj = 0;
44164 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44165 SwigValueWrapper<wxVisualAttributes > result;
44166 int val1 ;
44167 int ecode1 = 0 ;
44168 PyObject * obj0 = 0 ;
44169 char * kwnames[] = {
44170 (char *) "variant", NULL
44171 };
44172
44173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44174 if (obj0) {
44175 ecode1 = SWIG_AsVal_int(obj0, &val1);
44176 if (!SWIG_IsOK(ecode1)) {
44177 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44178 }
44179 arg1 = static_cast< wxWindowVariant >(val1);
44180 }
44181 {
44182 if (!wxPyCheckForApp()) SWIG_fail;
44183 PyThreadState* __tstate = wxPyBeginAllowThreads();
44184 result = wxControl::GetClassDefaultAttributes(arg1);
44185 wxPyEndAllowThreads(__tstate);
44186 if (PyErr_Occurred()) SWIG_fail;
44187 }
44188 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44189 return resultobj;
44190 fail:
44191 return NULL;
44192 }
44193
44194
44195 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44196 PyObject *obj;
44197 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44198 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44199 return SWIG_Py_Void();
44200 }
44201
44202 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44203 return SWIG_Python_InitShadowInstance(args);
44204 }
44205
44206 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44207 PyObject *resultobj = 0;
44208 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44209 wxString *arg2 = 0 ;
44210 PyObject *arg3 = (PyObject *) NULL ;
44211 int result;
44212 void *argp1 = 0 ;
44213 int res1 = 0 ;
44214 bool temp2 = false ;
44215 PyObject * obj0 = 0 ;
44216 PyObject * obj1 = 0 ;
44217 PyObject * obj2 = 0 ;
44218 char * kwnames[] = {
44219 (char *) "self",(char *) "item",(char *) "clientData", NULL
44220 };
44221
44222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44224 if (!SWIG_IsOK(res1)) {
44225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44226 }
44227 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44228 {
44229 arg2 = wxString_in_helper(obj1);
44230 if (arg2 == NULL) SWIG_fail;
44231 temp2 = true;
44232 }
44233 if (obj2) {
44234 arg3 = obj2;
44235 }
44236 {
44237 PyThreadState* __tstate = wxPyBeginAllowThreads();
44238 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44239 wxPyEndAllowThreads(__tstate);
44240 if (PyErr_Occurred()) SWIG_fail;
44241 }
44242 resultobj = SWIG_From_int(static_cast< int >(result));
44243 {
44244 if (temp2)
44245 delete arg2;
44246 }
44247 return resultobj;
44248 fail:
44249 {
44250 if (temp2)
44251 delete arg2;
44252 }
44253 return NULL;
44254 }
44255
44256
44257 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44258 PyObject *resultobj = 0;
44259 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44260 wxArrayString *arg2 = 0 ;
44261 void *argp1 = 0 ;
44262 int res1 = 0 ;
44263 bool temp2 = false ;
44264 PyObject * obj0 = 0 ;
44265 PyObject * obj1 = 0 ;
44266 char * kwnames[] = {
44267 (char *) "self",(char *) "strings", NULL
44268 };
44269
44270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44272 if (!SWIG_IsOK(res1)) {
44273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44274 }
44275 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44276 {
44277 if (! PySequence_Check(obj1)) {
44278 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44279 SWIG_fail;
44280 }
44281 arg2 = new wxArrayString;
44282 temp2 = true;
44283 int i, len=PySequence_Length(obj1);
44284 for (i=0; i<len; i++) {
44285 PyObject* item = PySequence_GetItem(obj1, i);
44286 wxString* s = wxString_in_helper(item);
44287 if (PyErr_Occurred()) SWIG_fail;
44288 arg2->Add(*s);
44289 delete s;
44290 Py_DECREF(item);
44291 }
44292 }
44293 {
44294 PyThreadState* __tstate = wxPyBeginAllowThreads();
44295 (arg1)->Append((wxArrayString const &)*arg2);
44296 wxPyEndAllowThreads(__tstate);
44297 if (PyErr_Occurred()) SWIG_fail;
44298 }
44299 resultobj = SWIG_Py_Void();
44300 {
44301 if (temp2) delete arg2;
44302 }
44303 return resultobj;
44304 fail:
44305 {
44306 if (temp2) delete arg2;
44307 }
44308 return NULL;
44309 }
44310
44311
44312 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44313 PyObject *resultobj = 0;
44314 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44315 wxString *arg2 = 0 ;
44316 unsigned int arg3 ;
44317 PyObject *arg4 = (PyObject *) NULL ;
44318 int result;
44319 void *argp1 = 0 ;
44320 int res1 = 0 ;
44321 bool temp2 = false ;
44322 unsigned int val3 ;
44323 int ecode3 = 0 ;
44324 PyObject * obj0 = 0 ;
44325 PyObject * obj1 = 0 ;
44326 PyObject * obj2 = 0 ;
44327 PyObject * obj3 = 0 ;
44328 char * kwnames[] = {
44329 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44330 };
44331
44332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44334 if (!SWIG_IsOK(res1)) {
44335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44336 }
44337 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44338 {
44339 arg2 = wxString_in_helper(obj1);
44340 if (arg2 == NULL) SWIG_fail;
44341 temp2 = true;
44342 }
44343 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44344 if (!SWIG_IsOK(ecode3)) {
44345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44346 }
44347 arg3 = static_cast< unsigned int >(val3);
44348 if (obj3) {
44349 arg4 = obj3;
44350 }
44351 {
44352 PyThreadState* __tstate = wxPyBeginAllowThreads();
44353 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44354 wxPyEndAllowThreads(__tstate);
44355 if (PyErr_Occurred()) SWIG_fail;
44356 }
44357 resultobj = SWIG_From_int(static_cast< int >(result));
44358 {
44359 if (temp2)
44360 delete arg2;
44361 }
44362 return resultobj;
44363 fail:
44364 {
44365 if (temp2)
44366 delete arg2;
44367 }
44368 return NULL;
44369 }
44370
44371
44372 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44373 PyObject *resultobj = 0;
44374 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44375 void *argp1 = 0 ;
44376 int res1 = 0 ;
44377 PyObject *swig_obj[1] ;
44378
44379 if (!args) SWIG_fail;
44380 swig_obj[0] = args;
44381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44382 if (!SWIG_IsOK(res1)) {
44383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44384 }
44385 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44386 {
44387 PyThreadState* __tstate = wxPyBeginAllowThreads();
44388 (arg1)->Clear();
44389 wxPyEndAllowThreads(__tstate);
44390 if (PyErr_Occurred()) SWIG_fail;
44391 }
44392 resultobj = SWIG_Py_Void();
44393 return resultobj;
44394 fail:
44395 return NULL;
44396 }
44397
44398
44399 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44400 PyObject *resultobj = 0;
44401 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44402 unsigned int arg2 ;
44403 void *argp1 = 0 ;
44404 int res1 = 0 ;
44405 unsigned int val2 ;
44406 int ecode2 = 0 ;
44407 PyObject * obj0 = 0 ;
44408 PyObject * obj1 = 0 ;
44409 char * kwnames[] = {
44410 (char *) "self",(char *) "n", NULL
44411 };
44412
44413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44415 if (!SWIG_IsOK(res1)) {
44416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44417 }
44418 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44419 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44420 if (!SWIG_IsOK(ecode2)) {
44421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44422 }
44423 arg2 = static_cast< unsigned int >(val2);
44424 {
44425 PyThreadState* __tstate = wxPyBeginAllowThreads();
44426 (arg1)->Delete(arg2);
44427 wxPyEndAllowThreads(__tstate);
44428 if (PyErr_Occurred()) SWIG_fail;
44429 }
44430 resultobj = SWIG_Py_Void();
44431 return resultobj;
44432 fail:
44433 return NULL;
44434 }
44435
44436
44437 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44438 PyObject *resultobj = 0;
44439 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44440 unsigned int arg2 ;
44441 PyObject *result = 0 ;
44442 void *argp1 = 0 ;
44443 int res1 = 0 ;
44444 unsigned int val2 ;
44445 int ecode2 = 0 ;
44446 PyObject * obj0 = 0 ;
44447 PyObject * obj1 = 0 ;
44448 char * kwnames[] = {
44449 (char *) "self",(char *) "n", NULL
44450 };
44451
44452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44454 if (!SWIG_IsOK(res1)) {
44455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44456 }
44457 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44458 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44459 if (!SWIG_IsOK(ecode2)) {
44460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44461 }
44462 arg2 = static_cast< unsigned int >(val2);
44463 {
44464 PyThreadState* __tstate = wxPyBeginAllowThreads();
44465 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44466 wxPyEndAllowThreads(__tstate);
44467 if (PyErr_Occurred()) SWIG_fail;
44468 }
44469 resultobj = result;
44470 return resultobj;
44471 fail:
44472 return NULL;
44473 }
44474
44475
44476 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44477 PyObject *resultobj = 0;
44478 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44479 unsigned int arg2 ;
44480 PyObject *arg3 = (PyObject *) 0 ;
44481 void *argp1 = 0 ;
44482 int res1 = 0 ;
44483 unsigned int val2 ;
44484 int ecode2 = 0 ;
44485 PyObject * obj0 = 0 ;
44486 PyObject * obj1 = 0 ;
44487 PyObject * obj2 = 0 ;
44488 char * kwnames[] = {
44489 (char *) "self",(char *) "n",(char *) "clientData", NULL
44490 };
44491
44492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44494 if (!SWIG_IsOK(res1)) {
44495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44496 }
44497 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44498 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44499 if (!SWIG_IsOK(ecode2)) {
44500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44501 }
44502 arg2 = static_cast< unsigned int >(val2);
44503 arg3 = obj2;
44504 {
44505 PyThreadState* __tstate = wxPyBeginAllowThreads();
44506 wxItemContainer_SetClientData(arg1,arg2,arg3);
44507 wxPyEndAllowThreads(__tstate);
44508 if (PyErr_Occurred()) SWIG_fail;
44509 }
44510 resultobj = SWIG_Py_Void();
44511 return resultobj;
44512 fail:
44513 return NULL;
44514 }
44515
44516
44517 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44518 PyObject *resultobj = 0;
44519 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44520 unsigned int result;
44521 void *argp1 = 0 ;
44522 int res1 = 0 ;
44523 PyObject *swig_obj[1] ;
44524
44525 if (!args) SWIG_fail;
44526 swig_obj[0] = args;
44527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44528 if (!SWIG_IsOK(res1)) {
44529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44530 }
44531 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44532 {
44533 PyThreadState* __tstate = wxPyBeginAllowThreads();
44534 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44535 wxPyEndAllowThreads(__tstate);
44536 if (PyErr_Occurred()) SWIG_fail;
44537 }
44538 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44539 return resultobj;
44540 fail:
44541 return NULL;
44542 }
44543
44544
44545 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44546 PyObject *resultobj = 0;
44547 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44548 bool result;
44549 void *argp1 = 0 ;
44550 int res1 = 0 ;
44551 PyObject *swig_obj[1] ;
44552
44553 if (!args) SWIG_fail;
44554 swig_obj[0] = args;
44555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44556 if (!SWIG_IsOK(res1)) {
44557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44558 }
44559 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44560 {
44561 PyThreadState* __tstate = wxPyBeginAllowThreads();
44562 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44563 wxPyEndAllowThreads(__tstate);
44564 if (PyErr_Occurred()) SWIG_fail;
44565 }
44566 {
44567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44568 }
44569 return resultobj;
44570 fail:
44571 return NULL;
44572 }
44573
44574
44575 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44576 PyObject *resultobj = 0;
44577 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44578 unsigned int arg2 ;
44579 wxString result;
44580 void *argp1 = 0 ;
44581 int res1 = 0 ;
44582 unsigned int val2 ;
44583 int ecode2 = 0 ;
44584 PyObject * obj0 = 0 ;
44585 PyObject * obj1 = 0 ;
44586 char * kwnames[] = {
44587 (char *) "self",(char *) "n", NULL
44588 };
44589
44590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44592 if (!SWIG_IsOK(res1)) {
44593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44594 }
44595 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44596 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44597 if (!SWIG_IsOK(ecode2)) {
44598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44599 }
44600 arg2 = static_cast< unsigned int >(val2);
44601 {
44602 PyThreadState* __tstate = wxPyBeginAllowThreads();
44603 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44604 wxPyEndAllowThreads(__tstate);
44605 if (PyErr_Occurred()) SWIG_fail;
44606 }
44607 {
44608 #if wxUSE_UNICODE
44609 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44610 #else
44611 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44612 #endif
44613 }
44614 return resultobj;
44615 fail:
44616 return NULL;
44617 }
44618
44619
44620 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44621 PyObject *resultobj = 0;
44622 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44623 wxArrayString result;
44624 void *argp1 = 0 ;
44625 int res1 = 0 ;
44626 PyObject *swig_obj[1] ;
44627
44628 if (!args) SWIG_fail;
44629 swig_obj[0] = args;
44630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44631 if (!SWIG_IsOK(res1)) {
44632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44633 }
44634 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44635 {
44636 PyThreadState* __tstate = wxPyBeginAllowThreads();
44637 result = ((wxItemContainer const *)arg1)->GetStrings();
44638 wxPyEndAllowThreads(__tstate);
44639 if (PyErr_Occurred()) SWIG_fail;
44640 }
44641 {
44642 resultobj = wxArrayString2PyList_helper(result);
44643 }
44644 return resultobj;
44645 fail:
44646 return NULL;
44647 }
44648
44649
44650 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44651 PyObject *resultobj = 0;
44652 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44653 unsigned int arg2 ;
44654 wxString *arg3 = 0 ;
44655 void *argp1 = 0 ;
44656 int res1 = 0 ;
44657 unsigned int val2 ;
44658 int ecode2 = 0 ;
44659 bool temp3 = false ;
44660 PyObject * obj0 = 0 ;
44661 PyObject * obj1 = 0 ;
44662 PyObject * obj2 = 0 ;
44663 char * kwnames[] = {
44664 (char *) "self",(char *) "n",(char *) "s", NULL
44665 };
44666
44667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44669 if (!SWIG_IsOK(res1)) {
44670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44671 }
44672 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44673 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44674 if (!SWIG_IsOK(ecode2)) {
44675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44676 }
44677 arg2 = static_cast< unsigned int >(val2);
44678 {
44679 arg3 = wxString_in_helper(obj2);
44680 if (arg3 == NULL) SWIG_fail;
44681 temp3 = true;
44682 }
44683 {
44684 PyThreadState* __tstate = wxPyBeginAllowThreads();
44685 (arg1)->SetString(arg2,(wxString const &)*arg3);
44686 wxPyEndAllowThreads(__tstate);
44687 if (PyErr_Occurred()) SWIG_fail;
44688 }
44689 resultobj = SWIG_Py_Void();
44690 {
44691 if (temp3)
44692 delete arg3;
44693 }
44694 return resultobj;
44695 fail:
44696 {
44697 if (temp3)
44698 delete arg3;
44699 }
44700 return NULL;
44701 }
44702
44703
44704 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44705 PyObject *resultobj = 0;
44706 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44707 wxString *arg2 = 0 ;
44708 int result;
44709 void *argp1 = 0 ;
44710 int res1 = 0 ;
44711 bool temp2 = false ;
44712 PyObject * obj0 = 0 ;
44713 PyObject * obj1 = 0 ;
44714 char * kwnames[] = {
44715 (char *) "self",(char *) "s", NULL
44716 };
44717
44718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44720 if (!SWIG_IsOK(res1)) {
44721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44722 }
44723 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44724 {
44725 arg2 = wxString_in_helper(obj1);
44726 if (arg2 == NULL) SWIG_fail;
44727 temp2 = true;
44728 }
44729 {
44730 PyThreadState* __tstate = wxPyBeginAllowThreads();
44731 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44732 wxPyEndAllowThreads(__tstate);
44733 if (PyErr_Occurred()) SWIG_fail;
44734 }
44735 resultobj = SWIG_From_int(static_cast< int >(result));
44736 {
44737 if (temp2)
44738 delete arg2;
44739 }
44740 return resultobj;
44741 fail:
44742 {
44743 if (temp2)
44744 delete arg2;
44745 }
44746 return NULL;
44747 }
44748
44749
44750 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44751 PyObject *resultobj = 0;
44752 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44753 int arg2 ;
44754 void *argp1 = 0 ;
44755 int res1 = 0 ;
44756 int val2 ;
44757 int ecode2 = 0 ;
44758 PyObject * obj0 = 0 ;
44759 PyObject * obj1 = 0 ;
44760 char * kwnames[] = {
44761 (char *) "self",(char *) "n", NULL
44762 };
44763
44764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44766 if (!SWIG_IsOK(res1)) {
44767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44768 }
44769 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44770 ecode2 = SWIG_AsVal_int(obj1, &val2);
44771 if (!SWIG_IsOK(ecode2)) {
44772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44773 }
44774 arg2 = static_cast< int >(val2);
44775 {
44776 PyThreadState* __tstate = wxPyBeginAllowThreads();
44777 (arg1)->SetSelection(arg2);
44778 wxPyEndAllowThreads(__tstate);
44779 if (PyErr_Occurred()) SWIG_fail;
44780 }
44781 resultobj = SWIG_Py_Void();
44782 return resultobj;
44783 fail:
44784 return NULL;
44785 }
44786
44787
44788 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44789 PyObject *resultobj = 0;
44790 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44791 int result;
44792 void *argp1 = 0 ;
44793 int res1 = 0 ;
44794 PyObject *swig_obj[1] ;
44795
44796 if (!args) SWIG_fail;
44797 swig_obj[0] = args;
44798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44799 if (!SWIG_IsOK(res1)) {
44800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44801 }
44802 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44803 {
44804 PyThreadState* __tstate = wxPyBeginAllowThreads();
44805 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44806 wxPyEndAllowThreads(__tstate);
44807 if (PyErr_Occurred()) SWIG_fail;
44808 }
44809 resultobj = SWIG_From_int(static_cast< int >(result));
44810 return resultobj;
44811 fail:
44812 return NULL;
44813 }
44814
44815
44816 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44817 PyObject *resultobj = 0;
44818 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44819 wxString *arg2 = 0 ;
44820 bool result;
44821 void *argp1 = 0 ;
44822 int res1 = 0 ;
44823 bool temp2 = false ;
44824 PyObject * obj0 = 0 ;
44825 PyObject * obj1 = 0 ;
44826 char * kwnames[] = {
44827 (char *) "self",(char *) "s", NULL
44828 };
44829
44830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44832 if (!SWIG_IsOK(res1)) {
44833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44834 }
44835 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44836 {
44837 arg2 = wxString_in_helper(obj1);
44838 if (arg2 == NULL) SWIG_fail;
44839 temp2 = true;
44840 }
44841 {
44842 PyThreadState* __tstate = wxPyBeginAllowThreads();
44843 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44844 wxPyEndAllowThreads(__tstate);
44845 if (PyErr_Occurred()) SWIG_fail;
44846 }
44847 {
44848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44849 }
44850 {
44851 if (temp2)
44852 delete arg2;
44853 }
44854 return resultobj;
44855 fail:
44856 {
44857 if (temp2)
44858 delete arg2;
44859 }
44860 return NULL;
44861 }
44862
44863
44864 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44865 PyObject *resultobj = 0;
44866 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44867 wxString result;
44868 void *argp1 = 0 ;
44869 int res1 = 0 ;
44870 PyObject *swig_obj[1] ;
44871
44872 if (!args) SWIG_fail;
44873 swig_obj[0] = args;
44874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44875 if (!SWIG_IsOK(res1)) {
44876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44877 }
44878 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44879 {
44880 PyThreadState* __tstate = wxPyBeginAllowThreads();
44881 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44882 wxPyEndAllowThreads(__tstate);
44883 if (PyErr_Occurred()) SWIG_fail;
44884 }
44885 {
44886 #if wxUSE_UNICODE
44887 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44888 #else
44889 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44890 #endif
44891 }
44892 return resultobj;
44893 fail:
44894 return NULL;
44895 }
44896
44897
44898 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44899 PyObject *resultobj = 0;
44900 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44901 int arg2 ;
44902 void *argp1 = 0 ;
44903 int res1 = 0 ;
44904 int val2 ;
44905 int ecode2 = 0 ;
44906 PyObject * obj0 = 0 ;
44907 PyObject * obj1 = 0 ;
44908 char * kwnames[] = {
44909 (char *) "self",(char *) "n", NULL
44910 };
44911
44912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44914 if (!SWIG_IsOK(res1)) {
44915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44916 }
44917 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44918 ecode2 = SWIG_AsVal_int(obj1, &val2);
44919 if (!SWIG_IsOK(ecode2)) {
44920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44921 }
44922 arg2 = static_cast< int >(val2);
44923 {
44924 PyThreadState* __tstate = wxPyBeginAllowThreads();
44925 (arg1)->Select(arg2);
44926 wxPyEndAllowThreads(__tstate);
44927 if (PyErr_Occurred()) SWIG_fail;
44928 }
44929 resultobj = SWIG_Py_Void();
44930 return resultobj;
44931 fail:
44932 return NULL;
44933 }
44934
44935
44936 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44937 PyObject *obj;
44938 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44939 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44940 return SWIG_Py_Void();
44941 }
44942
44943 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44944 PyObject *obj;
44945 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44946 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44947 return SWIG_Py_Void();
44948 }
44949
44950 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44951 PyObject *resultobj = 0;
44952 wxSizerItem *result = 0 ;
44953
44954 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44955 {
44956 PyThreadState* __tstate = wxPyBeginAllowThreads();
44957 result = (wxSizerItem *)new wxSizerItem();
44958 wxPyEndAllowThreads(__tstate);
44959 if (PyErr_Occurred()) SWIG_fail;
44960 }
44961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44962 return resultobj;
44963 fail:
44964 return NULL;
44965 }
44966
44967
44968 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44969 PyObject *resultobj = 0;
44970 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44971 void *argp1 = 0 ;
44972 int res1 = 0 ;
44973 PyObject *swig_obj[1] ;
44974
44975 if (!args) SWIG_fail;
44976 swig_obj[0] = args;
44977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44978 if (!SWIG_IsOK(res1)) {
44979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44980 }
44981 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44982 {
44983 PyThreadState* __tstate = wxPyBeginAllowThreads();
44984 delete arg1;
44985
44986 wxPyEndAllowThreads(__tstate);
44987 if (PyErr_Occurred()) SWIG_fail;
44988 }
44989 resultobj = SWIG_Py_Void();
44990 return resultobj;
44991 fail:
44992 return NULL;
44993 }
44994
44995
44996 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44997 PyObject *resultobj = 0;
44998 wxWindow *arg1 = (wxWindow *) 0 ;
44999 int arg2 ;
45000 int arg3 ;
45001 int arg4 ;
45002 PyObject *arg5 = (PyObject *) NULL ;
45003 wxSizerItem *result = 0 ;
45004 void *argp1 = 0 ;
45005 int res1 = 0 ;
45006 int val2 ;
45007 int ecode2 = 0 ;
45008 int val3 ;
45009 int ecode3 = 0 ;
45010 int val4 ;
45011 int ecode4 = 0 ;
45012 PyObject * obj0 = 0 ;
45013 PyObject * obj1 = 0 ;
45014 PyObject * obj2 = 0 ;
45015 PyObject * obj3 = 0 ;
45016 PyObject * obj4 = 0 ;
45017 char * kwnames[] = {
45018 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45019 };
45020
45021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45023 if (!SWIG_IsOK(res1)) {
45024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45025 }
45026 arg1 = reinterpret_cast< wxWindow * >(argp1);
45027 ecode2 = SWIG_AsVal_int(obj1, &val2);
45028 if (!SWIG_IsOK(ecode2)) {
45029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45030 }
45031 arg2 = static_cast< int >(val2);
45032 ecode3 = SWIG_AsVal_int(obj2, &val3);
45033 if (!SWIG_IsOK(ecode3)) {
45034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45035 }
45036 arg3 = static_cast< int >(val3);
45037 ecode4 = SWIG_AsVal_int(obj3, &val4);
45038 if (!SWIG_IsOK(ecode4)) {
45039 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45040 }
45041 arg4 = static_cast< int >(val4);
45042 if (obj4) {
45043 arg5 = obj4;
45044 }
45045 {
45046 PyThreadState* __tstate = wxPyBeginAllowThreads();
45047 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45048 wxPyEndAllowThreads(__tstate);
45049 if (PyErr_Occurred()) SWIG_fail;
45050 }
45051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45052 return resultobj;
45053 fail:
45054 return NULL;
45055 }
45056
45057
45058 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45059 PyObject *resultobj = 0;
45060 int arg1 ;
45061 int arg2 ;
45062 int arg3 ;
45063 int arg4 ;
45064 int arg5 ;
45065 PyObject *arg6 = (PyObject *) NULL ;
45066 wxSizerItem *result = 0 ;
45067 int val1 ;
45068 int ecode1 = 0 ;
45069 int val2 ;
45070 int ecode2 = 0 ;
45071 int val3 ;
45072 int ecode3 = 0 ;
45073 int val4 ;
45074 int ecode4 = 0 ;
45075 int val5 ;
45076 int ecode5 = 0 ;
45077 PyObject * obj0 = 0 ;
45078 PyObject * obj1 = 0 ;
45079 PyObject * obj2 = 0 ;
45080 PyObject * obj3 = 0 ;
45081 PyObject * obj4 = 0 ;
45082 PyObject * obj5 = 0 ;
45083 char * kwnames[] = {
45084 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45085 };
45086
45087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45088 ecode1 = SWIG_AsVal_int(obj0, &val1);
45089 if (!SWIG_IsOK(ecode1)) {
45090 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45091 }
45092 arg1 = static_cast< int >(val1);
45093 ecode2 = SWIG_AsVal_int(obj1, &val2);
45094 if (!SWIG_IsOK(ecode2)) {
45095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45096 }
45097 arg2 = static_cast< int >(val2);
45098 ecode3 = SWIG_AsVal_int(obj2, &val3);
45099 if (!SWIG_IsOK(ecode3)) {
45100 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45101 }
45102 arg3 = static_cast< int >(val3);
45103 ecode4 = SWIG_AsVal_int(obj3, &val4);
45104 if (!SWIG_IsOK(ecode4)) {
45105 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45106 }
45107 arg4 = static_cast< int >(val4);
45108 ecode5 = SWIG_AsVal_int(obj4, &val5);
45109 if (!SWIG_IsOK(ecode5)) {
45110 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45111 }
45112 arg5 = static_cast< int >(val5);
45113 if (obj5) {
45114 arg6 = obj5;
45115 }
45116 {
45117 PyThreadState* __tstate = wxPyBeginAllowThreads();
45118 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45119 wxPyEndAllowThreads(__tstate);
45120 if (PyErr_Occurred()) SWIG_fail;
45121 }
45122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45123 return resultobj;
45124 fail:
45125 return NULL;
45126 }
45127
45128
45129 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45130 PyObject *resultobj = 0;
45131 wxSizer *arg1 = (wxSizer *) 0 ;
45132 int arg2 ;
45133 int arg3 ;
45134 int arg4 ;
45135 PyObject *arg5 = (PyObject *) NULL ;
45136 wxSizerItem *result = 0 ;
45137 int res1 = 0 ;
45138 int val2 ;
45139 int ecode2 = 0 ;
45140 int val3 ;
45141 int ecode3 = 0 ;
45142 int val4 ;
45143 int ecode4 = 0 ;
45144 PyObject * obj0 = 0 ;
45145 PyObject * obj1 = 0 ;
45146 PyObject * obj2 = 0 ;
45147 PyObject * obj3 = 0 ;
45148 PyObject * obj4 = 0 ;
45149 char * kwnames[] = {
45150 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45151 };
45152
45153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45154 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45155 if (!SWIG_IsOK(res1)) {
45156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45157 }
45158 ecode2 = SWIG_AsVal_int(obj1, &val2);
45159 if (!SWIG_IsOK(ecode2)) {
45160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45161 }
45162 arg2 = static_cast< int >(val2);
45163 ecode3 = SWIG_AsVal_int(obj2, &val3);
45164 if (!SWIG_IsOK(ecode3)) {
45165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45166 }
45167 arg3 = static_cast< int >(val3);
45168 ecode4 = SWIG_AsVal_int(obj3, &val4);
45169 if (!SWIG_IsOK(ecode4)) {
45170 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45171 }
45172 arg4 = static_cast< int >(val4);
45173 if (obj4) {
45174 arg5 = obj4;
45175 }
45176 {
45177 PyThreadState* __tstate = wxPyBeginAllowThreads();
45178 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45179 wxPyEndAllowThreads(__tstate);
45180 if (PyErr_Occurred()) SWIG_fail;
45181 }
45182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45183 return resultobj;
45184 fail:
45185 return NULL;
45186 }
45187
45188
45189 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45190 PyObject *resultobj = 0;
45191 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45192 void *argp1 = 0 ;
45193 int res1 = 0 ;
45194 PyObject *swig_obj[1] ;
45195
45196 if (!args) SWIG_fail;
45197 swig_obj[0] = args;
45198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45199 if (!SWIG_IsOK(res1)) {
45200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45201 }
45202 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45203 {
45204 PyThreadState* __tstate = wxPyBeginAllowThreads();
45205 (arg1)->DeleteWindows();
45206 wxPyEndAllowThreads(__tstate);
45207 if (PyErr_Occurred()) SWIG_fail;
45208 }
45209 resultobj = SWIG_Py_Void();
45210 return resultobj;
45211 fail:
45212 return NULL;
45213 }
45214
45215
45216 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45217 PyObject *resultobj = 0;
45218 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45219 void *argp1 = 0 ;
45220 int res1 = 0 ;
45221 PyObject *swig_obj[1] ;
45222
45223 if (!args) SWIG_fail;
45224 swig_obj[0] = args;
45225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45226 if (!SWIG_IsOK(res1)) {
45227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45228 }
45229 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45230 {
45231 PyThreadState* __tstate = wxPyBeginAllowThreads();
45232 (arg1)->DetachSizer();
45233 wxPyEndAllowThreads(__tstate);
45234 if (PyErr_Occurred()) SWIG_fail;
45235 }
45236 resultobj = SWIG_Py_Void();
45237 return resultobj;
45238 fail:
45239 return NULL;
45240 }
45241
45242
45243 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45244 PyObject *resultobj = 0;
45245 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45246 wxSize result;
45247 void *argp1 = 0 ;
45248 int res1 = 0 ;
45249 PyObject *swig_obj[1] ;
45250
45251 if (!args) SWIG_fail;
45252 swig_obj[0] = args;
45253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45254 if (!SWIG_IsOK(res1)) {
45255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45256 }
45257 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45258 {
45259 PyThreadState* __tstate = wxPyBeginAllowThreads();
45260 result = (arg1)->GetSize();
45261 wxPyEndAllowThreads(__tstate);
45262 if (PyErr_Occurred()) SWIG_fail;
45263 }
45264 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45265 return resultobj;
45266 fail:
45267 return NULL;
45268 }
45269
45270
45271 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45272 PyObject *resultobj = 0;
45273 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45274 wxSize result;
45275 void *argp1 = 0 ;
45276 int res1 = 0 ;
45277 PyObject *swig_obj[1] ;
45278
45279 if (!args) SWIG_fail;
45280 swig_obj[0] = args;
45281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45282 if (!SWIG_IsOK(res1)) {
45283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45284 }
45285 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45286 {
45287 PyThreadState* __tstate = wxPyBeginAllowThreads();
45288 result = (arg1)->CalcMin();
45289 wxPyEndAllowThreads(__tstate);
45290 if (PyErr_Occurred()) SWIG_fail;
45291 }
45292 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45293 return resultobj;
45294 fail:
45295 return NULL;
45296 }
45297
45298
45299 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45300 PyObject *resultobj = 0;
45301 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45302 wxPoint *arg2 = 0 ;
45303 wxSize *arg3 = 0 ;
45304 void *argp1 = 0 ;
45305 int res1 = 0 ;
45306 wxPoint temp2 ;
45307 wxSize temp3 ;
45308 PyObject * obj0 = 0 ;
45309 PyObject * obj1 = 0 ;
45310 PyObject * obj2 = 0 ;
45311 char * kwnames[] = {
45312 (char *) "self",(char *) "pos",(char *) "size", NULL
45313 };
45314
45315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45317 if (!SWIG_IsOK(res1)) {
45318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45319 }
45320 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45321 {
45322 arg2 = &temp2;
45323 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45324 }
45325 {
45326 arg3 = &temp3;
45327 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45328 }
45329 {
45330 PyThreadState* __tstate = wxPyBeginAllowThreads();
45331 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45332 wxPyEndAllowThreads(__tstate);
45333 if (PyErr_Occurred()) SWIG_fail;
45334 }
45335 resultobj = SWIG_Py_Void();
45336 return resultobj;
45337 fail:
45338 return NULL;
45339 }
45340
45341
45342 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45343 PyObject *resultobj = 0;
45344 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45345 wxSize result;
45346 void *argp1 = 0 ;
45347 int res1 = 0 ;
45348 PyObject *swig_obj[1] ;
45349
45350 if (!args) SWIG_fail;
45351 swig_obj[0] = args;
45352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45353 if (!SWIG_IsOK(res1)) {
45354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45355 }
45356 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45357 {
45358 PyThreadState* __tstate = wxPyBeginAllowThreads();
45359 result = (arg1)->GetMinSize();
45360 wxPyEndAllowThreads(__tstate);
45361 if (PyErr_Occurred()) SWIG_fail;
45362 }
45363 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45364 return resultobj;
45365 fail:
45366 return NULL;
45367 }
45368
45369
45370 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45371 PyObject *resultobj = 0;
45372 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45373 wxSize result;
45374 void *argp1 = 0 ;
45375 int res1 = 0 ;
45376 PyObject *swig_obj[1] ;
45377
45378 if (!args) SWIG_fail;
45379 swig_obj[0] = args;
45380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45381 if (!SWIG_IsOK(res1)) {
45382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45383 }
45384 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45385 {
45386 PyThreadState* __tstate = wxPyBeginAllowThreads();
45387 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45388 wxPyEndAllowThreads(__tstate);
45389 if (PyErr_Occurred()) SWIG_fail;
45390 }
45391 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45392 return resultobj;
45393 fail:
45394 return NULL;
45395 }
45396
45397
45398 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45399 PyObject *resultobj = 0;
45400 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45401 int arg2 ;
45402 int arg3 ;
45403 void *argp1 = 0 ;
45404 int res1 = 0 ;
45405 int val2 ;
45406 int ecode2 = 0 ;
45407 int val3 ;
45408 int ecode3 = 0 ;
45409 PyObject * obj0 = 0 ;
45410 PyObject * obj1 = 0 ;
45411 PyObject * obj2 = 0 ;
45412 char * kwnames[] = {
45413 (char *) "self",(char *) "x",(char *) "y", NULL
45414 };
45415
45416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45418 if (!SWIG_IsOK(res1)) {
45419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45420 }
45421 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45422 ecode2 = SWIG_AsVal_int(obj1, &val2);
45423 if (!SWIG_IsOK(ecode2)) {
45424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45425 }
45426 arg2 = static_cast< int >(val2);
45427 ecode3 = SWIG_AsVal_int(obj2, &val3);
45428 if (!SWIG_IsOK(ecode3)) {
45429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45430 }
45431 arg3 = static_cast< int >(val3);
45432 {
45433 PyThreadState* __tstate = wxPyBeginAllowThreads();
45434 (arg1)->SetInitSize(arg2,arg3);
45435 wxPyEndAllowThreads(__tstate);
45436 if (PyErr_Occurred()) SWIG_fail;
45437 }
45438 resultobj = SWIG_Py_Void();
45439 return resultobj;
45440 fail:
45441 return NULL;
45442 }
45443
45444
45445 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45446 PyObject *resultobj = 0;
45447 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45448 int arg2 ;
45449 int arg3 ;
45450 void *argp1 = 0 ;
45451 int res1 = 0 ;
45452 int val2 ;
45453 int ecode2 = 0 ;
45454 int val3 ;
45455 int ecode3 = 0 ;
45456 PyObject * obj0 = 0 ;
45457 PyObject * obj1 = 0 ;
45458 PyObject * obj2 = 0 ;
45459 char * kwnames[] = {
45460 (char *) "self",(char *) "width",(char *) "height", NULL
45461 };
45462
45463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45465 if (!SWIG_IsOK(res1)) {
45466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45467 }
45468 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45469 ecode2 = SWIG_AsVal_int(obj1, &val2);
45470 if (!SWIG_IsOK(ecode2)) {
45471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45472 }
45473 arg2 = static_cast< int >(val2);
45474 ecode3 = SWIG_AsVal_int(obj2, &val3);
45475 if (!SWIG_IsOK(ecode3)) {
45476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45477 }
45478 arg3 = static_cast< int >(val3);
45479 {
45480 PyThreadState* __tstate = wxPyBeginAllowThreads();
45481 (arg1)->SetRatio(arg2,arg3);
45482 wxPyEndAllowThreads(__tstate);
45483 if (PyErr_Occurred()) SWIG_fail;
45484 }
45485 resultobj = SWIG_Py_Void();
45486 return resultobj;
45487 fail:
45488 return NULL;
45489 }
45490
45491
45492 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45493 PyObject *resultobj = 0;
45494 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45495 wxSize *arg2 = 0 ;
45496 void *argp1 = 0 ;
45497 int res1 = 0 ;
45498 wxSize temp2 ;
45499 PyObject * obj0 = 0 ;
45500 PyObject * obj1 = 0 ;
45501 char * kwnames[] = {
45502 (char *) "self",(char *) "size", NULL
45503 };
45504
45505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45507 if (!SWIG_IsOK(res1)) {
45508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45509 }
45510 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45511 {
45512 arg2 = &temp2;
45513 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45514 }
45515 {
45516 PyThreadState* __tstate = wxPyBeginAllowThreads();
45517 (arg1)->SetRatio((wxSize const &)*arg2);
45518 wxPyEndAllowThreads(__tstate);
45519 if (PyErr_Occurred()) SWIG_fail;
45520 }
45521 resultobj = SWIG_Py_Void();
45522 return resultobj;
45523 fail:
45524 return NULL;
45525 }
45526
45527
45528 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45529 PyObject *resultobj = 0;
45530 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45531 float arg2 ;
45532 void *argp1 = 0 ;
45533 int res1 = 0 ;
45534 float val2 ;
45535 int ecode2 = 0 ;
45536 PyObject * obj0 = 0 ;
45537 PyObject * obj1 = 0 ;
45538 char * kwnames[] = {
45539 (char *) "self",(char *) "ratio", NULL
45540 };
45541
45542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45544 if (!SWIG_IsOK(res1)) {
45545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45546 }
45547 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45548 ecode2 = SWIG_AsVal_float(obj1, &val2);
45549 if (!SWIG_IsOK(ecode2)) {
45550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45551 }
45552 arg2 = static_cast< float >(val2);
45553 {
45554 PyThreadState* __tstate = wxPyBeginAllowThreads();
45555 (arg1)->SetRatio(arg2);
45556 wxPyEndAllowThreads(__tstate);
45557 if (PyErr_Occurred()) SWIG_fail;
45558 }
45559 resultobj = SWIG_Py_Void();
45560 return resultobj;
45561 fail:
45562 return NULL;
45563 }
45564
45565
45566 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45567 PyObject *resultobj = 0;
45568 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45569 float result;
45570 void *argp1 = 0 ;
45571 int res1 = 0 ;
45572 PyObject *swig_obj[1] ;
45573
45574 if (!args) SWIG_fail;
45575 swig_obj[0] = args;
45576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45577 if (!SWIG_IsOK(res1)) {
45578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45579 }
45580 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45581 {
45582 PyThreadState* __tstate = wxPyBeginAllowThreads();
45583 result = (float)(arg1)->GetRatio();
45584 wxPyEndAllowThreads(__tstate);
45585 if (PyErr_Occurred()) SWIG_fail;
45586 }
45587 resultobj = SWIG_From_float(static_cast< float >(result));
45588 return resultobj;
45589 fail:
45590 return NULL;
45591 }
45592
45593
45594 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45595 PyObject *resultobj = 0;
45596 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45597 wxRect result;
45598 void *argp1 = 0 ;
45599 int res1 = 0 ;
45600 PyObject *swig_obj[1] ;
45601
45602 if (!args) SWIG_fail;
45603 swig_obj[0] = args;
45604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45605 if (!SWIG_IsOK(res1)) {
45606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45607 }
45608 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45609 {
45610 PyThreadState* __tstate = wxPyBeginAllowThreads();
45611 result = (arg1)->GetRect();
45612 wxPyEndAllowThreads(__tstate);
45613 if (PyErr_Occurred()) SWIG_fail;
45614 }
45615 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45616 return resultobj;
45617 fail:
45618 return NULL;
45619 }
45620
45621
45622 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45623 PyObject *resultobj = 0;
45624 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45625 bool result;
45626 void *argp1 = 0 ;
45627 int res1 = 0 ;
45628 PyObject *swig_obj[1] ;
45629
45630 if (!args) SWIG_fail;
45631 swig_obj[0] = args;
45632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45633 if (!SWIG_IsOK(res1)) {
45634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45635 }
45636 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45637 {
45638 PyThreadState* __tstate = wxPyBeginAllowThreads();
45639 result = (bool)(arg1)->IsWindow();
45640 wxPyEndAllowThreads(__tstate);
45641 if (PyErr_Occurred()) SWIG_fail;
45642 }
45643 {
45644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45645 }
45646 return resultobj;
45647 fail:
45648 return NULL;
45649 }
45650
45651
45652 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45653 PyObject *resultobj = 0;
45654 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45655 bool result;
45656 void *argp1 = 0 ;
45657 int res1 = 0 ;
45658 PyObject *swig_obj[1] ;
45659
45660 if (!args) SWIG_fail;
45661 swig_obj[0] = args;
45662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45663 if (!SWIG_IsOK(res1)) {
45664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45665 }
45666 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45667 {
45668 PyThreadState* __tstate = wxPyBeginAllowThreads();
45669 result = (bool)(arg1)->IsSizer();
45670 wxPyEndAllowThreads(__tstate);
45671 if (PyErr_Occurred()) SWIG_fail;
45672 }
45673 {
45674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45675 }
45676 return resultobj;
45677 fail:
45678 return NULL;
45679 }
45680
45681
45682 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45683 PyObject *resultobj = 0;
45684 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45685 bool result;
45686 void *argp1 = 0 ;
45687 int res1 = 0 ;
45688 PyObject *swig_obj[1] ;
45689
45690 if (!args) SWIG_fail;
45691 swig_obj[0] = args;
45692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45693 if (!SWIG_IsOK(res1)) {
45694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45695 }
45696 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45697 {
45698 PyThreadState* __tstate = wxPyBeginAllowThreads();
45699 result = (bool)(arg1)->IsSpacer();
45700 wxPyEndAllowThreads(__tstate);
45701 if (PyErr_Occurred()) SWIG_fail;
45702 }
45703 {
45704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45705 }
45706 return resultobj;
45707 fail:
45708 return NULL;
45709 }
45710
45711
45712 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45713 PyObject *resultobj = 0;
45714 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45715 int arg2 ;
45716 void *argp1 = 0 ;
45717 int res1 = 0 ;
45718 int val2 ;
45719 int ecode2 = 0 ;
45720 PyObject * obj0 = 0 ;
45721 PyObject * obj1 = 0 ;
45722 char * kwnames[] = {
45723 (char *) "self",(char *) "proportion", NULL
45724 };
45725
45726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45728 if (!SWIG_IsOK(res1)) {
45729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45730 }
45731 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45732 ecode2 = SWIG_AsVal_int(obj1, &val2);
45733 if (!SWIG_IsOK(ecode2)) {
45734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45735 }
45736 arg2 = static_cast< int >(val2);
45737 {
45738 PyThreadState* __tstate = wxPyBeginAllowThreads();
45739 (arg1)->SetProportion(arg2);
45740 wxPyEndAllowThreads(__tstate);
45741 if (PyErr_Occurred()) SWIG_fail;
45742 }
45743 resultobj = SWIG_Py_Void();
45744 return resultobj;
45745 fail:
45746 return NULL;
45747 }
45748
45749
45750 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45751 PyObject *resultobj = 0;
45752 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45753 int result;
45754 void *argp1 = 0 ;
45755 int res1 = 0 ;
45756 PyObject *swig_obj[1] ;
45757
45758 if (!args) SWIG_fail;
45759 swig_obj[0] = args;
45760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45761 if (!SWIG_IsOK(res1)) {
45762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45763 }
45764 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45765 {
45766 PyThreadState* __tstate = wxPyBeginAllowThreads();
45767 result = (int)(arg1)->GetProportion();
45768 wxPyEndAllowThreads(__tstate);
45769 if (PyErr_Occurred()) SWIG_fail;
45770 }
45771 resultobj = SWIG_From_int(static_cast< int >(result));
45772 return resultobj;
45773 fail:
45774 return NULL;
45775 }
45776
45777
45778 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45779 PyObject *resultobj = 0;
45780 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45781 int arg2 ;
45782 void *argp1 = 0 ;
45783 int res1 = 0 ;
45784 int val2 ;
45785 int ecode2 = 0 ;
45786 PyObject * obj0 = 0 ;
45787 PyObject * obj1 = 0 ;
45788 char * kwnames[] = {
45789 (char *) "self",(char *) "flag", NULL
45790 };
45791
45792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45794 if (!SWIG_IsOK(res1)) {
45795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45796 }
45797 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45798 ecode2 = SWIG_AsVal_int(obj1, &val2);
45799 if (!SWIG_IsOK(ecode2)) {
45800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45801 }
45802 arg2 = static_cast< int >(val2);
45803 {
45804 PyThreadState* __tstate = wxPyBeginAllowThreads();
45805 (arg1)->SetFlag(arg2);
45806 wxPyEndAllowThreads(__tstate);
45807 if (PyErr_Occurred()) SWIG_fail;
45808 }
45809 resultobj = SWIG_Py_Void();
45810 return resultobj;
45811 fail:
45812 return NULL;
45813 }
45814
45815
45816 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45817 PyObject *resultobj = 0;
45818 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45819 int result;
45820 void *argp1 = 0 ;
45821 int res1 = 0 ;
45822 PyObject *swig_obj[1] ;
45823
45824 if (!args) SWIG_fail;
45825 swig_obj[0] = args;
45826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45827 if (!SWIG_IsOK(res1)) {
45828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45829 }
45830 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45831 {
45832 PyThreadState* __tstate = wxPyBeginAllowThreads();
45833 result = (int)(arg1)->GetFlag();
45834 wxPyEndAllowThreads(__tstate);
45835 if (PyErr_Occurred()) SWIG_fail;
45836 }
45837 resultobj = SWIG_From_int(static_cast< int >(result));
45838 return resultobj;
45839 fail:
45840 return NULL;
45841 }
45842
45843
45844 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45845 PyObject *resultobj = 0;
45846 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45847 int arg2 ;
45848 void *argp1 = 0 ;
45849 int res1 = 0 ;
45850 int val2 ;
45851 int ecode2 = 0 ;
45852 PyObject * obj0 = 0 ;
45853 PyObject * obj1 = 0 ;
45854 char * kwnames[] = {
45855 (char *) "self",(char *) "border", NULL
45856 };
45857
45858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45860 if (!SWIG_IsOK(res1)) {
45861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45862 }
45863 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45864 ecode2 = SWIG_AsVal_int(obj1, &val2);
45865 if (!SWIG_IsOK(ecode2)) {
45866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45867 }
45868 arg2 = static_cast< int >(val2);
45869 {
45870 PyThreadState* __tstate = wxPyBeginAllowThreads();
45871 (arg1)->SetBorder(arg2);
45872 wxPyEndAllowThreads(__tstate);
45873 if (PyErr_Occurred()) SWIG_fail;
45874 }
45875 resultobj = SWIG_Py_Void();
45876 return resultobj;
45877 fail:
45878 return NULL;
45879 }
45880
45881
45882 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45883 PyObject *resultobj = 0;
45884 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45885 int result;
45886 void *argp1 = 0 ;
45887 int res1 = 0 ;
45888 PyObject *swig_obj[1] ;
45889
45890 if (!args) SWIG_fail;
45891 swig_obj[0] = args;
45892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45893 if (!SWIG_IsOK(res1)) {
45894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45895 }
45896 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45897 {
45898 PyThreadState* __tstate = wxPyBeginAllowThreads();
45899 result = (int)(arg1)->GetBorder();
45900 wxPyEndAllowThreads(__tstate);
45901 if (PyErr_Occurred()) SWIG_fail;
45902 }
45903 resultobj = SWIG_From_int(static_cast< int >(result));
45904 return resultobj;
45905 fail:
45906 return NULL;
45907 }
45908
45909
45910 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45911 PyObject *resultobj = 0;
45912 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45913 wxWindow *result = 0 ;
45914 void *argp1 = 0 ;
45915 int res1 = 0 ;
45916 PyObject *swig_obj[1] ;
45917
45918 if (!args) SWIG_fail;
45919 swig_obj[0] = args;
45920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45921 if (!SWIG_IsOK(res1)) {
45922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45923 }
45924 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45925 {
45926 PyThreadState* __tstate = wxPyBeginAllowThreads();
45927 result = (wxWindow *)(arg1)->GetWindow();
45928 wxPyEndAllowThreads(__tstate);
45929 if (PyErr_Occurred()) SWIG_fail;
45930 }
45931 {
45932 resultobj = wxPyMake_wxObject(result, 0);
45933 }
45934 return resultobj;
45935 fail:
45936 return NULL;
45937 }
45938
45939
45940 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45941 PyObject *resultobj = 0;
45942 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45943 wxWindow *arg2 = (wxWindow *) 0 ;
45944 void *argp1 = 0 ;
45945 int res1 = 0 ;
45946 void *argp2 = 0 ;
45947 int res2 = 0 ;
45948 PyObject * obj0 = 0 ;
45949 PyObject * obj1 = 0 ;
45950 char * kwnames[] = {
45951 (char *) "self",(char *) "window", NULL
45952 };
45953
45954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45956 if (!SWIG_IsOK(res1)) {
45957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45958 }
45959 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45960 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45961 if (!SWIG_IsOK(res2)) {
45962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45963 }
45964 arg2 = reinterpret_cast< wxWindow * >(argp2);
45965 {
45966 PyThreadState* __tstate = wxPyBeginAllowThreads();
45967 (arg1)->SetWindow(arg2);
45968 wxPyEndAllowThreads(__tstate);
45969 if (PyErr_Occurred()) SWIG_fail;
45970 }
45971 resultobj = SWIG_Py_Void();
45972 return resultobj;
45973 fail:
45974 return NULL;
45975 }
45976
45977
45978 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45979 PyObject *resultobj = 0;
45980 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45981 wxSizer *result = 0 ;
45982 void *argp1 = 0 ;
45983 int res1 = 0 ;
45984 PyObject *swig_obj[1] ;
45985
45986 if (!args) SWIG_fail;
45987 swig_obj[0] = args;
45988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45989 if (!SWIG_IsOK(res1)) {
45990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45991 }
45992 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45993 {
45994 PyThreadState* __tstate = wxPyBeginAllowThreads();
45995 result = (wxSizer *)(arg1)->GetSizer();
45996 wxPyEndAllowThreads(__tstate);
45997 if (PyErr_Occurred()) SWIG_fail;
45998 }
45999 {
46000 resultobj = wxPyMake_wxObject(result, (bool)0);
46001 }
46002 return resultobj;
46003 fail:
46004 return NULL;
46005 }
46006
46007
46008 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46009 PyObject *resultobj = 0;
46010 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46011 wxSizer *arg2 = (wxSizer *) 0 ;
46012 void *argp1 = 0 ;
46013 int res1 = 0 ;
46014 int res2 = 0 ;
46015 PyObject * obj0 = 0 ;
46016 PyObject * obj1 = 0 ;
46017 char * kwnames[] = {
46018 (char *) "self",(char *) "sizer", NULL
46019 };
46020
46021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46023 if (!SWIG_IsOK(res1)) {
46024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46025 }
46026 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46027 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46028 if (!SWIG_IsOK(res2)) {
46029 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46030 }
46031 {
46032 PyThreadState* __tstate = wxPyBeginAllowThreads();
46033 (arg1)->SetSizer(arg2);
46034 wxPyEndAllowThreads(__tstate);
46035 if (PyErr_Occurred()) SWIG_fail;
46036 }
46037 resultobj = SWIG_Py_Void();
46038 return resultobj;
46039 fail:
46040 return NULL;
46041 }
46042
46043
46044 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46045 PyObject *resultobj = 0;
46046 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46047 wxSize *result = 0 ;
46048 void *argp1 = 0 ;
46049 int res1 = 0 ;
46050 PyObject *swig_obj[1] ;
46051
46052 if (!args) SWIG_fail;
46053 swig_obj[0] = args;
46054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46055 if (!SWIG_IsOK(res1)) {
46056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46057 }
46058 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46059 {
46060 PyThreadState* __tstate = wxPyBeginAllowThreads();
46061 {
46062 wxSize const &_result_ref = (arg1)->GetSpacer();
46063 result = (wxSize *) &_result_ref;
46064 }
46065 wxPyEndAllowThreads(__tstate);
46066 if (PyErr_Occurred()) SWIG_fail;
46067 }
46068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46069 return resultobj;
46070 fail:
46071 return NULL;
46072 }
46073
46074
46075 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46076 PyObject *resultobj = 0;
46077 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46078 wxSize *arg2 = 0 ;
46079 void *argp1 = 0 ;
46080 int res1 = 0 ;
46081 wxSize temp2 ;
46082 PyObject * obj0 = 0 ;
46083 PyObject * obj1 = 0 ;
46084 char * kwnames[] = {
46085 (char *) "self",(char *) "size", NULL
46086 };
46087
46088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46090 if (!SWIG_IsOK(res1)) {
46091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46092 }
46093 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46094 {
46095 arg2 = &temp2;
46096 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46097 }
46098 {
46099 PyThreadState* __tstate = wxPyBeginAllowThreads();
46100 (arg1)->SetSpacer((wxSize const &)*arg2);
46101 wxPyEndAllowThreads(__tstate);
46102 if (PyErr_Occurred()) SWIG_fail;
46103 }
46104 resultobj = SWIG_Py_Void();
46105 return resultobj;
46106 fail:
46107 return NULL;
46108 }
46109
46110
46111 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46112 PyObject *resultobj = 0;
46113 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46114 bool arg2 ;
46115 void *argp1 = 0 ;
46116 int res1 = 0 ;
46117 bool val2 ;
46118 int ecode2 = 0 ;
46119 PyObject * obj0 = 0 ;
46120 PyObject * obj1 = 0 ;
46121 char * kwnames[] = {
46122 (char *) "self",(char *) "show", NULL
46123 };
46124
46125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46127 if (!SWIG_IsOK(res1)) {
46128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46129 }
46130 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46131 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46132 if (!SWIG_IsOK(ecode2)) {
46133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46134 }
46135 arg2 = static_cast< bool >(val2);
46136 {
46137 PyThreadState* __tstate = wxPyBeginAllowThreads();
46138 (arg1)->Show(arg2);
46139 wxPyEndAllowThreads(__tstate);
46140 if (PyErr_Occurred()) SWIG_fail;
46141 }
46142 resultobj = SWIG_Py_Void();
46143 return resultobj;
46144 fail:
46145 return NULL;
46146 }
46147
46148
46149 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46150 PyObject *resultobj = 0;
46151 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46152 bool result;
46153 void *argp1 = 0 ;
46154 int res1 = 0 ;
46155 PyObject *swig_obj[1] ;
46156
46157 if (!args) SWIG_fail;
46158 swig_obj[0] = args;
46159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46160 if (!SWIG_IsOK(res1)) {
46161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46162 }
46163 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46164 {
46165 PyThreadState* __tstate = wxPyBeginAllowThreads();
46166 result = (bool)(arg1)->IsShown();
46167 wxPyEndAllowThreads(__tstate);
46168 if (PyErr_Occurred()) SWIG_fail;
46169 }
46170 {
46171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46172 }
46173 return resultobj;
46174 fail:
46175 return NULL;
46176 }
46177
46178
46179 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46180 PyObject *resultobj = 0;
46181 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46182 wxPoint result;
46183 void *argp1 = 0 ;
46184 int res1 = 0 ;
46185 PyObject *swig_obj[1] ;
46186
46187 if (!args) SWIG_fail;
46188 swig_obj[0] = args;
46189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46190 if (!SWIG_IsOK(res1)) {
46191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46192 }
46193 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46194 {
46195 PyThreadState* __tstate = wxPyBeginAllowThreads();
46196 result = (arg1)->GetPosition();
46197 wxPyEndAllowThreads(__tstate);
46198 if (PyErr_Occurred()) SWIG_fail;
46199 }
46200 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46201 return resultobj;
46202 fail:
46203 return NULL;
46204 }
46205
46206
46207 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46208 PyObject *resultobj = 0;
46209 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46210 PyObject *result = 0 ;
46211 void *argp1 = 0 ;
46212 int res1 = 0 ;
46213 PyObject *swig_obj[1] ;
46214
46215 if (!args) SWIG_fail;
46216 swig_obj[0] = args;
46217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46218 if (!SWIG_IsOK(res1)) {
46219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46220 }
46221 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46222 {
46223 PyThreadState* __tstate = wxPyBeginAllowThreads();
46224 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46225 wxPyEndAllowThreads(__tstate);
46226 if (PyErr_Occurred()) SWIG_fail;
46227 }
46228 resultobj = result;
46229 return resultobj;
46230 fail:
46231 return NULL;
46232 }
46233
46234
46235 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46236 PyObject *resultobj = 0;
46237 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46238 PyObject *arg2 = (PyObject *) 0 ;
46239 void *argp1 = 0 ;
46240 int res1 = 0 ;
46241 PyObject * obj0 = 0 ;
46242 PyObject * obj1 = 0 ;
46243 char * kwnames[] = {
46244 (char *) "self",(char *) "userData", NULL
46245 };
46246
46247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46249 if (!SWIG_IsOK(res1)) {
46250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46251 }
46252 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46253 arg2 = obj1;
46254 {
46255 PyThreadState* __tstate = wxPyBeginAllowThreads();
46256 wxSizerItem_SetUserData(arg1,arg2);
46257 wxPyEndAllowThreads(__tstate);
46258 if (PyErr_Occurred()) SWIG_fail;
46259 }
46260 resultobj = SWIG_Py_Void();
46261 return resultobj;
46262 fail:
46263 return NULL;
46264 }
46265
46266
46267 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46268 PyObject *obj;
46269 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46270 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46271 return SWIG_Py_Void();
46272 }
46273
46274 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46275 return SWIG_Python_InitShadowInstance(args);
46276 }
46277
46278 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46279 PyObject *resultobj = 0;
46280 wxSizer *arg1 = (wxSizer *) 0 ;
46281 void *argp1 = 0 ;
46282 int res1 = 0 ;
46283 PyObject *swig_obj[1] ;
46284
46285 if (!args) SWIG_fail;
46286 swig_obj[0] = args;
46287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46288 if (!SWIG_IsOK(res1)) {
46289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46290 }
46291 arg1 = reinterpret_cast< wxSizer * >(argp1);
46292 {
46293 PyThreadState* __tstate = wxPyBeginAllowThreads();
46294 delete arg1;
46295
46296 wxPyEndAllowThreads(__tstate);
46297 if (PyErr_Occurred()) SWIG_fail;
46298 }
46299 resultobj = SWIG_Py_Void();
46300 return resultobj;
46301 fail:
46302 return NULL;
46303 }
46304
46305
46306 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46307 PyObject *resultobj = 0;
46308 wxSizer *arg1 = (wxSizer *) 0 ;
46309 PyObject *arg2 = (PyObject *) 0 ;
46310 void *argp1 = 0 ;
46311 int res1 = 0 ;
46312 PyObject * obj0 = 0 ;
46313 PyObject * obj1 = 0 ;
46314 char * kwnames[] = {
46315 (char *) "self",(char *) "_self", NULL
46316 };
46317
46318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46320 if (!SWIG_IsOK(res1)) {
46321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46322 }
46323 arg1 = reinterpret_cast< wxSizer * >(argp1);
46324 arg2 = obj1;
46325 {
46326 PyThreadState* __tstate = wxPyBeginAllowThreads();
46327 wxSizer__setOORInfo(arg1,arg2);
46328 wxPyEndAllowThreads(__tstate);
46329 if (PyErr_Occurred()) SWIG_fail;
46330 }
46331 resultobj = SWIG_Py_Void();
46332 return resultobj;
46333 fail:
46334 return NULL;
46335 }
46336
46337
46338 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46339 PyObject *resultobj = 0;
46340 wxSizer *arg1 = (wxSizer *) 0 ;
46341 PyObject *arg2 = (PyObject *) 0 ;
46342 int arg3 = (int) 0 ;
46343 int arg4 = (int) 0 ;
46344 int arg5 = (int) 0 ;
46345 PyObject *arg6 = (PyObject *) NULL ;
46346 wxSizerItem *result = 0 ;
46347 void *argp1 = 0 ;
46348 int res1 = 0 ;
46349 int val3 ;
46350 int ecode3 = 0 ;
46351 int val4 ;
46352 int ecode4 = 0 ;
46353 int val5 ;
46354 int ecode5 = 0 ;
46355 PyObject * obj0 = 0 ;
46356 PyObject * obj1 = 0 ;
46357 PyObject * obj2 = 0 ;
46358 PyObject * obj3 = 0 ;
46359 PyObject * obj4 = 0 ;
46360 PyObject * obj5 = 0 ;
46361 char * kwnames[] = {
46362 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46363 };
46364
46365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46367 if (!SWIG_IsOK(res1)) {
46368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46369 }
46370 arg1 = reinterpret_cast< wxSizer * >(argp1);
46371 arg2 = obj1;
46372 if (obj2) {
46373 ecode3 = SWIG_AsVal_int(obj2, &val3);
46374 if (!SWIG_IsOK(ecode3)) {
46375 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46376 }
46377 arg3 = static_cast< int >(val3);
46378 }
46379 if (obj3) {
46380 ecode4 = SWIG_AsVal_int(obj3, &val4);
46381 if (!SWIG_IsOK(ecode4)) {
46382 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46383 }
46384 arg4 = static_cast< int >(val4);
46385 }
46386 if (obj4) {
46387 ecode5 = SWIG_AsVal_int(obj4, &val5);
46388 if (!SWIG_IsOK(ecode5)) {
46389 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46390 }
46391 arg5 = static_cast< int >(val5);
46392 }
46393 if (obj5) {
46394 arg6 = obj5;
46395 }
46396 {
46397 PyThreadState* __tstate = wxPyBeginAllowThreads();
46398 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46399 wxPyEndAllowThreads(__tstate);
46400 if (PyErr_Occurred()) SWIG_fail;
46401 }
46402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46403 return resultobj;
46404 fail:
46405 return NULL;
46406 }
46407
46408
46409 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46410 PyObject *resultobj = 0;
46411 wxSizer *arg1 = (wxSizer *) 0 ;
46412 int arg2 ;
46413 PyObject *arg3 = (PyObject *) 0 ;
46414 int arg4 = (int) 0 ;
46415 int arg5 = (int) 0 ;
46416 int arg6 = (int) 0 ;
46417 PyObject *arg7 = (PyObject *) NULL ;
46418 wxSizerItem *result = 0 ;
46419 void *argp1 = 0 ;
46420 int res1 = 0 ;
46421 int val2 ;
46422 int ecode2 = 0 ;
46423 int val4 ;
46424 int ecode4 = 0 ;
46425 int val5 ;
46426 int ecode5 = 0 ;
46427 int val6 ;
46428 int ecode6 = 0 ;
46429 PyObject * obj0 = 0 ;
46430 PyObject * obj1 = 0 ;
46431 PyObject * obj2 = 0 ;
46432 PyObject * obj3 = 0 ;
46433 PyObject * obj4 = 0 ;
46434 PyObject * obj5 = 0 ;
46435 PyObject * obj6 = 0 ;
46436 char * kwnames[] = {
46437 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46438 };
46439
46440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46442 if (!SWIG_IsOK(res1)) {
46443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46444 }
46445 arg1 = reinterpret_cast< wxSizer * >(argp1);
46446 ecode2 = SWIG_AsVal_int(obj1, &val2);
46447 if (!SWIG_IsOK(ecode2)) {
46448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46449 }
46450 arg2 = static_cast< int >(val2);
46451 arg3 = obj2;
46452 if (obj3) {
46453 ecode4 = SWIG_AsVal_int(obj3, &val4);
46454 if (!SWIG_IsOK(ecode4)) {
46455 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46456 }
46457 arg4 = static_cast< int >(val4);
46458 }
46459 if (obj4) {
46460 ecode5 = SWIG_AsVal_int(obj4, &val5);
46461 if (!SWIG_IsOK(ecode5)) {
46462 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46463 }
46464 arg5 = static_cast< int >(val5);
46465 }
46466 if (obj5) {
46467 ecode6 = SWIG_AsVal_int(obj5, &val6);
46468 if (!SWIG_IsOK(ecode6)) {
46469 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46470 }
46471 arg6 = static_cast< int >(val6);
46472 }
46473 if (obj6) {
46474 arg7 = obj6;
46475 }
46476 {
46477 PyThreadState* __tstate = wxPyBeginAllowThreads();
46478 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46479 wxPyEndAllowThreads(__tstate);
46480 if (PyErr_Occurred()) SWIG_fail;
46481 }
46482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46483 return resultobj;
46484 fail:
46485 return NULL;
46486 }
46487
46488
46489 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46490 PyObject *resultobj = 0;
46491 wxSizer *arg1 = (wxSizer *) 0 ;
46492 PyObject *arg2 = (PyObject *) 0 ;
46493 int arg3 = (int) 0 ;
46494 int arg4 = (int) 0 ;
46495 int arg5 = (int) 0 ;
46496 PyObject *arg6 = (PyObject *) NULL ;
46497 wxSizerItem *result = 0 ;
46498 void *argp1 = 0 ;
46499 int res1 = 0 ;
46500 int val3 ;
46501 int ecode3 = 0 ;
46502 int val4 ;
46503 int ecode4 = 0 ;
46504 int val5 ;
46505 int ecode5 = 0 ;
46506 PyObject * obj0 = 0 ;
46507 PyObject * obj1 = 0 ;
46508 PyObject * obj2 = 0 ;
46509 PyObject * obj3 = 0 ;
46510 PyObject * obj4 = 0 ;
46511 PyObject * obj5 = 0 ;
46512 char * kwnames[] = {
46513 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46514 };
46515
46516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46518 if (!SWIG_IsOK(res1)) {
46519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46520 }
46521 arg1 = reinterpret_cast< wxSizer * >(argp1);
46522 arg2 = obj1;
46523 if (obj2) {
46524 ecode3 = SWIG_AsVal_int(obj2, &val3);
46525 if (!SWIG_IsOK(ecode3)) {
46526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46527 }
46528 arg3 = static_cast< int >(val3);
46529 }
46530 if (obj3) {
46531 ecode4 = SWIG_AsVal_int(obj3, &val4);
46532 if (!SWIG_IsOK(ecode4)) {
46533 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46534 }
46535 arg4 = static_cast< int >(val4);
46536 }
46537 if (obj4) {
46538 ecode5 = SWIG_AsVal_int(obj4, &val5);
46539 if (!SWIG_IsOK(ecode5)) {
46540 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46541 }
46542 arg5 = static_cast< int >(val5);
46543 }
46544 if (obj5) {
46545 arg6 = obj5;
46546 }
46547 {
46548 PyThreadState* __tstate = wxPyBeginAllowThreads();
46549 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46550 wxPyEndAllowThreads(__tstate);
46551 if (PyErr_Occurred()) SWIG_fail;
46552 }
46553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46554 return resultobj;
46555 fail:
46556 return NULL;
46557 }
46558
46559
46560 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46561 PyObject *resultobj = 0;
46562 wxSizer *arg1 = (wxSizer *) 0 ;
46563 PyObject *arg2 = (PyObject *) 0 ;
46564 bool result;
46565 void *argp1 = 0 ;
46566 int res1 = 0 ;
46567 PyObject * obj0 = 0 ;
46568 PyObject * obj1 = 0 ;
46569 char * kwnames[] = {
46570 (char *) "self",(char *) "item", NULL
46571 };
46572
46573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46575 if (!SWIG_IsOK(res1)) {
46576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46577 }
46578 arg1 = reinterpret_cast< wxSizer * >(argp1);
46579 arg2 = obj1;
46580 {
46581 PyThreadState* __tstate = wxPyBeginAllowThreads();
46582 result = (bool)wxSizer_Remove(arg1,arg2);
46583 wxPyEndAllowThreads(__tstate);
46584 if (PyErr_Occurred()) SWIG_fail;
46585 }
46586 {
46587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46588 }
46589 return resultobj;
46590 fail:
46591 return NULL;
46592 }
46593
46594
46595 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46596 PyObject *resultobj = 0;
46597 wxSizer *arg1 = (wxSizer *) 0 ;
46598 PyObject *arg2 = (PyObject *) 0 ;
46599 bool result;
46600 void *argp1 = 0 ;
46601 int res1 = 0 ;
46602 PyObject * obj0 = 0 ;
46603 PyObject * obj1 = 0 ;
46604 char * kwnames[] = {
46605 (char *) "self",(char *) "item", NULL
46606 };
46607
46608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46610 if (!SWIG_IsOK(res1)) {
46611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46612 }
46613 arg1 = reinterpret_cast< wxSizer * >(argp1);
46614 arg2 = obj1;
46615 {
46616 PyThreadState* __tstate = wxPyBeginAllowThreads();
46617 result = (bool)wxSizer_Detach(arg1,arg2);
46618 wxPyEndAllowThreads(__tstate);
46619 if (PyErr_Occurred()) SWIG_fail;
46620 }
46621 {
46622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46623 }
46624 return resultobj;
46625 fail:
46626 return NULL;
46627 }
46628
46629
46630 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46631 PyObject *resultobj = 0;
46632 wxSizer *arg1 = (wxSizer *) 0 ;
46633 PyObject *arg2 = (PyObject *) 0 ;
46634 wxSizerItem *result = 0 ;
46635 void *argp1 = 0 ;
46636 int res1 = 0 ;
46637 PyObject * obj0 = 0 ;
46638 PyObject * obj1 = 0 ;
46639 char * kwnames[] = {
46640 (char *) "self",(char *) "item", NULL
46641 };
46642
46643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46645 if (!SWIG_IsOK(res1)) {
46646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46647 }
46648 arg1 = reinterpret_cast< wxSizer * >(argp1);
46649 arg2 = obj1;
46650 {
46651 PyThreadState* __tstate = wxPyBeginAllowThreads();
46652 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46653 wxPyEndAllowThreads(__tstate);
46654 if (PyErr_Occurred()) SWIG_fail;
46655 }
46656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46657 return resultobj;
46658 fail:
46659 return NULL;
46660 }
46661
46662
46663 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46664 PyObject *resultobj = 0;
46665 wxSizer *arg1 = (wxSizer *) 0 ;
46666 PyObject *arg2 = (PyObject *) 0 ;
46667 wxSize *arg3 = 0 ;
46668 void *argp1 = 0 ;
46669 int res1 = 0 ;
46670 wxSize temp3 ;
46671 PyObject * obj0 = 0 ;
46672 PyObject * obj1 = 0 ;
46673 PyObject * obj2 = 0 ;
46674 char * kwnames[] = {
46675 (char *) "self",(char *) "item",(char *) "size", NULL
46676 };
46677
46678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46680 if (!SWIG_IsOK(res1)) {
46681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46682 }
46683 arg1 = reinterpret_cast< wxSizer * >(argp1);
46684 arg2 = obj1;
46685 {
46686 arg3 = &temp3;
46687 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46688 }
46689 {
46690 PyThreadState* __tstate = wxPyBeginAllowThreads();
46691 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46692 wxPyEndAllowThreads(__tstate);
46693 if (PyErr_Occurred()) SWIG_fail;
46694 }
46695 resultobj = SWIG_Py_Void();
46696 return resultobj;
46697 fail:
46698 return NULL;
46699 }
46700
46701
46702 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46703 PyObject *resultobj = 0;
46704 wxSizer *arg1 = (wxSizer *) 0 ;
46705 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46706 wxSizerItem *result = 0 ;
46707 void *argp1 = 0 ;
46708 int res1 = 0 ;
46709 int res2 = 0 ;
46710 PyObject * obj0 = 0 ;
46711 PyObject * obj1 = 0 ;
46712 char * kwnames[] = {
46713 (char *) "self",(char *) "item", NULL
46714 };
46715
46716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46718 if (!SWIG_IsOK(res1)) {
46719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46720 }
46721 arg1 = reinterpret_cast< wxSizer * >(argp1);
46722 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46723 if (!SWIG_IsOK(res2)) {
46724 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46725 }
46726 {
46727 PyThreadState* __tstate = wxPyBeginAllowThreads();
46728 result = (wxSizerItem *)(arg1)->Add(arg2);
46729 wxPyEndAllowThreads(__tstate);
46730 if (PyErr_Occurred()) SWIG_fail;
46731 }
46732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46733 return resultobj;
46734 fail:
46735 return NULL;
46736 }
46737
46738
46739 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46740 PyObject *resultobj = 0;
46741 wxSizer *arg1 = (wxSizer *) 0 ;
46742 size_t arg2 ;
46743 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46744 wxSizerItem *result = 0 ;
46745 void *argp1 = 0 ;
46746 int res1 = 0 ;
46747 size_t val2 ;
46748 int ecode2 = 0 ;
46749 int res3 = 0 ;
46750 PyObject * obj0 = 0 ;
46751 PyObject * obj1 = 0 ;
46752 PyObject * obj2 = 0 ;
46753 char * kwnames[] = {
46754 (char *) "self",(char *) "index",(char *) "item", NULL
46755 };
46756
46757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46759 if (!SWIG_IsOK(res1)) {
46760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46761 }
46762 arg1 = reinterpret_cast< wxSizer * >(argp1);
46763 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46764 if (!SWIG_IsOK(ecode2)) {
46765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46766 }
46767 arg2 = static_cast< size_t >(val2);
46768 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46769 if (!SWIG_IsOK(res3)) {
46770 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46771 }
46772 {
46773 PyThreadState* __tstate = wxPyBeginAllowThreads();
46774 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46775 wxPyEndAllowThreads(__tstate);
46776 if (PyErr_Occurred()) SWIG_fail;
46777 }
46778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46779 return resultobj;
46780 fail:
46781 return NULL;
46782 }
46783
46784
46785 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46786 PyObject *resultobj = 0;
46787 wxSizer *arg1 = (wxSizer *) 0 ;
46788 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46789 wxSizerItem *result = 0 ;
46790 void *argp1 = 0 ;
46791 int res1 = 0 ;
46792 int res2 = 0 ;
46793 PyObject * obj0 = 0 ;
46794 PyObject * obj1 = 0 ;
46795 char * kwnames[] = {
46796 (char *) "self",(char *) "item", NULL
46797 };
46798
46799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46801 if (!SWIG_IsOK(res1)) {
46802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46803 }
46804 arg1 = reinterpret_cast< wxSizer * >(argp1);
46805 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46806 if (!SWIG_IsOK(res2)) {
46807 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46808 }
46809 {
46810 PyThreadState* __tstate = wxPyBeginAllowThreads();
46811 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46812 wxPyEndAllowThreads(__tstate);
46813 if (PyErr_Occurred()) SWIG_fail;
46814 }
46815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46816 return resultobj;
46817 fail:
46818 return NULL;
46819 }
46820
46821
46822 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46823 PyObject *resultobj = 0;
46824 wxSizer *arg1 = (wxSizer *) 0 ;
46825 int arg2 ;
46826 int arg3 ;
46827 int arg4 ;
46828 int arg5 ;
46829 void *argp1 = 0 ;
46830 int res1 = 0 ;
46831 int val2 ;
46832 int ecode2 = 0 ;
46833 int val3 ;
46834 int ecode3 = 0 ;
46835 int val4 ;
46836 int ecode4 = 0 ;
46837 int val5 ;
46838 int ecode5 = 0 ;
46839 PyObject * obj0 = 0 ;
46840 PyObject * obj1 = 0 ;
46841 PyObject * obj2 = 0 ;
46842 PyObject * obj3 = 0 ;
46843 PyObject * obj4 = 0 ;
46844 char * kwnames[] = {
46845 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46846 };
46847
46848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46850 if (!SWIG_IsOK(res1)) {
46851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46852 }
46853 arg1 = reinterpret_cast< wxSizer * >(argp1);
46854 ecode2 = SWIG_AsVal_int(obj1, &val2);
46855 if (!SWIG_IsOK(ecode2)) {
46856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46857 }
46858 arg2 = static_cast< int >(val2);
46859 ecode3 = SWIG_AsVal_int(obj2, &val3);
46860 if (!SWIG_IsOK(ecode3)) {
46861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46862 }
46863 arg3 = static_cast< int >(val3);
46864 ecode4 = SWIG_AsVal_int(obj3, &val4);
46865 if (!SWIG_IsOK(ecode4)) {
46866 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46867 }
46868 arg4 = static_cast< int >(val4);
46869 ecode5 = SWIG_AsVal_int(obj4, &val5);
46870 if (!SWIG_IsOK(ecode5)) {
46871 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46872 }
46873 arg5 = static_cast< int >(val5);
46874 {
46875 PyThreadState* __tstate = wxPyBeginAllowThreads();
46876 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46877 wxPyEndAllowThreads(__tstate);
46878 if (PyErr_Occurred()) SWIG_fail;
46879 }
46880 resultobj = SWIG_Py_Void();
46881 return resultobj;
46882 fail:
46883 return NULL;
46884 }
46885
46886
46887 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46888 PyObject *resultobj = 0;
46889 wxSizer *arg1 = (wxSizer *) 0 ;
46890 wxSize *arg2 = 0 ;
46891 void *argp1 = 0 ;
46892 int res1 = 0 ;
46893 wxSize temp2 ;
46894 PyObject * obj0 = 0 ;
46895 PyObject * obj1 = 0 ;
46896 char * kwnames[] = {
46897 (char *) "self",(char *) "size", NULL
46898 };
46899
46900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46902 if (!SWIG_IsOK(res1)) {
46903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46904 }
46905 arg1 = reinterpret_cast< wxSizer * >(argp1);
46906 {
46907 arg2 = &temp2;
46908 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46909 }
46910 {
46911 PyThreadState* __tstate = wxPyBeginAllowThreads();
46912 (arg1)->SetMinSize((wxSize const &)*arg2);
46913 wxPyEndAllowThreads(__tstate);
46914 if (PyErr_Occurred()) SWIG_fail;
46915 }
46916 resultobj = SWIG_Py_Void();
46917 return resultobj;
46918 fail:
46919 return NULL;
46920 }
46921
46922
46923 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46924 PyObject *resultobj = 0;
46925 wxSizer *arg1 = (wxSizer *) 0 ;
46926 wxSize result;
46927 void *argp1 = 0 ;
46928 int res1 = 0 ;
46929 PyObject *swig_obj[1] ;
46930
46931 if (!args) SWIG_fail;
46932 swig_obj[0] = args;
46933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46934 if (!SWIG_IsOK(res1)) {
46935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46936 }
46937 arg1 = reinterpret_cast< wxSizer * >(argp1);
46938 {
46939 PyThreadState* __tstate = wxPyBeginAllowThreads();
46940 result = (arg1)->GetSize();
46941 wxPyEndAllowThreads(__tstate);
46942 if (PyErr_Occurred()) SWIG_fail;
46943 }
46944 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46945 return resultobj;
46946 fail:
46947 return NULL;
46948 }
46949
46950
46951 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46952 PyObject *resultobj = 0;
46953 wxSizer *arg1 = (wxSizer *) 0 ;
46954 wxPoint result;
46955 void *argp1 = 0 ;
46956 int res1 = 0 ;
46957 PyObject *swig_obj[1] ;
46958
46959 if (!args) SWIG_fail;
46960 swig_obj[0] = args;
46961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46962 if (!SWIG_IsOK(res1)) {
46963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46964 }
46965 arg1 = reinterpret_cast< wxSizer * >(argp1);
46966 {
46967 PyThreadState* __tstate = wxPyBeginAllowThreads();
46968 result = (arg1)->GetPosition();
46969 wxPyEndAllowThreads(__tstate);
46970 if (PyErr_Occurred()) SWIG_fail;
46971 }
46972 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46973 return resultobj;
46974 fail:
46975 return NULL;
46976 }
46977
46978
46979 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46980 PyObject *resultobj = 0;
46981 wxSizer *arg1 = (wxSizer *) 0 ;
46982 wxSize result;
46983 void *argp1 = 0 ;
46984 int res1 = 0 ;
46985 PyObject *swig_obj[1] ;
46986
46987 if (!args) SWIG_fail;
46988 swig_obj[0] = args;
46989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46990 if (!SWIG_IsOK(res1)) {
46991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46992 }
46993 arg1 = reinterpret_cast< wxSizer * >(argp1);
46994 {
46995 PyThreadState* __tstate = wxPyBeginAllowThreads();
46996 result = (arg1)->GetMinSize();
46997 wxPyEndAllowThreads(__tstate);
46998 if (PyErr_Occurred()) SWIG_fail;
46999 }
47000 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47001 return resultobj;
47002 fail:
47003 return NULL;
47004 }
47005
47006
47007 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47008 PyObject *resultobj = 0;
47009 wxSizer *arg1 = (wxSizer *) 0 ;
47010 void *argp1 = 0 ;
47011 int res1 = 0 ;
47012 PyObject *swig_obj[1] ;
47013
47014 if (!args) SWIG_fail;
47015 swig_obj[0] = args;
47016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47017 if (!SWIG_IsOK(res1)) {
47018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47019 }
47020 arg1 = reinterpret_cast< wxSizer * >(argp1);
47021 {
47022 PyThreadState* __tstate = wxPyBeginAllowThreads();
47023 (arg1)->RecalcSizes();
47024 wxPyEndAllowThreads(__tstate);
47025 if (PyErr_Occurred()) SWIG_fail;
47026 }
47027 resultobj = SWIG_Py_Void();
47028 return resultobj;
47029 fail:
47030 return NULL;
47031 }
47032
47033
47034 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47035 PyObject *resultobj = 0;
47036 wxSizer *arg1 = (wxSizer *) 0 ;
47037 wxSize result;
47038 void *argp1 = 0 ;
47039 int res1 = 0 ;
47040 PyObject *swig_obj[1] ;
47041
47042 if (!args) SWIG_fail;
47043 swig_obj[0] = args;
47044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47045 if (!SWIG_IsOK(res1)) {
47046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47047 }
47048 arg1 = reinterpret_cast< wxSizer * >(argp1);
47049 {
47050 PyThreadState* __tstate = wxPyBeginAllowThreads();
47051 result = (arg1)->CalcMin();
47052 wxPyEndAllowThreads(__tstate);
47053 if (PyErr_Occurred()) SWIG_fail;
47054 }
47055 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47056 return resultobj;
47057 fail:
47058 return NULL;
47059 }
47060
47061
47062 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47063 PyObject *resultobj = 0;
47064 wxSizer *arg1 = (wxSizer *) 0 ;
47065 void *argp1 = 0 ;
47066 int res1 = 0 ;
47067 PyObject *swig_obj[1] ;
47068
47069 if (!args) SWIG_fail;
47070 swig_obj[0] = args;
47071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47072 if (!SWIG_IsOK(res1)) {
47073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47074 }
47075 arg1 = reinterpret_cast< wxSizer * >(argp1);
47076 {
47077 PyThreadState* __tstate = wxPyBeginAllowThreads();
47078 (arg1)->Layout();
47079 wxPyEndAllowThreads(__tstate);
47080 if (PyErr_Occurred()) SWIG_fail;
47081 }
47082 resultobj = SWIG_Py_Void();
47083 return resultobj;
47084 fail:
47085 return NULL;
47086 }
47087
47088
47089 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47090 PyObject *resultobj = 0;
47091 wxSizer *arg1 = (wxSizer *) 0 ;
47092 wxWindow *arg2 = (wxWindow *) 0 ;
47093 wxSize result;
47094 void *argp1 = 0 ;
47095 int res1 = 0 ;
47096 void *argp2 = 0 ;
47097 int res2 = 0 ;
47098 PyObject * obj0 = 0 ;
47099 PyObject * obj1 = 0 ;
47100 char * kwnames[] = {
47101 (char *) "self",(char *) "window", NULL
47102 };
47103
47104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47106 if (!SWIG_IsOK(res1)) {
47107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47108 }
47109 arg1 = reinterpret_cast< wxSizer * >(argp1);
47110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47111 if (!SWIG_IsOK(res2)) {
47112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47113 }
47114 arg2 = reinterpret_cast< wxWindow * >(argp2);
47115 {
47116 PyThreadState* __tstate = wxPyBeginAllowThreads();
47117 result = (arg1)->Fit(arg2);
47118 wxPyEndAllowThreads(__tstate);
47119 if (PyErr_Occurred()) SWIG_fail;
47120 }
47121 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47122 return resultobj;
47123 fail:
47124 return NULL;
47125 }
47126
47127
47128 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47129 PyObject *resultobj = 0;
47130 wxSizer *arg1 = (wxSizer *) 0 ;
47131 wxWindow *arg2 = (wxWindow *) 0 ;
47132 void *argp1 = 0 ;
47133 int res1 = 0 ;
47134 void *argp2 = 0 ;
47135 int res2 = 0 ;
47136 PyObject * obj0 = 0 ;
47137 PyObject * obj1 = 0 ;
47138 char * kwnames[] = {
47139 (char *) "self",(char *) "window", NULL
47140 };
47141
47142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47144 if (!SWIG_IsOK(res1)) {
47145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47146 }
47147 arg1 = reinterpret_cast< wxSizer * >(argp1);
47148 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47149 if (!SWIG_IsOK(res2)) {
47150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47151 }
47152 arg2 = reinterpret_cast< wxWindow * >(argp2);
47153 {
47154 PyThreadState* __tstate = wxPyBeginAllowThreads();
47155 (arg1)->FitInside(arg2);
47156 wxPyEndAllowThreads(__tstate);
47157 if (PyErr_Occurred()) SWIG_fail;
47158 }
47159 resultobj = SWIG_Py_Void();
47160 return resultobj;
47161 fail:
47162 return NULL;
47163 }
47164
47165
47166 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47167 PyObject *resultobj = 0;
47168 wxSizer *arg1 = (wxSizer *) 0 ;
47169 wxWindow *arg2 = (wxWindow *) 0 ;
47170 void *argp1 = 0 ;
47171 int res1 = 0 ;
47172 void *argp2 = 0 ;
47173 int res2 = 0 ;
47174 PyObject * obj0 = 0 ;
47175 PyObject * obj1 = 0 ;
47176 char * kwnames[] = {
47177 (char *) "self",(char *) "window", NULL
47178 };
47179
47180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47182 if (!SWIG_IsOK(res1)) {
47183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47184 }
47185 arg1 = reinterpret_cast< wxSizer * >(argp1);
47186 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47187 if (!SWIG_IsOK(res2)) {
47188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47189 }
47190 arg2 = reinterpret_cast< wxWindow * >(argp2);
47191 {
47192 PyThreadState* __tstate = wxPyBeginAllowThreads();
47193 (arg1)->SetSizeHints(arg2);
47194 wxPyEndAllowThreads(__tstate);
47195 if (PyErr_Occurred()) SWIG_fail;
47196 }
47197 resultobj = SWIG_Py_Void();
47198 return resultobj;
47199 fail:
47200 return NULL;
47201 }
47202
47203
47204 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47205 PyObject *resultobj = 0;
47206 wxSizer *arg1 = (wxSizer *) 0 ;
47207 wxWindow *arg2 = (wxWindow *) 0 ;
47208 void *argp1 = 0 ;
47209 int res1 = 0 ;
47210 void *argp2 = 0 ;
47211 int res2 = 0 ;
47212 PyObject * obj0 = 0 ;
47213 PyObject * obj1 = 0 ;
47214 char * kwnames[] = {
47215 (char *) "self",(char *) "window", NULL
47216 };
47217
47218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47220 if (!SWIG_IsOK(res1)) {
47221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47222 }
47223 arg1 = reinterpret_cast< wxSizer * >(argp1);
47224 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47225 if (!SWIG_IsOK(res2)) {
47226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47227 }
47228 arg2 = reinterpret_cast< wxWindow * >(argp2);
47229 {
47230 PyThreadState* __tstate = wxPyBeginAllowThreads();
47231 (arg1)->SetVirtualSizeHints(arg2);
47232 wxPyEndAllowThreads(__tstate);
47233 if (PyErr_Occurred()) SWIG_fail;
47234 }
47235 resultobj = SWIG_Py_Void();
47236 return resultobj;
47237 fail:
47238 return NULL;
47239 }
47240
47241
47242 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47243 PyObject *resultobj = 0;
47244 wxSizer *arg1 = (wxSizer *) 0 ;
47245 bool arg2 = (bool) false ;
47246 void *argp1 = 0 ;
47247 int res1 = 0 ;
47248 bool val2 ;
47249 int ecode2 = 0 ;
47250 PyObject * obj0 = 0 ;
47251 PyObject * obj1 = 0 ;
47252 char * kwnames[] = {
47253 (char *) "self",(char *) "deleteWindows", NULL
47254 };
47255
47256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47258 if (!SWIG_IsOK(res1)) {
47259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47260 }
47261 arg1 = reinterpret_cast< wxSizer * >(argp1);
47262 if (obj1) {
47263 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47264 if (!SWIG_IsOK(ecode2)) {
47265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47266 }
47267 arg2 = static_cast< bool >(val2);
47268 }
47269 {
47270 PyThreadState* __tstate = wxPyBeginAllowThreads();
47271 (arg1)->Clear(arg2);
47272 wxPyEndAllowThreads(__tstate);
47273 if (PyErr_Occurred()) SWIG_fail;
47274 }
47275 resultobj = SWIG_Py_Void();
47276 return resultobj;
47277 fail:
47278 return NULL;
47279 }
47280
47281
47282 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47283 PyObject *resultobj = 0;
47284 wxSizer *arg1 = (wxSizer *) 0 ;
47285 void *argp1 = 0 ;
47286 int res1 = 0 ;
47287 PyObject *swig_obj[1] ;
47288
47289 if (!args) SWIG_fail;
47290 swig_obj[0] = args;
47291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47292 if (!SWIG_IsOK(res1)) {
47293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47294 }
47295 arg1 = reinterpret_cast< wxSizer * >(argp1);
47296 {
47297 PyThreadState* __tstate = wxPyBeginAllowThreads();
47298 (arg1)->DeleteWindows();
47299 wxPyEndAllowThreads(__tstate);
47300 if (PyErr_Occurred()) SWIG_fail;
47301 }
47302 resultobj = SWIG_Py_Void();
47303 return resultobj;
47304 fail:
47305 return NULL;
47306 }
47307
47308
47309 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47310 PyObject *resultobj = 0;
47311 wxSizer *arg1 = (wxSizer *) 0 ;
47312 PyObject *result = 0 ;
47313 void *argp1 = 0 ;
47314 int res1 = 0 ;
47315 PyObject *swig_obj[1] ;
47316
47317 if (!args) SWIG_fail;
47318 swig_obj[0] = args;
47319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47320 if (!SWIG_IsOK(res1)) {
47321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47322 }
47323 arg1 = reinterpret_cast< wxSizer * >(argp1);
47324 {
47325 PyThreadState* __tstate = wxPyBeginAllowThreads();
47326 result = (PyObject *)wxSizer_GetChildren(arg1);
47327 wxPyEndAllowThreads(__tstate);
47328 if (PyErr_Occurred()) SWIG_fail;
47329 }
47330 resultobj = result;
47331 return resultobj;
47332 fail:
47333 return NULL;
47334 }
47335
47336
47337 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47338 PyObject *resultobj = 0;
47339 wxSizer *arg1 = (wxSizer *) 0 ;
47340 PyObject *arg2 = (PyObject *) 0 ;
47341 bool arg3 = (bool) true ;
47342 bool arg4 = (bool) false ;
47343 bool result;
47344 void *argp1 = 0 ;
47345 int res1 = 0 ;
47346 bool val3 ;
47347 int ecode3 = 0 ;
47348 bool val4 ;
47349 int ecode4 = 0 ;
47350 PyObject * obj0 = 0 ;
47351 PyObject * obj1 = 0 ;
47352 PyObject * obj2 = 0 ;
47353 PyObject * obj3 = 0 ;
47354 char * kwnames[] = {
47355 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47356 };
47357
47358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47360 if (!SWIG_IsOK(res1)) {
47361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47362 }
47363 arg1 = reinterpret_cast< wxSizer * >(argp1);
47364 arg2 = obj1;
47365 if (obj2) {
47366 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47367 if (!SWIG_IsOK(ecode3)) {
47368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47369 }
47370 arg3 = static_cast< bool >(val3);
47371 }
47372 if (obj3) {
47373 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47374 if (!SWIG_IsOK(ecode4)) {
47375 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47376 }
47377 arg4 = static_cast< bool >(val4);
47378 }
47379 {
47380 PyThreadState* __tstate = wxPyBeginAllowThreads();
47381 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47382 wxPyEndAllowThreads(__tstate);
47383 if (PyErr_Occurred()) SWIG_fail;
47384 }
47385 {
47386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47387 }
47388 return resultobj;
47389 fail:
47390 return NULL;
47391 }
47392
47393
47394 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47395 PyObject *resultobj = 0;
47396 wxSizer *arg1 = (wxSizer *) 0 ;
47397 PyObject *arg2 = (PyObject *) 0 ;
47398 bool result;
47399 void *argp1 = 0 ;
47400 int res1 = 0 ;
47401 PyObject * obj0 = 0 ;
47402 PyObject * obj1 = 0 ;
47403 char * kwnames[] = {
47404 (char *) "self",(char *) "item", NULL
47405 };
47406
47407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47409 if (!SWIG_IsOK(res1)) {
47410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47411 }
47412 arg1 = reinterpret_cast< wxSizer * >(argp1);
47413 arg2 = obj1;
47414 {
47415 PyThreadState* __tstate = wxPyBeginAllowThreads();
47416 result = (bool)wxSizer_IsShown(arg1,arg2);
47417 wxPyEndAllowThreads(__tstate);
47418 if (PyErr_Occurred()) SWIG_fail;
47419 }
47420 {
47421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47422 }
47423 return resultobj;
47424 fail:
47425 return NULL;
47426 }
47427
47428
47429 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47430 PyObject *resultobj = 0;
47431 wxSizer *arg1 = (wxSizer *) 0 ;
47432 bool arg2 ;
47433 void *argp1 = 0 ;
47434 int res1 = 0 ;
47435 bool val2 ;
47436 int ecode2 = 0 ;
47437 PyObject * obj0 = 0 ;
47438 PyObject * obj1 = 0 ;
47439 char * kwnames[] = {
47440 (char *) "self",(char *) "show", NULL
47441 };
47442
47443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47445 if (!SWIG_IsOK(res1)) {
47446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47447 }
47448 arg1 = reinterpret_cast< wxSizer * >(argp1);
47449 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47450 if (!SWIG_IsOK(ecode2)) {
47451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47452 }
47453 arg2 = static_cast< bool >(val2);
47454 {
47455 PyThreadState* __tstate = wxPyBeginAllowThreads();
47456 (arg1)->ShowItems(arg2);
47457 wxPyEndAllowThreads(__tstate);
47458 if (PyErr_Occurred()) SWIG_fail;
47459 }
47460 resultobj = SWIG_Py_Void();
47461 return resultobj;
47462 fail:
47463 return NULL;
47464 }
47465
47466
47467 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47468 PyObject *obj;
47469 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47470 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47471 return SWIG_Py_Void();
47472 }
47473
47474 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47475 PyObject *resultobj = 0;
47476 wxPySizer *result = 0 ;
47477
47478 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47479 {
47480 PyThreadState* __tstate = wxPyBeginAllowThreads();
47481 result = (wxPySizer *)new wxPySizer();
47482 wxPyEndAllowThreads(__tstate);
47483 if (PyErr_Occurred()) SWIG_fail;
47484 }
47485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47486 return resultobj;
47487 fail:
47488 return NULL;
47489 }
47490
47491
47492 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47493 PyObject *resultobj = 0;
47494 wxPySizer *arg1 = (wxPySizer *) 0 ;
47495 PyObject *arg2 = (PyObject *) 0 ;
47496 PyObject *arg3 = (PyObject *) 0 ;
47497 void *argp1 = 0 ;
47498 int res1 = 0 ;
47499 PyObject * obj0 = 0 ;
47500 PyObject * obj1 = 0 ;
47501 PyObject * obj2 = 0 ;
47502 char * kwnames[] = {
47503 (char *) "self",(char *) "self",(char *) "_class", NULL
47504 };
47505
47506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47508 if (!SWIG_IsOK(res1)) {
47509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47510 }
47511 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47512 arg2 = obj1;
47513 arg3 = obj2;
47514 {
47515 PyThreadState* __tstate = wxPyBeginAllowThreads();
47516 (arg1)->_setCallbackInfo(arg2,arg3);
47517 wxPyEndAllowThreads(__tstate);
47518 if (PyErr_Occurred()) SWIG_fail;
47519 }
47520 resultobj = SWIG_Py_Void();
47521 return resultobj;
47522 fail:
47523 return NULL;
47524 }
47525
47526
47527 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47528 PyObject *obj;
47529 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47530 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47531 return SWIG_Py_Void();
47532 }
47533
47534 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47535 return SWIG_Python_InitShadowInstance(args);
47536 }
47537
47538 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47539 PyObject *resultobj = 0;
47540 int arg1 = (int) wxHORIZONTAL ;
47541 wxBoxSizer *result = 0 ;
47542 int val1 ;
47543 int ecode1 = 0 ;
47544 PyObject * obj0 = 0 ;
47545 char * kwnames[] = {
47546 (char *) "orient", NULL
47547 };
47548
47549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47550 if (obj0) {
47551 ecode1 = SWIG_AsVal_int(obj0, &val1);
47552 if (!SWIG_IsOK(ecode1)) {
47553 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47554 }
47555 arg1 = static_cast< int >(val1);
47556 }
47557 {
47558 PyThreadState* __tstate = wxPyBeginAllowThreads();
47559 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47560 wxPyEndAllowThreads(__tstate);
47561 if (PyErr_Occurred()) SWIG_fail;
47562 }
47563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47564 return resultobj;
47565 fail:
47566 return NULL;
47567 }
47568
47569
47570 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47571 PyObject *resultobj = 0;
47572 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47573 int result;
47574 void *argp1 = 0 ;
47575 int res1 = 0 ;
47576 PyObject *swig_obj[1] ;
47577
47578 if (!args) SWIG_fail;
47579 swig_obj[0] = args;
47580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47581 if (!SWIG_IsOK(res1)) {
47582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47583 }
47584 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47585 {
47586 PyThreadState* __tstate = wxPyBeginAllowThreads();
47587 result = (int)(arg1)->GetOrientation();
47588 wxPyEndAllowThreads(__tstate);
47589 if (PyErr_Occurred()) SWIG_fail;
47590 }
47591 resultobj = SWIG_From_int(static_cast< int >(result));
47592 return resultobj;
47593 fail:
47594 return NULL;
47595 }
47596
47597
47598 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47599 PyObject *resultobj = 0;
47600 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47601 int arg2 ;
47602 void *argp1 = 0 ;
47603 int res1 = 0 ;
47604 int val2 ;
47605 int ecode2 = 0 ;
47606 PyObject * obj0 = 0 ;
47607 PyObject * obj1 = 0 ;
47608 char * kwnames[] = {
47609 (char *) "self",(char *) "orient", NULL
47610 };
47611
47612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47614 if (!SWIG_IsOK(res1)) {
47615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47616 }
47617 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47618 ecode2 = SWIG_AsVal_int(obj1, &val2);
47619 if (!SWIG_IsOK(ecode2)) {
47620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47621 }
47622 arg2 = static_cast< int >(val2);
47623 {
47624 PyThreadState* __tstate = wxPyBeginAllowThreads();
47625 (arg1)->SetOrientation(arg2);
47626 wxPyEndAllowThreads(__tstate);
47627 if (PyErr_Occurred()) SWIG_fail;
47628 }
47629 resultobj = SWIG_Py_Void();
47630 return resultobj;
47631 fail:
47632 return NULL;
47633 }
47634
47635
47636 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47637 PyObject *obj;
47638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47639 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47640 return SWIG_Py_Void();
47641 }
47642
47643 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47644 return SWIG_Python_InitShadowInstance(args);
47645 }
47646
47647 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47648 PyObject *resultobj = 0;
47649 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47650 int arg2 = (int) wxHORIZONTAL ;
47651 wxStaticBoxSizer *result = 0 ;
47652 void *argp1 = 0 ;
47653 int res1 = 0 ;
47654 int val2 ;
47655 int ecode2 = 0 ;
47656 PyObject * obj0 = 0 ;
47657 PyObject * obj1 = 0 ;
47658 char * kwnames[] = {
47659 (char *) "box",(char *) "orient", NULL
47660 };
47661
47662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47664 if (!SWIG_IsOK(res1)) {
47665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47666 }
47667 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47668 if (obj1) {
47669 ecode2 = SWIG_AsVal_int(obj1, &val2);
47670 if (!SWIG_IsOK(ecode2)) {
47671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47672 }
47673 arg2 = static_cast< int >(val2);
47674 }
47675 {
47676 PyThreadState* __tstate = wxPyBeginAllowThreads();
47677 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47678 wxPyEndAllowThreads(__tstate);
47679 if (PyErr_Occurred()) SWIG_fail;
47680 }
47681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47682 return resultobj;
47683 fail:
47684 return NULL;
47685 }
47686
47687
47688 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47689 PyObject *resultobj = 0;
47690 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47691 wxStaticBox *result = 0 ;
47692 void *argp1 = 0 ;
47693 int res1 = 0 ;
47694 PyObject *swig_obj[1] ;
47695
47696 if (!args) SWIG_fail;
47697 swig_obj[0] = args;
47698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47699 if (!SWIG_IsOK(res1)) {
47700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47701 }
47702 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47703 {
47704 PyThreadState* __tstate = wxPyBeginAllowThreads();
47705 result = (wxStaticBox *)(arg1)->GetStaticBox();
47706 wxPyEndAllowThreads(__tstate);
47707 if (PyErr_Occurred()) SWIG_fail;
47708 }
47709 {
47710 resultobj = wxPyMake_wxObject(result, (bool)0);
47711 }
47712 return resultobj;
47713 fail:
47714 return NULL;
47715 }
47716
47717
47718 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47719 PyObject *obj;
47720 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47721 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47722 return SWIG_Py_Void();
47723 }
47724
47725 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47726 return SWIG_Python_InitShadowInstance(args);
47727 }
47728
47729 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47730 PyObject *resultobj = 0;
47731 int arg1 = (int) 1 ;
47732 int arg2 = (int) 0 ;
47733 int arg3 = (int) 0 ;
47734 int arg4 = (int) 0 ;
47735 wxGridSizer *result = 0 ;
47736 int val1 ;
47737 int ecode1 = 0 ;
47738 int val2 ;
47739 int ecode2 = 0 ;
47740 int val3 ;
47741 int ecode3 = 0 ;
47742 int val4 ;
47743 int ecode4 = 0 ;
47744 PyObject * obj0 = 0 ;
47745 PyObject * obj1 = 0 ;
47746 PyObject * obj2 = 0 ;
47747 PyObject * obj3 = 0 ;
47748 char * kwnames[] = {
47749 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47750 };
47751
47752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47753 if (obj0) {
47754 ecode1 = SWIG_AsVal_int(obj0, &val1);
47755 if (!SWIG_IsOK(ecode1)) {
47756 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47757 }
47758 arg1 = static_cast< int >(val1);
47759 }
47760 if (obj1) {
47761 ecode2 = SWIG_AsVal_int(obj1, &val2);
47762 if (!SWIG_IsOK(ecode2)) {
47763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47764 }
47765 arg2 = static_cast< int >(val2);
47766 }
47767 if (obj2) {
47768 ecode3 = SWIG_AsVal_int(obj2, &val3);
47769 if (!SWIG_IsOK(ecode3)) {
47770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47771 }
47772 arg3 = static_cast< int >(val3);
47773 }
47774 if (obj3) {
47775 ecode4 = SWIG_AsVal_int(obj3, &val4);
47776 if (!SWIG_IsOK(ecode4)) {
47777 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47778 }
47779 arg4 = static_cast< int >(val4);
47780 }
47781 {
47782 PyThreadState* __tstate = wxPyBeginAllowThreads();
47783 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47784 wxPyEndAllowThreads(__tstate);
47785 if (PyErr_Occurred()) SWIG_fail;
47786 }
47787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47788 return resultobj;
47789 fail:
47790 return NULL;
47791 }
47792
47793
47794 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47795 PyObject *resultobj = 0;
47796 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47797 int arg2 ;
47798 void *argp1 = 0 ;
47799 int res1 = 0 ;
47800 int val2 ;
47801 int ecode2 = 0 ;
47802 PyObject * obj0 = 0 ;
47803 PyObject * obj1 = 0 ;
47804 char * kwnames[] = {
47805 (char *) "self",(char *) "cols", NULL
47806 };
47807
47808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47810 if (!SWIG_IsOK(res1)) {
47811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47812 }
47813 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47814 ecode2 = SWIG_AsVal_int(obj1, &val2);
47815 if (!SWIG_IsOK(ecode2)) {
47816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47817 }
47818 arg2 = static_cast< int >(val2);
47819 {
47820 PyThreadState* __tstate = wxPyBeginAllowThreads();
47821 (arg1)->SetCols(arg2);
47822 wxPyEndAllowThreads(__tstate);
47823 if (PyErr_Occurred()) SWIG_fail;
47824 }
47825 resultobj = SWIG_Py_Void();
47826 return resultobj;
47827 fail:
47828 return NULL;
47829 }
47830
47831
47832 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47833 PyObject *resultobj = 0;
47834 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47835 int arg2 ;
47836 void *argp1 = 0 ;
47837 int res1 = 0 ;
47838 int val2 ;
47839 int ecode2 = 0 ;
47840 PyObject * obj0 = 0 ;
47841 PyObject * obj1 = 0 ;
47842 char * kwnames[] = {
47843 (char *) "self",(char *) "rows", NULL
47844 };
47845
47846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47848 if (!SWIG_IsOK(res1)) {
47849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47850 }
47851 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47852 ecode2 = SWIG_AsVal_int(obj1, &val2);
47853 if (!SWIG_IsOK(ecode2)) {
47854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47855 }
47856 arg2 = static_cast< int >(val2);
47857 {
47858 PyThreadState* __tstate = wxPyBeginAllowThreads();
47859 (arg1)->SetRows(arg2);
47860 wxPyEndAllowThreads(__tstate);
47861 if (PyErr_Occurred()) SWIG_fail;
47862 }
47863 resultobj = SWIG_Py_Void();
47864 return resultobj;
47865 fail:
47866 return NULL;
47867 }
47868
47869
47870 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47871 PyObject *resultobj = 0;
47872 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47873 int arg2 ;
47874 void *argp1 = 0 ;
47875 int res1 = 0 ;
47876 int val2 ;
47877 int ecode2 = 0 ;
47878 PyObject * obj0 = 0 ;
47879 PyObject * obj1 = 0 ;
47880 char * kwnames[] = {
47881 (char *) "self",(char *) "gap", NULL
47882 };
47883
47884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47886 if (!SWIG_IsOK(res1)) {
47887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47888 }
47889 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47890 ecode2 = SWIG_AsVal_int(obj1, &val2);
47891 if (!SWIG_IsOK(ecode2)) {
47892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47893 }
47894 arg2 = static_cast< int >(val2);
47895 {
47896 PyThreadState* __tstate = wxPyBeginAllowThreads();
47897 (arg1)->SetVGap(arg2);
47898 wxPyEndAllowThreads(__tstate);
47899 if (PyErr_Occurred()) SWIG_fail;
47900 }
47901 resultobj = SWIG_Py_Void();
47902 return resultobj;
47903 fail:
47904 return NULL;
47905 }
47906
47907
47908 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47909 PyObject *resultobj = 0;
47910 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47911 int arg2 ;
47912 void *argp1 = 0 ;
47913 int res1 = 0 ;
47914 int val2 ;
47915 int ecode2 = 0 ;
47916 PyObject * obj0 = 0 ;
47917 PyObject * obj1 = 0 ;
47918 char * kwnames[] = {
47919 (char *) "self",(char *) "gap", NULL
47920 };
47921
47922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47924 if (!SWIG_IsOK(res1)) {
47925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47926 }
47927 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47928 ecode2 = SWIG_AsVal_int(obj1, &val2);
47929 if (!SWIG_IsOK(ecode2)) {
47930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47931 }
47932 arg2 = static_cast< int >(val2);
47933 {
47934 PyThreadState* __tstate = wxPyBeginAllowThreads();
47935 (arg1)->SetHGap(arg2);
47936 wxPyEndAllowThreads(__tstate);
47937 if (PyErr_Occurred()) SWIG_fail;
47938 }
47939 resultobj = SWIG_Py_Void();
47940 return resultobj;
47941 fail:
47942 return NULL;
47943 }
47944
47945
47946 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47947 PyObject *resultobj = 0;
47948 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47949 int result;
47950 void *argp1 = 0 ;
47951 int res1 = 0 ;
47952 PyObject *swig_obj[1] ;
47953
47954 if (!args) SWIG_fail;
47955 swig_obj[0] = args;
47956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47957 if (!SWIG_IsOK(res1)) {
47958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47959 }
47960 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47961 {
47962 PyThreadState* __tstate = wxPyBeginAllowThreads();
47963 result = (int)(arg1)->GetCols();
47964 wxPyEndAllowThreads(__tstate);
47965 if (PyErr_Occurred()) SWIG_fail;
47966 }
47967 resultobj = SWIG_From_int(static_cast< int >(result));
47968 return resultobj;
47969 fail:
47970 return NULL;
47971 }
47972
47973
47974 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47975 PyObject *resultobj = 0;
47976 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47977 int result;
47978 void *argp1 = 0 ;
47979 int res1 = 0 ;
47980 PyObject *swig_obj[1] ;
47981
47982 if (!args) SWIG_fail;
47983 swig_obj[0] = args;
47984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47985 if (!SWIG_IsOK(res1)) {
47986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47987 }
47988 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47989 {
47990 PyThreadState* __tstate = wxPyBeginAllowThreads();
47991 result = (int)(arg1)->GetRows();
47992 wxPyEndAllowThreads(__tstate);
47993 if (PyErr_Occurred()) SWIG_fail;
47994 }
47995 resultobj = SWIG_From_int(static_cast< int >(result));
47996 return resultobj;
47997 fail:
47998 return NULL;
47999 }
48000
48001
48002 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48003 PyObject *resultobj = 0;
48004 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48005 int result;
48006 void *argp1 = 0 ;
48007 int res1 = 0 ;
48008 PyObject *swig_obj[1] ;
48009
48010 if (!args) SWIG_fail;
48011 swig_obj[0] = args;
48012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48013 if (!SWIG_IsOK(res1)) {
48014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48015 }
48016 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48017 {
48018 PyThreadState* __tstate = wxPyBeginAllowThreads();
48019 result = (int)(arg1)->GetVGap();
48020 wxPyEndAllowThreads(__tstate);
48021 if (PyErr_Occurred()) SWIG_fail;
48022 }
48023 resultobj = SWIG_From_int(static_cast< int >(result));
48024 return resultobj;
48025 fail:
48026 return NULL;
48027 }
48028
48029
48030 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48031 PyObject *resultobj = 0;
48032 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48033 int result;
48034 void *argp1 = 0 ;
48035 int res1 = 0 ;
48036 PyObject *swig_obj[1] ;
48037
48038 if (!args) SWIG_fail;
48039 swig_obj[0] = args;
48040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48041 if (!SWIG_IsOK(res1)) {
48042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48043 }
48044 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48045 {
48046 PyThreadState* __tstate = wxPyBeginAllowThreads();
48047 result = (int)(arg1)->GetHGap();
48048 wxPyEndAllowThreads(__tstate);
48049 if (PyErr_Occurred()) SWIG_fail;
48050 }
48051 resultobj = SWIG_From_int(static_cast< int >(result));
48052 return resultobj;
48053 fail:
48054 return NULL;
48055 }
48056
48057
48058 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48059 PyObject *obj;
48060 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48061 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48062 return SWIG_Py_Void();
48063 }
48064
48065 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48066 return SWIG_Python_InitShadowInstance(args);
48067 }
48068
48069 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48070 PyObject *resultobj = 0;
48071 int arg1 = (int) 1 ;
48072 int arg2 = (int) 0 ;
48073 int arg3 = (int) 0 ;
48074 int arg4 = (int) 0 ;
48075 wxFlexGridSizer *result = 0 ;
48076 int val1 ;
48077 int ecode1 = 0 ;
48078 int val2 ;
48079 int ecode2 = 0 ;
48080 int val3 ;
48081 int ecode3 = 0 ;
48082 int val4 ;
48083 int ecode4 = 0 ;
48084 PyObject * obj0 = 0 ;
48085 PyObject * obj1 = 0 ;
48086 PyObject * obj2 = 0 ;
48087 PyObject * obj3 = 0 ;
48088 char * kwnames[] = {
48089 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48090 };
48091
48092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48093 if (obj0) {
48094 ecode1 = SWIG_AsVal_int(obj0, &val1);
48095 if (!SWIG_IsOK(ecode1)) {
48096 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48097 }
48098 arg1 = static_cast< int >(val1);
48099 }
48100 if (obj1) {
48101 ecode2 = SWIG_AsVal_int(obj1, &val2);
48102 if (!SWIG_IsOK(ecode2)) {
48103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48104 }
48105 arg2 = static_cast< int >(val2);
48106 }
48107 if (obj2) {
48108 ecode3 = SWIG_AsVal_int(obj2, &val3);
48109 if (!SWIG_IsOK(ecode3)) {
48110 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48111 }
48112 arg3 = static_cast< int >(val3);
48113 }
48114 if (obj3) {
48115 ecode4 = SWIG_AsVal_int(obj3, &val4);
48116 if (!SWIG_IsOK(ecode4)) {
48117 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48118 }
48119 arg4 = static_cast< int >(val4);
48120 }
48121 {
48122 PyThreadState* __tstate = wxPyBeginAllowThreads();
48123 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48124 wxPyEndAllowThreads(__tstate);
48125 if (PyErr_Occurred()) SWIG_fail;
48126 }
48127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48128 return resultobj;
48129 fail:
48130 return NULL;
48131 }
48132
48133
48134 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48135 PyObject *resultobj = 0;
48136 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48137 size_t arg2 ;
48138 int arg3 = (int) 0 ;
48139 void *argp1 = 0 ;
48140 int res1 = 0 ;
48141 size_t val2 ;
48142 int ecode2 = 0 ;
48143 int val3 ;
48144 int ecode3 = 0 ;
48145 PyObject * obj0 = 0 ;
48146 PyObject * obj1 = 0 ;
48147 PyObject * obj2 = 0 ;
48148 char * kwnames[] = {
48149 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48150 };
48151
48152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48154 if (!SWIG_IsOK(res1)) {
48155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48156 }
48157 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48158 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48159 if (!SWIG_IsOK(ecode2)) {
48160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48161 }
48162 arg2 = static_cast< size_t >(val2);
48163 if (obj2) {
48164 ecode3 = SWIG_AsVal_int(obj2, &val3);
48165 if (!SWIG_IsOK(ecode3)) {
48166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48167 }
48168 arg3 = static_cast< int >(val3);
48169 }
48170 {
48171 PyThreadState* __tstate = wxPyBeginAllowThreads();
48172 (arg1)->AddGrowableRow(arg2,arg3);
48173 wxPyEndAllowThreads(__tstate);
48174 if (PyErr_Occurred()) SWIG_fail;
48175 }
48176 resultobj = SWIG_Py_Void();
48177 return resultobj;
48178 fail:
48179 return NULL;
48180 }
48181
48182
48183 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48184 PyObject *resultobj = 0;
48185 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48186 size_t arg2 ;
48187 void *argp1 = 0 ;
48188 int res1 = 0 ;
48189 size_t val2 ;
48190 int ecode2 = 0 ;
48191 PyObject * obj0 = 0 ;
48192 PyObject * obj1 = 0 ;
48193 char * kwnames[] = {
48194 (char *) "self",(char *) "idx", NULL
48195 };
48196
48197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48199 if (!SWIG_IsOK(res1)) {
48200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48201 }
48202 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48203 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48204 if (!SWIG_IsOK(ecode2)) {
48205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48206 }
48207 arg2 = static_cast< size_t >(val2);
48208 {
48209 PyThreadState* __tstate = wxPyBeginAllowThreads();
48210 (arg1)->RemoveGrowableRow(arg2);
48211 wxPyEndAllowThreads(__tstate);
48212 if (PyErr_Occurred()) SWIG_fail;
48213 }
48214 resultobj = SWIG_Py_Void();
48215 return resultobj;
48216 fail:
48217 return NULL;
48218 }
48219
48220
48221 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48222 PyObject *resultobj = 0;
48223 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48224 size_t arg2 ;
48225 int arg3 = (int) 0 ;
48226 void *argp1 = 0 ;
48227 int res1 = 0 ;
48228 size_t val2 ;
48229 int ecode2 = 0 ;
48230 int val3 ;
48231 int ecode3 = 0 ;
48232 PyObject * obj0 = 0 ;
48233 PyObject * obj1 = 0 ;
48234 PyObject * obj2 = 0 ;
48235 char * kwnames[] = {
48236 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48237 };
48238
48239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48241 if (!SWIG_IsOK(res1)) {
48242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48243 }
48244 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48245 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48246 if (!SWIG_IsOK(ecode2)) {
48247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48248 }
48249 arg2 = static_cast< size_t >(val2);
48250 if (obj2) {
48251 ecode3 = SWIG_AsVal_int(obj2, &val3);
48252 if (!SWIG_IsOK(ecode3)) {
48253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48254 }
48255 arg3 = static_cast< int >(val3);
48256 }
48257 {
48258 PyThreadState* __tstate = wxPyBeginAllowThreads();
48259 (arg1)->AddGrowableCol(arg2,arg3);
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_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48271 PyObject *resultobj = 0;
48272 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48273 size_t arg2 ;
48274 void *argp1 = 0 ;
48275 int res1 = 0 ;
48276 size_t val2 ;
48277 int ecode2 = 0 ;
48278 PyObject * obj0 = 0 ;
48279 PyObject * obj1 = 0 ;
48280 char * kwnames[] = {
48281 (char *) "self",(char *) "idx", NULL
48282 };
48283
48284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48286 if (!SWIG_IsOK(res1)) {
48287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48288 }
48289 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48290 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48291 if (!SWIG_IsOK(ecode2)) {
48292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48293 }
48294 arg2 = static_cast< size_t >(val2);
48295 {
48296 PyThreadState* __tstate = wxPyBeginAllowThreads();
48297 (arg1)->RemoveGrowableCol(arg2);
48298 wxPyEndAllowThreads(__tstate);
48299 if (PyErr_Occurred()) SWIG_fail;
48300 }
48301 resultobj = SWIG_Py_Void();
48302 return resultobj;
48303 fail:
48304 return NULL;
48305 }
48306
48307
48308 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48309 PyObject *resultobj = 0;
48310 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48311 int arg2 ;
48312 void *argp1 = 0 ;
48313 int res1 = 0 ;
48314 int val2 ;
48315 int ecode2 = 0 ;
48316 PyObject * obj0 = 0 ;
48317 PyObject * obj1 = 0 ;
48318 char * kwnames[] = {
48319 (char *) "self",(char *) "direction", NULL
48320 };
48321
48322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48324 if (!SWIG_IsOK(res1)) {
48325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48326 }
48327 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48328 ecode2 = SWIG_AsVal_int(obj1, &val2);
48329 if (!SWIG_IsOK(ecode2)) {
48330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48331 }
48332 arg2 = static_cast< int >(val2);
48333 {
48334 PyThreadState* __tstate = wxPyBeginAllowThreads();
48335 (arg1)->SetFlexibleDirection(arg2);
48336 wxPyEndAllowThreads(__tstate);
48337 if (PyErr_Occurred()) SWIG_fail;
48338 }
48339 resultobj = SWIG_Py_Void();
48340 return resultobj;
48341 fail:
48342 return NULL;
48343 }
48344
48345
48346 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48347 PyObject *resultobj = 0;
48348 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48349 int result;
48350 void *argp1 = 0 ;
48351 int res1 = 0 ;
48352 PyObject *swig_obj[1] ;
48353
48354 if (!args) SWIG_fail;
48355 swig_obj[0] = args;
48356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48357 if (!SWIG_IsOK(res1)) {
48358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48359 }
48360 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48361 {
48362 PyThreadState* __tstate = wxPyBeginAllowThreads();
48363 result = (int)(arg1)->GetFlexibleDirection();
48364 wxPyEndAllowThreads(__tstate);
48365 if (PyErr_Occurred()) SWIG_fail;
48366 }
48367 resultobj = SWIG_From_int(static_cast< int >(result));
48368 return resultobj;
48369 fail:
48370 return NULL;
48371 }
48372
48373
48374 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48375 PyObject *resultobj = 0;
48376 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48377 wxFlexSizerGrowMode arg2 ;
48378 void *argp1 = 0 ;
48379 int res1 = 0 ;
48380 int val2 ;
48381 int ecode2 = 0 ;
48382 PyObject * obj0 = 0 ;
48383 PyObject * obj1 = 0 ;
48384 char * kwnames[] = {
48385 (char *) "self",(char *) "mode", NULL
48386 };
48387
48388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48390 if (!SWIG_IsOK(res1)) {
48391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48392 }
48393 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48394 ecode2 = SWIG_AsVal_int(obj1, &val2);
48395 if (!SWIG_IsOK(ecode2)) {
48396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48397 }
48398 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48399 {
48400 PyThreadState* __tstate = wxPyBeginAllowThreads();
48401 (arg1)->SetNonFlexibleGrowMode(arg2);
48402 wxPyEndAllowThreads(__tstate);
48403 if (PyErr_Occurred()) SWIG_fail;
48404 }
48405 resultobj = SWIG_Py_Void();
48406 return resultobj;
48407 fail:
48408 return NULL;
48409 }
48410
48411
48412 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48413 PyObject *resultobj = 0;
48414 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48415 wxFlexSizerGrowMode result;
48416 void *argp1 = 0 ;
48417 int res1 = 0 ;
48418 PyObject *swig_obj[1] ;
48419
48420 if (!args) SWIG_fail;
48421 swig_obj[0] = args;
48422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48423 if (!SWIG_IsOK(res1)) {
48424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48425 }
48426 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48427 {
48428 PyThreadState* __tstate = wxPyBeginAllowThreads();
48429 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48430 wxPyEndAllowThreads(__tstate);
48431 if (PyErr_Occurred()) SWIG_fail;
48432 }
48433 resultobj = SWIG_From_int(static_cast< int >(result));
48434 return resultobj;
48435 fail:
48436 return NULL;
48437 }
48438
48439
48440 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48441 PyObject *resultobj = 0;
48442 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48443 wxArrayInt *result = 0 ;
48444 void *argp1 = 0 ;
48445 int res1 = 0 ;
48446 PyObject *swig_obj[1] ;
48447
48448 if (!args) SWIG_fail;
48449 swig_obj[0] = args;
48450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48451 if (!SWIG_IsOK(res1)) {
48452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48453 }
48454 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48455 {
48456 PyThreadState* __tstate = wxPyBeginAllowThreads();
48457 {
48458 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48459 result = (wxArrayInt *) &_result_ref;
48460 }
48461 wxPyEndAllowThreads(__tstate);
48462 if (PyErr_Occurred()) SWIG_fail;
48463 }
48464 {
48465 resultobj = PyList_New(0);
48466 size_t idx;
48467 for (idx = 0; idx < result->GetCount(); idx += 1) {
48468 PyObject* val = PyInt_FromLong( result->Item(idx) );
48469 PyList_Append(resultobj, val);
48470 Py_DECREF(val);
48471 }
48472 }
48473 return resultobj;
48474 fail:
48475 return NULL;
48476 }
48477
48478
48479 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48480 PyObject *resultobj = 0;
48481 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48482 wxArrayInt *result = 0 ;
48483 void *argp1 = 0 ;
48484 int res1 = 0 ;
48485 PyObject *swig_obj[1] ;
48486
48487 if (!args) SWIG_fail;
48488 swig_obj[0] = args;
48489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48490 if (!SWIG_IsOK(res1)) {
48491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48492 }
48493 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48494 {
48495 PyThreadState* __tstate = wxPyBeginAllowThreads();
48496 {
48497 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48498 result = (wxArrayInt *) &_result_ref;
48499 }
48500 wxPyEndAllowThreads(__tstate);
48501 if (PyErr_Occurred()) SWIG_fail;
48502 }
48503 {
48504 resultobj = PyList_New(0);
48505 size_t idx;
48506 for (idx = 0; idx < result->GetCount(); idx += 1) {
48507 PyObject* val = PyInt_FromLong( result->Item(idx) );
48508 PyList_Append(resultobj, val);
48509 Py_DECREF(val);
48510 }
48511 }
48512 return resultobj;
48513 fail:
48514 return NULL;
48515 }
48516
48517
48518 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48519 PyObject *obj;
48520 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48521 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48522 return SWIG_Py_Void();
48523 }
48524
48525 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48526 return SWIG_Python_InitShadowInstance(args);
48527 }
48528
48529 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48530 PyObject *resultobj = 0;
48531 wxStdDialogButtonSizer *result = 0 ;
48532
48533 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48534 {
48535 PyThreadState* __tstate = wxPyBeginAllowThreads();
48536 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48537 wxPyEndAllowThreads(__tstate);
48538 if (PyErr_Occurred()) SWIG_fail;
48539 }
48540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48541 return resultobj;
48542 fail:
48543 return NULL;
48544 }
48545
48546
48547 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48548 PyObject *resultobj = 0;
48549 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48550 wxButton *arg2 = (wxButton *) 0 ;
48551 void *argp1 = 0 ;
48552 int res1 = 0 ;
48553 void *argp2 = 0 ;
48554 int res2 = 0 ;
48555 PyObject * obj0 = 0 ;
48556 PyObject * obj1 = 0 ;
48557 char * kwnames[] = {
48558 (char *) "self",(char *) "button", NULL
48559 };
48560
48561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48563 if (!SWIG_IsOK(res1)) {
48564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48565 }
48566 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48567 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48568 if (!SWIG_IsOK(res2)) {
48569 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48570 }
48571 arg2 = reinterpret_cast< wxButton * >(argp2);
48572 {
48573 PyThreadState* __tstate = wxPyBeginAllowThreads();
48574 (arg1)->AddButton(arg2);
48575 wxPyEndAllowThreads(__tstate);
48576 if (PyErr_Occurred()) SWIG_fail;
48577 }
48578 resultobj = SWIG_Py_Void();
48579 return resultobj;
48580 fail:
48581 return NULL;
48582 }
48583
48584
48585 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48586 PyObject *resultobj = 0;
48587 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48588 void *argp1 = 0 ;
48589 int res1 = 0 ;
48590 PyObject *swig_obj[1] ;
48591
48592 if (!args) SWIG_fail;
48593 swig_obj[0] = args;
48594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48595 if (!SWIG_IsOK(res1)) {
48596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48597 }
48598 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48599 {
48600 PyThreadState* __tstate = wxPyBeginAllowThreads();
48601 (arg1)->Realize();
48602 wxPyEndAllowThreads(__tstate);
48603 if (PyErr_Occurred()) SWIG_fail;
48604 }
48605 resultobj = SWIG_Py_Void();
48606 return resultobj;
48607 fail:
48608 return NULL;
48609 }
48610
48611
48612 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48613 PyObject *resultobj = 0;
48614 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48615 wxButton *arg2 = (wxButton *) 0 ;
48616 void *argp1 = 0 ;
48617 int res1 = 0 ;
48618 void *argp2 = 0 ;
48619 int res2 = 0 ;
48620 PyObject * obj0 = 0 ;
48621 PyObject * obj1 = 0 ;
48622 char * kwnames[] = {
48623 (char *) "self",(char *) "button", NULL
48624 };
48625
48626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48628 if (!SWIG_IsOK(res1)) {
48629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48630 }
48631 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48632 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48633 if (!SWIG_IsOK(res2)) {
48634 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48635 }
48636 arg2 = reinterpret_cast< wxButton * >(argp2);
48637 {
48638 PyThreadState* __tstate = wxPyBeginAllowThreads();
48639 (arg1)->SetAffirmativeButton(arg2);
48640 wxPyEndAllowThreads(__tstate);
48641 if (PyErr_Occurred()) SWIG_fail;
48642 }
48643 resultobj = SWIG_Py_Void();
48644 return resultobj;
48645 fail:
48646 return NULL;
48647 }
48648
48649
48650 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48651 PyObject *resultobj = 0;
48652 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48653 wxButton *arg2 = (wxButton *) 0 ;
48654 void *argp1 = 0 ;
48655 int res1 = 0 ;
48656 void *argp2 = 0 ;
48657 int res2 = 0 ;
48658 PyObject * obj0 = 0 ;
48659 PyObject * obj1 = 0 ;
48660 char * kwnames[] = {
48661 (char *) "self",(char *) "button", NULL
48662 };
48663
48664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48666 if (!SWIG_IsOK(res1)) {
48667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48668 }
48669 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48670 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48671 if (!SWIG_IsOK(res2)) {
48672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48673 }
48674 arg2 = reinterpret_cast< wxButton * >(argp2);
48675 {
48676 PyThreadState* __tstate = wxPyBeginAllowThreads();
48677 (arg1)->SetNegativeButton(arg2);
48678 wxPyEndAllowThreads(__tstate);
48679 if (PyErr_Occurred()) SWIG_fail;
48680 }
48681 resultobj = SWIG_Py_Void();
48682 return resultobj;
48683 fail:
48684 return NULL;
48685 }
48686
48687
48688 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48689 PyObject *resultobj = 0;
48690 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48691 wxButton *arg2 = (wxButton *) 0 ;
48692 void *argp1 = 0 ;
48693 int res1 = 0 ;
48694 void *argp2 = 0 ;
48695 int res2 = 0 ;
48696 PyObject * obj0 = 0 ;
48697 PyObject * obj1 = 0 ;
48698 char * kwnames[] = {
48699 (char *) "self",(char *) "button", NULL
48700 };
48701
48702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48704 if (!SWIG_IsOK(res1)) {
48705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48706 }
48707 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48708 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48709 if (!SWIG_IsOK(res2)) {
48710 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48711 }
48712 arg2 = reinterpret_cast< wxButton * >(argp2);
48713 {
48714 PyThreadState* __tstate = wxPyBeginAllowThreads();
48715 (arg1)->SetCancelButton(arg2);
48716 wxPyEndAllowThreads(__tstate);
48717 if (PyErr_Occurred()) SWIG_fail;
48718 }
48719 resultobj = SWIG_Py_Void();
48720 return resultobj;
48721 fail:
48722 return NULL;
48723 }
48724
48725
48726 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48727 PyObject *resultobj = 0;
48728 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48729 wxButton *result = 0 ;
48730 void *argp1 = 0 ;
48731 int res1 = 0 ;
48732 PyObject *swig_obj[1] ;
48733
48734 if (!args) SWIG_fail;
48735 swig_obj[0] = args;
48736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48737 if (!SWIG_IsOK(res1)) {
48738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48739 }
48740 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48741 {
48742 PyThreadState* __tstate = wxPyBeginAllowThreads();
48743 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48744 wxPyEndAllowThreads(__tstate);
48745 if (PyErr_Occurred()) SWIG_fail;
48746 }
48747 {
48748 resultobj = wxPyMake_wxObject(result, (bool)0);
48749 }
48750 return resultobj;
48751 fail:
48752 return NULL;
48753 }
48754
48755
48756 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48757 PyObject *resultobj = 0;
48758 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48759 wxButton *result = 0 ;
48760 void *argp1 = 0 ;
48761 int res1 = 0 ;
48762 PyObject *swig_obj[1] ;
48763
48764 if (!args) SWIG_fail;
48765 swig_obj[0] = args;
48766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48767 if (!SWIG_IsOK(res1)) {
48768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48769 }
48770 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48771 {
48772 PyThreadState* __tstate = wxPyBeginAllowThreads();
48773 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48774 wxPyEndAllowThreads(__tstate);
48775 if (PyErr_Occurred()) SWIG_fail;
48776 }
48777 {
48778 resultobj = wxPyMake_wxObject(result, (bool)0);
48779 }
48780 return resultobj;
48781 fail:
48782 return NULL;
48783 }
48784
48785
48786 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48787 PyObject *resultobj = 0;
48788 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48789 wxButton *result = 0 ;
48790 void *argp1 = 0 ;
48791 int res1 = 0 ;
48792 PyObject *swig_obj[1] ;
48793
48794 if (!args) SWIG_fail;
48795 swig_obj[0] = args;
48796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48797 if (!SWIG_IsOK(res1)) {
48798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48799 }
48800 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48801 {
48802 PyThreadState* __tstate = wxPyBeginAllowThreads();
48803 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48804 wxPyEndAllowThreads(__tstate);
48805 if (PyErr_Occurred()) SWIG_fail;
48806 }
48807 {
48808 resultobj = wxPyMake_wxObject(result, (bool)0);
48809 }
48810 return resultobj;
48811 fail:
48812 return NULL;
48813 }
48814
48815
48816 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48817 PyObject *resultobj = 0;
48818 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48819 wxButton *result = 0 ;
48820 void *argp1 = 0 ;
48821 int res1 = 0 ;
48822 PyObject *swig_obj[1] ;
48823
48824 if (!args) SWIG_fail;
48825 swig_obj[0] = args;
48826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48827 if (!SWIG_IsOK(res1)) {
48828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48829 }
48830 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48831 {
48832 PyThreadState* __tstate = wxPyBeginAllowThreads();
48833 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48834 wxPyEndAllowThreads(__tstate);
48835 if (PyErr_Occurred()) SWIG_fail;
48836 }
48837 {
48838 resultobj = wxPyMake_wxObject(result, (bool)0);
48839 }
48840 return resultobj;
48841 fail:
48842 return NULL;
48843 }
48844
48845
48846 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48847 PyObject *resultobj = 0;
48848 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48849 wxButton *result = 0 ;
48850 void *argp1 = 0 ;
48851 int res1 = 0 ;
48852 PyObject *swig_obj[1] ;
48853
48854 if (!args) SWIG_fail;
48855 swig_obj[0] = args;
48856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48857 if (!SWIG_IsOK(res1)) {
48858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48859 }
48860 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48861 {
48862 PyThreadState* __tstate = wxPyBeginAllowThreads();
48863 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48864 wxPyEndAllowThreads(__tstate);
48865 if (PyErr_Occurred()) SWIG_fail;
48866 }
48867 {
48868 resultobj = wxPyMake_wxObject(result, (bool)0);
48869 }
48870 return resultobj;
48871 fail:
48872 return NULL;
48873 }
48874
48875
48876 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48877 PyObject *obj;
48878 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48879 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48880 return SWIG_Py_Void();
48881 }
48882
48883 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48884 return SWIG_Python_InitShadowInstance(args);
48885 }
48886
48887 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48888 PyObject *resultobj = 0;
48889 int arg1 = (int) 0 ;
48890 int arg2 = (int) 0 ;
48891 wxGBPosition *result = 0 ;
48892 int val1 ;
48893 int ecode1 = 0 ;
48894 int val2 ;
48895 int ecode2 = 0 ;
48896 PyObject * obj0 = 0 ;
48897 PyObject * obj1 = 0 ;
48898 char * kwnames[] = {
48899 (char *) "row",(char *) "col", NULL
48900 };
48901
48902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48903 if (obj0) {
48904 ecode1 = SWIG_AsVal_int(obj0, &val1);
48905 if (!SWIG_IsOK(ecode1)) {
48906 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48907 }
48908 arg1 = static_cast< int >(val1);
48909 }
48910 if (obj1) {
48911 ecode2 = SWIG_AsVal_int(obj1, &val2);
48912 if (!SWIG_IsOK(ecode2)) {
48913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48914 }
48915 arg2 = static_cast< int >(val2);
48916 }
48917 {
48918 PyThreadState* __tstate = wxPyBeginAllowThreads();
48919 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48920 wxPyEndAllowThreads(__tstate);
48921 if (PyErr_Occurred()) SWIG_fail;
48922 }
48923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48924 return resultobj;
48925 fail:
48926 return NULL;
48927 }
48928
48929
48930 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48931 PyObject *resultobj = 0;
48932 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48933 void *argp1 = 0 ;
48934 int res1 = 0 ;
48935 PyObject *swig_obj[1] ;
48936
48937 if (!args) SWIG_fail;
48938 swig_obj[0] = args;
48939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48940 if (!SWIG_IsOK(res1)) {
48941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48942 }
48943 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48944 {
48945 PyThreadState* __tstate = wxPyBeginAllowThreads();
48946 delete arg1;
48947
48948 wxPyEndAllowThreads(__tstate);
48949 if (PyErr_Occurred()) SWIG_fail;
48950 }
48951 resultobj = SWIG_Py_Void();
48952 return resultobj;
48953 fail:
48954 return NULL;
48955 }
48956
48957
48958 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48959 PyObject *resultobj = 0;
48960 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48961 int result;
48962 void *argp1 = 0 ;
48963 int res1 = 0 ;
48964 PyObject *swig_obj[1] ;
48965
48966 if (!args) SWIG_fail;
48967 swig_obj[0] = args;
48968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48969 if (!SWIG_IsOK(res1)) {
48970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48971 }
48972 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48973 {
48974 PyThreadState* __tstate = wxPyBeginAllowThreads();
48975 result = (int)((wxGBPosition const *)arg1)->GetRow();
48976 wxPyEndAllowThreads(__tstate);
48977 if (PyErr_Occurred()) SWIG_fail;
48978 }
48979 resultobj = SWIG_From_int(static_cast< int >(result));
48980 return resultobj;
48981 fail:
48982 return NULL;
48983 }
48984
48985
48986 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48987 PyObject *resultobj = 0;
48988 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48989 int result;
48990 void *argp1 = 0 ;
48991 int res1 = 0 ;
48992 PyObject *swig_obj[1] ;
48993
48994 if (!args) SWIG_fail;
48995 swig_obj[0] = args;
48996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48997 if (!SWIG_IsOK(res1)) {
48998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48999 }
49000 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49001 {
49002 PyThreadState* __tstate = wxPyBeginAllowThreads();
49003 result = (int)((wxGBPosition const *)arg1)->GetCol();
49004 wxPyEndAllowThreads(__tstate);
49005 if (PyErr_Occurred()) SWIG_fail;
49006 }
49007 resultobj = SWIG_From_int(static_cast< int >(result));
49008 return resultobj;
49009 fail:
49010 return NULL;
49011 }
49012
49013
49014 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49015 PyObject *resultobj = 0;
49016 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49017 int arg2 ;
49018 void *argp1 = 0 ;
49019 int res1 = 0 ;
49020 int val2 ;
49021 int ecode2 = 0 ;
49022 PyObject * obj0 = 0 ;
49023 PyObject * obj1 = 0 ;
49024 char * kwnames[] = {
49025 (char *) "self",(char *) "row", NULL
49026 };
49027
49028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49030 if (!SWIG_IsOK(res1)) {
49031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49032 }
49033 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49034 ecode2 = SWIG_AsVal_int(obj1, &val2);
49035 if (!SWIG_IsOK(ecode2)) {
49036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49037 }
49038 arg2 = static_cast< int >(val2);
49039 {
49040 PyThreadState* __tstate = wxPyBeginAllowThreads();
49041 (arg1)->SetRow(arg2);
49042 wxPyEndAllowThreads(__tstate);
49043 if (PyErr_Occurred()) SWIG_fail;
49044 }
49045 resultobj = SWIG_Py_Void();
49046 return resultobj;
49047 fail:
49048 return NULL;
49049 }
49050
49051
49052 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49053 PyObject *resultobj = 0;
49054 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49055 int arg2 ;
49056 void *argp1 = 0 ;
49057 int res1 = 0 ;
49058 int val2 ;
49059 int ecode2 = 0 ;
49060 PyObject * obj0 = 0 ;
49061 PyObject * obj1 = 0 ;
49062 char * kwnames[] = {
49063 (char *) "self",(char *) "col", NULL
49064 };
49065
49066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49068 if (!SWIG_IsOK(res1)) {
49069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49070 }
49071 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49072 ecode2 = SWIG_AsVal_int(obj1, &val2);
49073 if (!SWIG_IsOK(ecode2)) {
49074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49075 }
49076 arg2 = static_cast< int >(val2);
49077 {
49078 PyThreadState* __tstate = wxPyBeginAllowThreads();
49079 (arg1)->SetCol(arg2);
49080 wxPyEndAllowThreads(__tstate);
49081 if (PyErr_Occurred()) SWIG_fail;
49082 }
49083 resultobj = SWIG_Py_Void();
49084 return resultobj;
49085 fail:
49086 return NULL;
49087 }
49088
49089
49090 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49091 PyObject *resultobj = 0;
49092 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49093 PyObject *arg2 = (PyObject *) 0 ;
49094 bool result;
49095 void *argp1 = 0 ;
49096 int res1 = 0 ;
49097 PyObject * obj0 = 0 ;
49098 PyObject * obj1 = 0 ;
49099 char * kwnames[] = {
49100 (char *) "self",(char *) "other", NULL
49101 };
49102
49103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49105 if (!SWIG_IsOK(res1)) {
49106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49107 }
49108 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49109 arg2 = obj1;
49110 {
49111 result = (bool)wxGBPosition___eq__(arg1,arg2);
49112 if (PyErr_Occurred()) SWIG_fail;
49113 }
49114 {
49115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49116 }
49117 return resultobj;
49118 fail:
49119 return NULL;
49120 }
49121
49122
49123 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49124 PyObject *resultobj = 0;
49125 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49126 PyObject *arg2 = (PyObject *) 0 ;
49127 bool result;
49128 void *argp1 = 0 ;
49129 int res1 = 0 ;
49130 PyObject * obj0 = 0 ;
49131 PyObject * obj1 = 0 ;
49132 char * kwnames[] = {
49133 (char *) "self",(char *) "other", NULL
49134 };
49135
49136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49138 if (!SWIG_IsOK(res1)) {
49139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49140 }
49141 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49142 arg2 = obj1;
49143 {
49144 result = (bool)wxGBPosition___ne__(arg1,arg2);
49145 if (PyErr_Occurred()) SWIG_fail;
49146 }
49147 {
49148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49149 }
49150 return resultobj;
49151 fail:
49152 return NULL;
49153 }
49154
49155
49156 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49157 PyObject *resultobj = 0;
49158 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49159 int arg2 = (int) 0 ;
49160 int arg3 = (int) 0 ;
49161 void *argp1 = 0 ;
49162 int res1 = 0 ;
49163 int val2 ;
49164 int ecode2 = 0 ;
49165 int val3 ;
49166 int ecode3 = 0 ;
49167 PyObject * obj0 = 0 ;
49168 PyObject * obj1 = 0 ;
49169 PyObject * obj2 = 0 ;
49170 char * kwnames[] = {
49171 (char *) "self",(char *) "row",(char *) "col", NULL
49172 };
49173
49174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49176 if (!SWIG_IsOK(res1)) {
49177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49178 }
49179 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49180 if (obj1) {
49181 ecode2 = SWIG_AsVal_int(obj1, &val2);
49182 if (!SWIG_IsOK(ecode2)) {
49183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49184 }
49185 arg2 = static_cast< int >(val2);
49186 }
49187 if (obj2) {
49188 ecode3 = SWIG_AsVal_int(obj2, &val3);
49189 if (!SWIG_IsOK(ecode3)) {
49190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49191 }
49192 arg3 = static_cast< int >(val3);
49193 }
49194 {
49195 PyThreadState* __tstate = wxPyBeginAllowThreads();
49196 wxGBPosition_Set(arg1,arg2,arg3);
49197 wxPyEndAllowThreads(__tstate);
49198 if (PyErr_Occurred()) SWIG_fail;
49199 }
49200 resultobj = SWIG_Py_Void();
49201 return resultobj;
49202 fail:
49203 return NULL;
49204 }
49205
49206
49207 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49208 PyObject *resultobj = 0;
49209 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49210 PyObject *result = 0 ;
49211 void *argp1 = 0 ;
49212 int res1 = 0 ;
49213 PyObject *swig_obj[1] ;
49214
49215 if (!args) SWIG_fail;
49216 swig_obj[0] = args;
49217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49218 if (!SWIG_IsOK(res1)) {
49219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49220 }
49221 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49222 {
49223 PyThreadState* __tstate = wxPyBeginAllowThreads();
49224 result = (PyObject *)wxGBPosition_Get(arg1);
49225 wxPyEndAllowThreads(__tstate);
49226 if (PyErr_Occurred()) SWIG_fail;
49227 }
49228 resultobj = result;
49229 return resultobj;
49230 fail:
49231 return NULL;
49232 }
49233
49234
49235 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49236 PyObject *obj;
49237 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49238 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49239 return SWIG_Py_Void();
49240 }
49241
49242 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49243 return SWIG_Python_InitShadowInstance(args);
49244 }
49245
49246 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49247 PyObject *resultobj = 0;
49248 int arg1 = (int) 1 ;
49249 int arg2 = (int) 1 ;
49250 wxGBSpan *result = 0 ;
49251 int val1 ;
49252 int ecode1 = 0 ;
49253 int val2 ;
49254 int ecode2 = 0 ;
49255 PyObject * obj0 = 0 ;
49256 PyObject * obj1 = 0 ;
49257 char * kwnames[] = {
49258 (char *) "rowspan",(char *) "colspan", NULL
49259 };
49260
49261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49262 if (obj0) {
49263 ecode1 = SWIG_AsVal_int(obj0, &val1);
49264 if (!SWIG_IsOK(ecode1)) {
49265 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49266 }
49267 arg1 = static_cast< int >(val1);
49268 }
49269 if (obj1) {
49270 ecode2 = SWIG_AsVal_int(obj1, &val2);
49271 if (!SWIG_IsOK(ecode2)) {
49272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49273 }
49274 arg2 = static_cast< int >(val2);
49275 }
49276 {
49277 PyThreadState* __tstate = wxPyBeginAllowThreads();
49278 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49279 wxPyEndAllowThreads(__tstate);
49280 if (PyErr_Occurred()) SWIG_fail;
49281 }
49282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49283 return resultobj;
49284 fail:
49285 return NULL;
49286 }
49287
49288
49289 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49290 PyObject *resultobj = 0;
49291 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49292 void *argp1 = 0 ;
49293 int res1 = 0 ;
49294 PyObject *swig_obj[1] ;
49295
49296 if (!args) SWIG_fail;
49297 swig_obj[0] = args;
49298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49299 if (!SWIG_IsOK(res1)) {
49300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49301 }
49302 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49303 {
49304 PyThreadState* __tstate = wxPyBeginAllowThreads();
49305 delete arg1;
49306
49307 wxPyEndAllowThreads(__tstate);
49308 if (PyErr_Occurred()) SWIG_fail;
49309 }
49310 resultobj = SWIG_Py_Void();
49311 return resultobj;
49312 fail:
49313 return NULL;
49314 }
49315
49316
49317 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49318 PyObject *resultobj = 0;
49319 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49320 int result;
49321 void *argp1 = 0 ;
49322 int res1 = 0 ;
49323 PyObject *swig_obj[1] ;
49324
49325 if (!args) SWIG_fail;
49326 swig_obj[0] = args;
49327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49328 if (!SWIG_IsOK(res1)) {
49329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49330 }
49331 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49332 {
49333 PyThreadState* __tstate = wxPyBeginAllowThreads();
49334 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49335 wxPyEndAllowThreads(__tstate);
49336 if (PyErr_Occurred()) SWIG_fail;
49337 }
49338 resultobj = SWIG_From_int(static_cast< int >(result));
49339 return resultobj;
49340 fail:
49341 return NULL;
49342 }
49343
49344
49345 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49346 PyObject *resultobj = 0;
49347 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49348 int result;
49349 void *argp1 = 0 ;
49350 int res1 = 0 ;
49351 PyObject *swig_obj[1] ;
49352
49353 if (!args) SWIG_fail;
49354 swig_obj[0] = args;
49355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49356 if (!SWIG_IsOK(res1)) {
49357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49358 }
49359 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49360 {
49361 PyThreadState* __tstate = wxPyBeginAllowThreads();
49362 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49363 wxPyEndAllowThreads(__tstate);
49364 if (PyErr_Occurred()) SWIG_fail;
49365 }
49366 resultobj = SWIG_From_int(static_cast< int >(result));
49367 return resultobj;
49368 fail:
49369 return NULL;
49370 }
49371
49372
49373 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49374 PyObject *resultobj = 0;
49375 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49376 int arg2 ;
49377 void *argp1 = 0 ;
49378 int res1 = 0 ;
49379 int val2 ;
49380 int ecode2 = 0 ;
49381 PyObject * obj0 = 0 ;
49382 PyObject * obj1 = 0 ;
49383 char * kwnames[] = {
49384 (char *) "self",(char *) "rowspan", NULL
49385 };
49386
49387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49389 if (!SWIG_IsOK(res1)) {
49390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49391 }
49392 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49393 ecode2 = SWIG_AsVal_int(obj1, &val2);
49394 if (!SWIG_IsOK(ecode2)) {
49395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49396 }
49397 arg2 = static_cast< int >(val2);
49398 {
49399 PyThreadState* __tstate = wxPyBeginAllowThreads();
49400 (arg1)->SetRowspan(arg2);
49401 wxPyEndAllowThreads(__tstate);
49402 if (PyErr_Occurred()) SWIG_fail;
49403 }
49404 resultobj = SWIG_Py_Void();
49405 return resultobj;
49406 fail:
49407 return NULL;
49408 }
49409
49410
49411 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49412 PyObject *resultobj = 0;
49413 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49414 int arg2 ;
49415 void *argp1 = 0 ;
49416 int res1 = 0 ;
49417 int val2 ;
49418 int ecode2 = 0 ;
49419 PyObject * obj0 = 0 ;
49420 PyObject * obj1 = 0 ;
49421 char * kwnames[] = {
49422 (char *) "self",(char *) "colspan", NULL
49423 };
49424
49425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49427 if (!SWIG_IsOK(res1)) {
49428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49429 }
49430 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49431 ecode2 = SWIG_AsVal_int(obj1, &val2);
49432 if (!SWIG_IsOK(ecode2)) {
49433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49434 }
49435 arg2 = static_cast< int >(val2);
49436 {
49437 PyThreadState* __tstate = wxPyBeginAllowThreads();
49438 (arg1)->SetColspan(arg2);
49439 wxPyEndAllowThreads(__tstate);
49440 if (PyErr_Occurred()) SWIG_fail;
49441 }
49442 resultobj = SWIG_Py_Void();
49443 return resultobj;
49444 fail:
49445 return NULL;
49446 }
49447
49448
49449 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49450 PyObject *resultobj = 0;
49451 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49452 PyObject *arg2 = (PyObject *) 0 ;
49453 bool result;
49454 void *argp1 = 0 ;
49455 int res1 = 0 ;
49456 PyObject * obj0 = 0 ;
49457 PyObject * obj1 = 0 ;
49458 char * kwnames[] = {
49459 (char *) "self",(char *) "other", NULL
49460 };
49461
49462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49464 if (!SWIG_IsOK(res1)) {
49465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49466 }
49467 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49468 arg2 = obj1;
49469 {
49470 result = (bool)wxGBSpan___eq__(arg1,arg2);
49471 if (PyErr_Occurred()) SWIG_fail;
49472 }
49473 {
49474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49475 }
49476 return resultobj;
49477 fail:
49478 return NULL;
49479 }
49480
49481
49482 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49483 PyObject *resultobj = 0;
49484 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49485 PyObject *arg2 = (PyObject *) 0 ;
49486 bool result;
49487 void *argp1 = 0 ;
49488 int res1 = 0 ;
49489 PyObject * obj0 = 0 ;
49490 PyObject * obj1 = 0 ;
49491 char * kwnames[] = {
49492 (char *) "self",(char *) "other", NULL
49493 };
49494
49495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49497 if (!SWIG_IsOK(res1)) {
49498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49499 }
49500 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49501 arg2 = obj1;
49502 {
49503 result = (bool)wxGBSpan___ne__(arg1,arg2);
49504 if (PyErr_Occurred()) SWIG_fail;
49505 }
49506 {
49507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49508 }
49509 return resultobj;
49510 fail:
49511 return NULL;
49512 }
49513
49514
49515 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49516 PyObject *resultobj = 0;
49517 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49518 int arg2 = (int) 1 ;
49519 int arg3 = (int) 1 ;
49520 void *argp1 = 0 ;
49521 int res1 = 0 ;
49522 int val2 ;
49523 int ecode2 = 0 ;
49524 int val3 ;
49525 int ecode3 = 0 ;
49526 PyObject * obj0 = 0 ;
49527 PyObject * obj1 = 0 ;
49528 PyObject * obj2 = 0 ;
49529 char * kwnames[] = {
49530 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49531 };
49532
49533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49535 if (!SWIG_IsOK(res1)) {
49536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49537 }
49538 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49539 if (obj1) {
49540 ecode2 = SWIG_AsVal_int(obj1, &val2);
49541 if (!SWIG_IsOK(ecode2)) {
49542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49543 }
49544 arg2 = static_cast< int >(val2);
49545 }
49546 if (obj2) {
49547 ecode3 = SWIG_AsVal_int(obj2, &val3);
49548 if (!SWIG_IsOK(ecode3)) {
49549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49550 }
49551 arg3 = static_cast< int >(val3);
49552 }
49553 {
49554 PyThreadState* __tstate = wxPyBeginAllowThreads();
49555 wxGBSpan_Set(arg1,arg2,arg3);
49556 wxPyEndAllowThreads(__tstate);
49557 if (PyErr_Occurred()) SWIG_fail;
49558 }
49559 resultobj = SWIG_Py_Void();
49560 return resultobj;
49561 fail:
49562 return NULL;
49563 }
49564
49565
49566 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49567 PyObject *resultobj = 0;
49568 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49569 PyObject *result = 0 ;
49570 void *argp1 = 0 ;
49571 int res1 = 0 ;
49572 PyObject *swig_obj[1] ;
49573
49574 if (!args) SWIG_fail;
49575 swig_obj[0] = args;
49576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49577 if (!SWIG_IsOK(res1)) {
49578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49579 }
49580 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49581 {
49582 PyThreadState* __tstate = wxPyBeginAllowThreads();
49583 result = (PyObject *)wxGBSpan_Get(arg1);
49584 wxPyEndAllowThreads(__tstate);
49585 if (PyErr_Occurred()) SWIG_fail;
49586 }
49587 resultobj = result;
49588 return resultobj;
49589 fail:
49590 return NULL;
49591 }
49592
49593
49594 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49595 PyObject *obj;
49596 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49597 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49598 return SWIG_Py_Void();
49599 }
49600
49601 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49602 return SWIG_Python_InitShadowInstance(args);
49603 }
49604
49605 SWIGINTERN int DefaultSpan_set(PyObject *) {
49606 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49607 return 1;
49608 }
49609
49610
49611 SWIGINTERN PyObject *DefaultSpan_get(void) {
49612 PyObject *pyobj = 0;
49613
49614 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49615 return pyobj;
49616 }
49617
49618
49619 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49620 PyObject *resultobj = 0;
49621 wxGBSizerItem *result = 0 ;
49622
49623 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49624 {
49625 PyThreadState* __tstate = wxPyBeginAllowThreads();
49626 result = (wxGBSizerItem *)new wxGBSizerItem();
49627 wxPyEndAllowThreads(__tstate);
49628 if (PyErr_Occurred()) SWIG_fail;
49629 }
49630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49631 return resultobj;
49632 fail:
49633 return NULL;
49634 }
49635
49636
49637 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49638 PyObject *resultobj = 0;
49639 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49640 void *argp1 = 0 ;
49641 int res1 = 0 ;
49642 PyObject *swig_obj[1] ;
49643
49644 if (!args) SWIG_fail;
49645 swig_obj[0] = args;
49646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49647 if (!SWIG_IsOK(res1)) {
49648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49649 }
49650 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49651 {
49652 PyThreadState* __tstate = wxPyBeginAllowThreads();
49653 delete arg1;
49654
49655 wxPyEndAllowThreads(__tstate);
49656 if (PyErr_Occurred()) SWIG_fail;
49657 }
49658 resultobj = SWIG_Py_Void();
49659 return resultobj;
49660 fail:
49661 return NULL;
49662 }
49663
49664
49665 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49666 PyObject *resultobj = 0;
49667 wxWindow *arg1 = (wxWindow *) 0 ;
49668 wxGBPosition *arg2 = 0 ;
49669 wxGBSpan *arg3 = 0 ;
49670 int arg4 ;
49671 int arg5 ;
49672 PyObject *arg6 = (PyObject *) NULL ;
49673 wxGBSizerItem *result = 0 ;
49674 void *argp1 = 0 ;
49675 int res1 = 0 ;
49676 wxGBPosition temp2 ;
49677 wxGBSpan temp3 ;
49678 int val4 ;
49679 int ecode4 = 0 ;
49680 int val5 ;
49681 int ecode5 = 0 ;
49682 PyObject * obj0 = 0 ;
49683 PyObject * obj1 = 0 ;
49684 PyObject * obj2 = 0 ;
49685 PyObject * obj3 = 0 ;
49686 PyObject * obj4 = 0 ;
49687 PyObject * obj5 = 0 ;
49688 char * kwnames[] = {
49689 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49690 };
49691
49692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49694 if (!SWIG_IsOK(res1)) {
49695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49696 }
49697 arg1 = reinterpret_cast< wxWindow * >(argp1);
49698 {
49699 arg2 = &temp2;
49700 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49701 }
49702 {
49703 arg3 = &temp3;
49704 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49705 }
49706 ecode4 = SWIG_AsVal_int(obj3, &val4);
49707 if (!SWIG_IsOK(ecode4)) {
49708 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49709 }
49710 arg4 = static_cast< int >(val4);
49711 ecode5 = SWIG_AsVal_int(obj4, &val5);
49712 if (!SWIG_IsOK(ecode5)) {
49713 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49714 }
49715 arg5 = static_cast< int >(val5);
49716 if (obj5) {
49717 arg6 = obj5;
49718 }
49719 {
49720 PyThreadState* __tstate = wxPyBeginAllowThreads();
49721 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49722 wxPyEndAllowThreads(__tstate);
49723 if (PyErr_Occurred()) SWIG_fail;
49724 }
49725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49726 return resultobj;
49727 fail:
49728 return NULL;
49729 }
49730
49731
49732 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49733 PyObject *resultobj = 0;
49734 wxSizer *arg1 = (wxSizer *) 0 ;
49735 wxGBPosition *arg2 = 0 ;
49736 wxGBSpan *arg3 = 0 ;
49737 int arg4 ;
49738 int arg5 ;
49739 PyObject *arg6 = (PyObject *) NULL ;
49740 wxGBSizerItem *result = 0 ;
49741 int res1 = 0 ;
49742 wxGBPosition temp2 ;
49743 wxGBSpan temp3 ;
49744 int val4 ;
49745 int ecode4 = 0 ;
49746 int val5 ;
49747 int ecode5 = 0 ;
49748 PyObject * obj0 = 0 ;
49749 PyObject * obj1 = 0 ;
49750 PyObject * obj2 = 0 ;
49751 PyObject * obj3 = 0 ;
49752 PyObject * obj4 = 0 ;
49753 PyObject * obj5 = 0 ;
49754 char * kwnames[] = {
49755 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49756 };
49757
49758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49759 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49760 if (!SWIG_IsOK(res1)) {
49761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49762 }
49763 {
49764 arg2 = &temp2;
49765 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49766 }
49767 {
49768 arg3 = &temp3;
49769 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49770 }
49771 ecode4 = SWIG_AsVal_int(obj3, &val4);
49772 if (!SWIG_IsOK(ecode4)) {
49773 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49774 }
49775 arg4 = static_cast< int >(val4);
49776 ecode5 = SWIG_AsVal_int(obj4, &val5);
49777 if (!SWIG_IsOK(ecode5)) {
49778 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49779 }
49780 arg5 = static_cast< int >(val5);
49781 if (obj5) {
49782 arg6 = obj5;
49783 }
49784 {
49785 PyThreadState* __tstate = wxPyBeginAllowThreads();
49786 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49787 wxPyEndAllowThreads(__tstate);
49788 if (PyErr_Occurred()) SWIG_fail;
49789 }
49790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49791 return resultobj;
49792 fail:
49793 return NULL;
49794 }
49795
49796
49797 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49798 PyObject *resultobj = 0;
49799 int arg1 ;
49800 int arg2 ;
49801 wxGBPosition *arg3 = 0 ;
49802 wxGBSpan *arg4 = 0 ;
49803 int arg5 ;
49804 int arg6 ;
49805 PyObject *arg7 = (PyObject *) NULL ;
49806 wxGBSizerItem *result = 0 ;
49807 int val1 ;
49808 int ecode1 = 0 ;
49809 int val2 ;
49810 int ecode2 = 0 ;
49811 wxGBPosition temp3 ;
49812 wxGBSpan temp4 ;
49813 int val5 ;
49814 int ecode5 = 0 ;
49815 int val6 ;
49816 int ecode6 = 0 ;
49817 PyObject * obj0 = 0 ;
49818 PyObject * obj1 = 0 ;
49819 PyObject * obj2 = 0 ;
49820 PyObject * obj3 = 0 ;
49821 PyObject * obj4 = 0 ;
49822 PyObject * obj5 = 0 ;
49823 PyObject * obj6 = 0 ;
49824 char * kwnames[] = {
49825 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49826 };
49827
49828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49829 ecode1 = SWIG_AsVal_int(obj0, &val1);
49830 if (!SWIG_IsOK(ecode1)) {
49831 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49832 }
49833 arg1 = static_cast< int >(val1);
49834 ecode2 = SWIG_AsVal_int(obj1, &val2);
49835 if (!SWIG_IsOK(ecode2)) {
49836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49837 }
49838 arg2 = static_cast< int >(val2);
49839 {
49840 arg3 = &temp3;
49841 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49842 }
49843 {
49844 arg4 = &temp4;
49845 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49846 }
49847 ecode5 = SWIG_AsVal_int(obj4, &val5);
49848 if (!SWIG_IsOK(ecode5)) {
49849 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49850 }
49851 arg5 = static_cast< int >(val5);
49852 ecode6 = SWIG_AsVal_int(obj5, &val6);
49853 if (!SWIG_IsOK(ecode6)) {
49854 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49855 }
49856 arg6 = static_cast< int >(val6);
49857 if (obj6) {
49858 arg7 = obj6;
49859 }
49860 {
49861 PyThreadState* __tstate = wxPyBeginAllowThreads();
49862 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49863 wxPyEndAllowThreads(__tstate);
49864 if (PyErr_Occurred()) SWIG_fail;
49865 }
49866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49867 return resultobj;
49868 fail:
49869 return NULL;
49870 }
49871
49872
49873 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49874 PyObject *resultobj = 0;
49875 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49876 wxGBPosition result;
49877 void *argp1 = 0 ;
49878 int res1 = 0 ;
49879 PyObject *swig_obj[1] ;
49880
49881 if (!args) SWIG_fail;
49882 swig_obj[0] = args;
49883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49884 if (!SWIG_IsOK(res1)) {
49885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49886 }
49887 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49888 {
49889 PyThreadState* __tstate = wxPyBeginAllowThreads();
49890 result = ((wxGBSizerItem const *)arg1)->GetPos();
49891 wxPyEndAllowThreads(__tstate);
49892 if (PyErr_Occurred()) SWIG_fail;
49893 }
49894 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49895 return resultobj;
49896 fail:
49897 return NULL;
49898 }
49899
49900
49901 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49902 PyObject *resultobj = 0;
49903 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49904 wxGBSpan result;
49905 void *argp1 = 0 ;
49906 int res1 = 0 ;
49907 PyObject *swig_obj[1] ;
49908
49909 if (!args) SWIG_fail;
49910 swig_obj[0] = args;
49911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49912 if (!SWIG_IsOK(res1)) {
49913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49914 }
49915 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49916 {
49917 PyThreadState* __tstate = wxPyBeginAllowThreads();
49918 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49919 wxPyEndAllowThreads(__tstate);
49920 if (PyErr_Occurred()) SWIG_fail;
49921 }
49922 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49923 return resultobj;
49924 fail:
49925 return NULL;
49926 }
49927
49928
49929 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49930 PyObject *resultobj = 0;
49931 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49932 wxGBPosition *arg2 = 0 ;
49933 bool result;
49934 void *argp1 = 0 ;
49935 int res1 = 0 ;
49936 wxGBPosition temp2 ;
49937 PyObject * obj0 = 0 ;
49938 PyObject * obj1 = 0 ;
49939 char * kwnames[] = {
49940 (char *) "self",(char *) "pos", NULL
49941 };
49942
49943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49945 if (!SWIG_IsOK(res1)) {
49946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49947 }
49948 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49949 {
49950 arg2 = &temp2;
49951 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49952 }
49953 {
49954 PyThreadState* __tstate = wxPyBeginAllowThreads();
49955 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49956 wxPyEndAllowThreads(__tstate);
49957 if (PyErr_Occurred()) SWIG_fail;
49958 }
49959 {
49960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49961 }
49962 return resultobj;
49963 fail:
49964 return NULL;
49965 }
49966
49967
49968 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49969 PyObject *resultobj = 0;
49970 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49971 wxGBSpan *arg2 = 0 ;
49972 bool result;
49973 void *argp1 = 0 ;
49974 int res1 = 0 ;
49975 wxGBSpan temp2 ;
49976 PyObject * obj0 = 0 ;
49977 PyObject * obj1 = 0 ;
49978 char * kwnames[] = {
49979 (char *) "self",(char *) "span", NULL
49980 };
49981
49982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49984 if (!SWIG_IsOK(res1)) {
49985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49986 }
49987 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49988 {
49989 arg2 = &temp2;
49990 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49991 }
49992 {
49993 PyThreadState* __tstate = wxPyBeginAllowThreads();
49994 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49995 wxPyEndAllowThreads(__tstate);
49996 if (PyErr_Occurred()) SWIG_fail;
49997 }
49998 {
49999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50000 }
50001 return resultobj;
50002 fail:
50003 return NULL;
50004 }
50005
50006
50007 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50008 PyObject *resultobj = 0;
50009 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50010 wxGBSizerItem *arg2 = 0 ;
50011 bool result;
50012 void *argp1 = 0 ;
50013 int res1 = 0 ;
50014 void *argp2 = 0 ;
50015 int res2 = 0 ;
50016 PyObject * obj0 = 0 ;
50017 PyObject * obj1 = 0 ;
50018 char * kwnames[] = {
50019 (char *) "self",(char *) "other", NULL
50020 };
50021
50022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50024 if (!SWIG_IsOK(res1)) {
50025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50026 }
50027 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50028 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50029 if (!SWIG_IsOK(res2)) {
50030 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50031 }
50032 if (!argp2) {
50033 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50034 }
50035 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50036 {
50037 PyThreadState* __tstate = wxPyBeginAllowThreads();
50038 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50039 wxPyEndAllowThreads(__tstate);
50040 if (PyErr_Occurred()) SWIG_fail;
50041 }
50042 {
50043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50044 }
50045 return resultobj;
50046 fail:
50047 return NULL;
50048 }
50049
50050
50051 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50052 PyObject *resultobj = 0;
50053 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50054 wxGBPosition *arg2 = 0 ;
50055 wxGBSpan *arg3 = 0 ;
50056 bool result;
50057 void *argp1 = 0 ;
50058 int res1 = 0 ;
50059 wxGBPosition temp2 ;
50060 wxGBSpan temp3 ;
50061 PyObject * obj0 = 0 ;
50062 PyObject * obj1 = 0 ;
50063 PyObject * obj2 = 0 ;
50064 char * kwnames[] = {
50065 (char *) "self",(char *) "pos",(char *) "span", NULL
50066 };
50067
50068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50070 if (!SWIG_IsOK(res1)) {
50071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50072 }
50073 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50074 {
50075 arg2 = &temp2;
50076 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50077 }
50078 {
50079 arg3 = &temp3;
50080 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50081 }
50082 {
50083 PyThreadState* __tstate = wxPyBeginAllowThreads();
50084 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50085 wxPyEndAllowThreads(__tstate);
50086 if (PyErr_Occurred()) SWIG_fail;
50087 }
50088 {
50089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50090 }
50091 return resultobj;
50092 fail:
50093 return NULL;
50094 }
50095
50096
50097 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50098 PyObject *resultobj = 0;
50099 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50100 wxGBPosition result;
50101 void *argp1 = 0 ;
50102 int res1 = 0 ;
50103 PyObject *swig_obj[1] ;
50104
50105 if (!args) SWIG_fail;
50106 swig_obj[0] = args;
50107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50108 if (!SWIG_IsOK(res1)) {
50109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50110 }
50111 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50112 {
50113 PyThreadState* __tstate = wxPyBeginAllowThreads();
50114 result = wxGBSizerItem_GetEndPos(arg1);
50115 wxPyEndAllowThreads(__tstate);
50116 if (PyErr_Occurred()) SWIG_fail;
50117 }
50118 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50119 return resultobj;
50120 fail:
50121 return NULL;
50122 }
50123
50124
50125 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50126 PyObject *resultobj = 0;
50127 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50128 wxGridBagSizer *result = 0 ;
50129 void *argp1 = 0 ;
50130 int res1 = 0 ;
50131 PyObject *swig_obj[1] ;
50132
50133 if (!args) SWIG_fail;
50134 swig_obj[0] = args;
50135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50136 if (!SWIG_IsOK(res1)) {
50137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50138 }
50139 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50140 {
50141 PyThreadState* __tstate = wxPyBeginAllowThreads();
50142 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50143 wxPyEndAllowThreads(__tstate);
50144 if (PyErr_Occurred()) SWIG_fail;
50145 }
50146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50147 return resultobj;
50148 fail:
50149 return NULL;
50150 }
50151
50152
50153 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50154 PyObject *resultobj = 0;
50155 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50156 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50157 void *argp1 = 0 ;
50158 int res1 = 0 ;
50159 void *argp2 = 0 ;
50160 int res2 = 0 ;
50161 PyObject * obj0 = 0 ;
50162 PyObject * obj1 = 0 ;
50163 char * kwnames[] = {
50164 (char *) "self",(char *) "sizer", NULL
50165 };
50166
50167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50169 if (!SWIG_IsOK(res1)) {
50170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50171 }
50172 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50173 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50174 if (!SWIG_IsOK(res2)) {
50175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50176 }
50177 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50178 {
50179 PyThreadState* __tstate = wxPyBeginAllowThreads();
50180 (arg1)->SetGBSizer(arg2);
50181 wxPyEndAllowThreads(__tstate);
50182 if (PyErr_Occurred()) SWIG_fail;
50183 }
50184 resultobj = SWIG_Py_Void();
50185 return resultobj;
50186 fail:
50187 return NULL;
50188 }
50189
50190
50191 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50192 PyObject *obj;
50193 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50194 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50195 return SWIG_Py_Void();
50196 }
50197
50198 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50199 return SWIG_Python_InitShadowInstance(args);
50200 }
50201
50202 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50203 PyObject *resultobj = 0;
50204 int arg1 = (int) 0 ;
50205 int arg2 = (int) 0 ;
50206 wxGridBagSizer *result = 0 ;
50207 int val1 ;
50208 int ecode1 = 0 ;
50209 int val2 ;
50210 int ecode2 = 0 ;
50211 PyObject * obj0 = 0 ;
50212 PyObject * obj1 = 0 ;
50213 char * kwnames[] = {
50214 (char *) "vgap",(char *) "hgap", NULL
50215 };
50216
50217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50218 if (obj0) {
50219 ecode1 = SWIG_AsVal_int(obj0, &val1);
50220 if (!SWIG_IsOK(ecode1)) {
50221 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50222 }
50223 arg1 = static_cast< int >(val1);
50224 }
50225 if (obj1) {
50226 ecode2 = SWIG_AsVal_int(obj1, &val2);
50227 if (!SWIG_IsOK(ecode2)) {
50228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50229 }
50230 arg2 = static_cast< int >(val2);
50231 }
50232 {
50233 PyThreadState* __tstate = wxPyBeginAllowThreads();
50234 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50235 wxPyEndAllowThreads(__tstate);
50236 if (PyErr_Occurred()) SWIG_fail;
50237 }
50238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50239 return resultobj;
50240 fail:
50241 return NULL;
50242 }
50243
50244
50245 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50246 PyObject *resultobj = 0;
50247 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50248 PyObject *arg2 = (PyObject *) 0 ;
50249 wxGBPosition *arg3 = 0 ;
50250 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50251 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50252 int arg5 = (int) 0 ;
50253 int arg6 = (int) 0 ;
50254 PyObject *arg7 = (PyObject *) NULL ;
50255 wxGBSizerItem *result = 0 ;
50256 void *argp1 = 0 ;
50257 int res1 = 0 ;
50258 wxGBPosition temp3 ;
50259 wxGBSpan temp4 ;
50260 int val5 ;
50261 int ecode5 = 0 ;
50262 int val6 ;
50263 int ecode6 = 0 ;
50264 PyObject * obj0 = 0 ;
50265 PyObject * obj1 = 0 ;
50266 PyObject * obj2 = 0 ;
50267 PyObject * obj3 = 0 ;
50268 PyObject * obj4 = 0 ;
50269 PyObject * obj5 = 0 ;
50270 PyObject * obj6 = 0 ;
50271 char * kwnames[] = {
50272 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50273 };
50274
50275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50277 if (!SWIG_IsOK(res1)) {
50278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50279 }
50280 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50281 arg2 = obj1;
50282 {
50283 arg3 = &temp3;
50284 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50285 }
50286 if (obj3) {
50287 {
50288 arg4 = &temp4;
50289 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50290 }
50291 }
50292 if (obj4) {
50293 ecode5 = SWIG_AsVal_int(obj4, &val5);
50294 if (!SWIG_IsOK(ecode5)) {
50295 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50296 }
50297 arg5 = static_cast< int >(val5);
50298 }
50299 if (obj5) {
50300 ecode6 = SWIG_AsVal_int(obj5, &val6);
50301 if (!SWIG_IsOK(ecode6)) {
50302 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50303 }
50304 arg6 = static_cast< int >(val6);
50305 }
50306 if (obj6) {
50307 arg7 = obj6;
50308 }
50309 {
50310 PyThreadState* __tstate = wxPyBeginAllowThreads();
50311 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50312 wxPyEndAllowThreads(__tstate);
50313 if (PyErr_Occurred()) SWIG_fail;
50314 }
50315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50316 return resultobj;
50317 fail:
50318 return NULL;
50319 }
50320
50321
50322 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50323 PyObject *resultobj = 0;
50324 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50325 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50326 wxGBSizerItem *result = 0 ;
50327 void *argp1 = 0 ;
50328 int res1 = 0 ;
50329 int res2 = 0 ;
50330 PyObject * obj0 = 0 ;
50331 PyObject * obj1 = 0 ;
50332 char * kwnames[] = {
50333 (char *) "self",(char *) "item", NULL
50334 };
50335
50336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50338 if (!SWIG_IsOK(res1)) {
50339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50340 }
50341 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50342 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50343 if (!SWIG_IsOK(res2)) {
50344 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50345 }
50346 {
50347 PyThreadState* __tstate = wxPyBeginAllowThreads();
50348 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50349 wxPyEndAllowThreads(__tstate);
50350 if (PyErr_Occurred()) SWIG_fail;
50351 }
50352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50353 return resultobj;
50354 fail:
50355 return NULL;
50356 }
50357
50358
50359 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50360 PyObject *resultobj = 0;
50361 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50362 int arg2 ;
50363 int arg3 ;
50364 wxSize result;
50365 void *argp1 = 0 ;
50366 int res1 = 0 ;
50367 int val2 ;
50368 int ecode2 = 0 ;
50369 int val3 ;
50370 int ecode3 = 0 ;
50371 PyObject * obj0 = 0 ;
50372 PyObject * obj1 = 0 ;
50373 PyObject * obj2 = 0 ;
50374 char * kwnames[] = {
50375 (char *) "self",(char *) "row",(char *) "col", NULL
50376 };
50377
50378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50380 if (!SWIG_IsOK(res1)) {
50381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50382 }
50383 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50384 ecode2 = SWIG_AsVal_int(obj1, &val2);
50385 if (!SWIG_IsOK(ecode2)) {
50386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50387 }
50388 arg2 = static_cast< int >(val2);
50389 ecode3 = SWIG_AsVal_int(obj2, &val3);
50390 if (!SWIG_IsOK(ecode3)) {
50391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50392 }
50393 arg3 = static_cast< int >(val3);
50394 {
50395 PyThreadState* __tstate = wxPyBeginAllowThreads();
50396 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50397 wxPyEndAllowThreads(__tstate);
50398 if (PyErr_Occurred()) SWIG_fail;
50399 }
50400 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50401 return resultobj;
50402 fail:
50403 return NULL;
50404 }
50405
50406
50407 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50408 PyObject *resultobj = 0;
50409 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50410 wxSize result;
50411 void *argp1 = 0 ;
50412 int res1 = 0 ;
50413 PyObject *swig_obj[1] ;
50414
50415 if (!args) SWIG_fail;
50416 swig_obj[0] = args;
50417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50418 if (!SWIG_IsOK(res1)) {
50419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50420 }
50421 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50422 {
50423 PyThreadState* __tstate = wxPyBeginAllowThreads();
50424 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50425 wxPyEndAllowThreads(__tstate);
50426 if (PyErr_Occurred()) SWIG_fail;
50427 }
50428 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50429 return resultobj;
50430 fail:
50431 return NULL;
50432 }
50433
50434
50435 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50436 PyObject *resultobj = 0;
50437 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50438 wxSize *arg2 = 0 ;
50439 void *argp1 = 0 ;
50440 int res1 = 0 ;
50441 wxSize temp2 ;
50442 PyObject * obj0 = 0 ;
50443 PyObject * obj1 = 0 ;
50444 char * kwnames[] = {
50445 (char *) "self",(char *) "sz", NULL
50446 };
50447
50448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50450 if (!SWIG_IsOK(res1)) {
50451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50452 }
50453 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50454 {
50455 arg2 = &temp2;
50456 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50457 }
50458 {
50459 PyThreadState* __tstate = wxPyBeginAllowThreads();
50460 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50461 wxPyEndAllowThreads(__tstate);
50462 if (PyErr_Occurred()) SWIG_fail;
50463 }
50464 resultobj = SWIG_Py_Void();
50465 return resultobj;
50466 fail:
50467 return NULL;
50468 }
50469
50470
50471 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50472 PyObject *resultobj = 0;
50473 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50474 wxWindow *arg2 = (wxWindow *) 0 ;
50475 wxGBPosition result;
50476 void *argp1 = 0 ;
50477 int res1 = 0 ;
50478 void *argp2 = 0 ;
50479 int res2 = 0 ;
50480
50481 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50483 if (!SWIG_IsOK(res1)) {
50484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50485 }
50486 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50487 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50488 if (!SWIG_IsOK(res2)) {
50489 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50490 }
50491 arg2 = reinterpret_cast< wxWindow * >(argp2);
50492 {
50493 PyThreadState* __tstate = wxPyBeginAllowThreads();
50494 result = (arg1)->GetItemPosition(arg2);
50495 wxPyEndAllowThreads(__tstate);
50496 if (PyErr_Occurred()) SWIG_fail;
50497 }
50498 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50499 return resultobj;
50500 fail:
50501 return NULL;
50502 }
50503
50504
50505 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50506 PyObject *resultobj = 0;
50507 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50508 wxSizer *arg2 = (wxSizer *) 0 ;
50509 wxGBPosition result;
50510 void *argp1 = 0 ;
50511 int res1 = 0 ;
50512 void *argp2 = 0 ;
50513 int res2 = 0 ;
50514
50515 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50517 if (!SWIG_IsOK(res1)) {
50518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50519 }
50520 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50521 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50522 if (!SWIG_IsOK(res2)) {
50523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50524 }
50525 arg2 = reinterpret_cast< wxSizer * >(argp2);
50526 {
50527 PyThreadState* __tstate = wxPyBeginAllowThreads();
50528 result = (arg1)->GetItemPosition(arg2);
50529 wxPyEndAllowThreads(__tstate);
50530 if (PyErr_Occurred()) SWIG_fail;
50531 }
50532 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50533 return resultobj;
50534 fail:
50535 return NULL;
50536 }
50537
50538
50539 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50540 PyObject *resultobj = 0;
50541 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50542 size_t arg2 ;
50543 wxGBPosition result;
50544 void *argp1 = 0 ;
50545 int res1 = 0 ;
50546 size_t val2 ;
50547 int ecode2 = 0 ;
50548
50549 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50551 if (!SWIG_IsOK(res1)) {
50552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50553 }
50554 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50555 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50556 if (!SWIG_IsOK(ecode2)) {
50557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50558 }
50559 arg2 = static_cast< size_t >(val2);
50560 {
50561 PyThreadState* __tstate = wxPyBeginAllowThreads();
50562 result = (arg1)->GetItemPosition(arg2);
50563 wxPyEndAllowThreads(__tstate);
50564 if (PyErr_Occurred()) SWIG_fail;
50565 }
50566 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50567 return resultobj;
50568 fail:
50569 return NULL;
50570 }
50571
50572
50573 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50574 int argc;
50575 PyObject *argv[3];
50576
50577 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50578 --argc;
50579 if (argc == 2) {
50580 int _v = 0;
50581 {
50582 void *vptr = 0;
50583 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50584 _v = SWIG_CheckState(res);
50585 }
50586 if (!_v) goto check_1;
50587 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50588 }
50589 check_1:
50590
50591 if (argc == 2) {
50592 int _v = 0;
50593 {
50594 void *vptr = 0;
50595 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50596 _v = SWIG_CheckState(res);
50597 }
50598 if (!_v) goto check_2;
50599 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50600 }
50601 check_2:
50602
50603 if (argc == 2) {
50604 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50605 }
50606
50607 fail:
50608 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50609 return NULL;
50610 }
50611
50612
50613 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50614 PyObject *resultobj = 0;
50615 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50616 wxWindow *arg2 = (wxWindow *) 0 ;
50617 wxGBPosition *arg3 = 0 ;
50618 bool result;
50619 void *argp1 = 0 ;
50620 int res1 = 0 ;
50621 void *argp2 = 0 ;
50622 int res2 = 0 ;
50623 wxGBPosition temp3 ;
50624
50625 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50627 if (!SWIG_IsOK(res1)) {
50628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50629 }
50630 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50631 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50632 if (!SWIG_IsOK(res2)) {
50633 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50634 }
50635 arg2 = reinterpret_cast< wxWindow * >(argp2);
50636 {
50637 arg3 = &temp3;
50638 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50639 }
50640 {
50641 PyThreadState* __tstate = wxPyBeginAllowThreads();
50642 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50643 wxPyEndAllowThreads(__tstate);
50644 if (PyErr_Occurred()) SWIG_fail;
50645 }
50646 {
50647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50648 }
50649 return resultobj;
50650 fail:
50651 return NULL;
50652 }
50653
50654
50655 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50656 PyObject *resultobj = 0;
50657 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50658 wxSizer *arg2 = (wxSizer *) 0 ;
50659 wxGBPosition *arg3 = 0 ;
50660 bool result;
50661 void *argp1 = 0 ;
50662 int res1 = 0 ;
50663 void *argp2 = 0 ;
50664 int res2 = 0 ;
50665 wxGBPosition temp3 ;
50666
50667 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50669 if (!SWIG_IsOK(res1)) {
50670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50671 }
50672 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50673 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50674 if (!SWIG_IsOK(res2)) {
50675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50676 }
50677 arg2 = reinterpret_cast< wxSizer * >(argp2);
50678 {
50679 arg3 = &temp3;
50680 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50681 }
50682 {
50683 PyThreadState* __tstate = wxPyBeginAllowThreads();
50684 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50685 wxPyEndAllowThreads(__tstate);
50686 if (PyErr_Occurred()) SWIG_fail;
50687 }
50688 {
50689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50690 }
50691 return resultobj;
50692 fail:
50693 return NULL;
50694 }
50695
50696
50697 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50698 PyObject *resultobj = 0;
50699 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50700 size_t arg2 ;
50701 wxGBPosition *arg3 = 0 ;
50702 bool result;
50703 void *argp1 = 0 ;
50704 int res1 = 0 ;
50705 size_t val2 ;
50706 int ecode2 = 0 ;
50707 wxGBPosition temp3 ;
50708
50709 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50711 if (!SWIG_IsOK(res1)) {
50712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50713 }
50714 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50715 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50716 if (!SWIG_IsOK(ecode2)) {
50717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50718 }
50719 arg2 = static_cast< size_t >(val2);
50720 {
50721 arg3 = &temp3;
50722 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50723 }
50724 {
50725 PyThreadState* __tstate = wxPyBeginAllowThreads();
50726 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50727 wxPyEndAllowThreads(__tstate);
50728 if (PyErr_Occurred()) SWIG_fail;
50729 }
50730 {
50731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50732 }
50733 return resultobj;
50734 fail:
50735 return NULL;
50736 }
50737
50738
50739 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50740 int argc;
50741 PyObject *argv[4];
50742
50743 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50744 --argc;
50745 if (argc == 3) {
50746 int _v = 0;
50747 {
50748 void *vptr = 0;
50749 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50750 _v = SWIG_CheckState(res);
50751 }
50752 if (!_v) goto check_1;
50753 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50754 }
50755 check_1:
50756
50757 if (argc == 3) {
50758 int _v = 0;
50759 {
50760 void *vptr = 0;
50761 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50762 _v = SWIG_CheckState(res);
50763 }
50764 if (!_v) goto check_2;
50765 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50766 }
50767 check_2:
50768
50769 if (argc == 3) {
50770 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50771 }
50772
50773 fail:
50774 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50775 return NULL;
50776 }
50777
50778
50779 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50780 PyObject *resultobj = 0;
50781 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50782 wxWindow *arg2 = (wxWindow *) 0 ;
50783 wxGBSpan result;
50784 void *argp1 = 0 ;
50785 int res1 = 0 ;
50786 void *argp2 = 0 ;
50787 int res2 = 0 ;
50788
50789 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50791 if (!SWIG_IsOK(res1)) {
50792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50793 }
50794 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50795 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50796 if (!SWIG_IsOK(res2)) {
50797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50798 }
50799 arg2 = reinterpret_cast< wxWindow * >(argp2);
50800 {
50801 PyThreadState* __tstate = wxPyBeginAllowThreads();
50802 result = (arg1)->GetItemSpan(arg2);
50803 wxPyEndAllowThreads(__tstate);
50804 if (PyErr_Occurred()) SWIG_fail;
50805 }
50806 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50807 return resultobj;
50808 fail:
50809 return NULL;
50810 }
50811
50812
50813 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50814 PyObject *resultobj = 0;
50815 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50816 wxSizer *arg2 = (wxSizer *) 0 ;
50817 wxGBSpan result;
50818 void *argp1 = 0 ;
50819 int res1 = 0 ;
50820 void *argp2 = 0 ;
50821 int res2 = 0 ;
50822
50823 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50825 if (!SWIG_IsOK(res1)) {
50826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50827 }
50828 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50829 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50830 if (!SWIG_IsOK(res2)) {
50831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50832 }
50833 arg2 = reinterpret_cast< wxSizer * >(argp2);
50834 {
50835 PyThreadState* __tstate = wxPyBeginAllowThreads();
50836 result = (arg1)->GetItemSpan(arg2);
50837 wxPyEndAllowThreads(__tstate);
50838 if (PyErr_Occurred()) SWIG_fail;
50839 }
50840 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50841 return resultobj;
50842 fail:
50843 return NULL;
50844 }
50845
50846
50847 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50848 PyObject *resultobj = 0;
50849 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50850 size_t arg2 ;
50851 wxGBSpan result;
50852 void *argp1 = 0 ;
50853 int res1 = 0 ;
50854 size_t val2 ;
50855 int ecode2 = 0 ;
50856
50857 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50859 if (!SWIG_IsOK(res1)) {
50860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50861 }
50862 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50863 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50864 if (!SWIG_IsOK(ecode2)) {
50865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50866 }
50867 arg2 = static_cast< size_t >(val2);
50868 {
50869 PyThreadState* __tstate = wxPyBeginAllowThreads();
50870 result = (arg1)->GetItemSpan(arg2);
50871 wxPyEndAllowThreads(__tstate);
50872 if (PyErr_Occurred()) SWIG_fail;
50873 }
50874 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50875 return resultobj;
50876 fail:
50877 return NULL;
50878 }
50879
50880
50881 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50882 int argc;
50883 PyObject *argv[3];
50884
50885 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50886 --argc;
50887 if (argc == 2) {
50888 int _v = 0;
50889 {
50890 void *vptr = 0;
50891 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50892 _v = SWIG_CheckState(res);
50893 }
50894 if (!_v) goto check_1;
50895 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50896 }
50897 check_1:
50898
50899 if (argc == 2) {
50900 int _v = 0;
50901 {
50902 void *vptr = 0;
50903 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50904 _v = SWIG_CheckState(res);
50905 }
50906 if (!_v) goto check_2;
50907 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50908 }
50909 check_2:
50910
50911 if (argc == 2) {
50912 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50913 }
50914
50915 fail:
50916 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50917 return NULL;
50918 }
50919
50920
50921 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50922 PyObject *resultobj = 0;
50923 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50924 wxWindow *arg2 = (wxWindow *) 0 ;
50925 wxGBSpan *arg3 = 0 ;
50926 bool result;
50927 void *argp1 = 0 ;
50928 int res1 = 0 ;
50929 void *argp2 = 0 ;
50930 int res2 = 0 ;
50931 wxGBSpan temp3 ;
50932
50933 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50935 if (!SWIG_IsOK(res1)) {
50936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50937 }
50938 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50939 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50940 if (!SWIG_IsOK(res2)) {
50941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50942 }
50943 arg2 = reinterpret_cast< wxWindow * >(argp2);
50944 {
50945 arg3 = &temp3;
50946 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50947 }
50948 {
50949 PyThreadState* __tstate = wxPyBeginAllowThreads();
50950 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50951 wxPyEndAllowThreads(__tstate);
50952 if (PyErr_Occurred()) SWIG_fail;
50953 }
50954 {
50955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50956 }
50957 return resultobj;
50958 fail:
50959 return NULL;
50960 }
50961
50962
50963 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50964 PyObject *resultobj = 0;
50965 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50966 wxSizer *arg2 = (wxSizer *) 0 ;
50967 wxGBSpan *arg3 = 0 ;
50968 bool result;
50969 void *argp1 = 0 ;
50970 int res1 = 0 ;
50971 void *argp2 = 0 ;
50972 int res2 = 0 ;
50973 wxGBSpan temp3 ;
50974
50975 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50977 if (!SWIG_IsOK(res1)) {
50978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50979 }
50980 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50981 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50982 if (!SWIG_IsOK(res2)) {
50983 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50984 }
50985 arg2 = reinterpret_cast< wxSizer * >(argp2);
50986 {
50987 arg3 = &temp3;
50988 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50989 }
50990 {
50991 PyThreadState* __tstate = wxPyBeginAllowThreads();
50992 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50993 wxPyEndAllowThreads(__tstate);
50994 if (PyErr_Occurred()) SWIG_fail;
50995 }
50996 {
50997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50998 }
50999 return resultobj;
51000 fail:
51001 return NULL;
51002 }
51003
51004
51005 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51006 PyObject *resultobj = 0;
51007 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51008 size_t arg2 ;
51009 wxGBSpan *arg3 = 0 ;
51010 bool result;
51011 void *argp1 = 0 ;
51012 int res1 = 0 ;
51013 size_t val2 ;
51014 int ecode2 = 0 ;
51015 wxGBSpan temp3 ;
51016
51017 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51019 if (!SWIG_IsOK(res1)) {
51020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51021 }
51022 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51023 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51024 if (!SWIG_IsOK(ecode2)) {
51025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51026 }
51027 arg2 = static_cast< size_t >(val2);
51028 {
51029 arg3 = &temp3;
51030 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51031 }
51032 {
51033 PyThreadState* __tstate = wxPyBeginAllowThreads();
51034 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51035 wxPyEndAllowThreads(__tstate);
51036 if (PyErr_Occurred()) SWIG_fail;
51037 }
51038 {
51039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51040 }
51041 return resultobj;
51042 fail:
51043 return NULL;
51044 }
51045
51046
51047 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51048 int argc;
51049 PyObject *argv[4];
51050
51051 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51052 --argc;
51053 if (argc == 3) {
51054 int _v = 0;
51055 {
51056 void *vptr = 0;
51057 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51058 _v = SWIG_CheckState(res);
51059 }
51060 if (!_v) goto check_1;
51061 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51062 }
51063 check_1:
51064
51065 if (argc == 3) {
51066 int _v = 0;
51067 {
51068 void *vptr = 0;
51069 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51070 _v = SWIG_CheckState(res);
51071 }
51072 if (!_v) goto check_2;
51073 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51074 }
51075 check_2:
51076
51077 if (argc == 3) {
51078 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51079 }
51080
51081 fail:
51082 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51083 return NULL;
51084 }
51085
51086
51087 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51088 PyObject *resultobj = 0;
51089 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51090 wxWindow *arg2 = (wxWindow *) 0 ;
51091 wxGBSizerItem *result = 0 ;
51092 void *argp1 = 0 ;
51093 int res1 = 0 ;
51094 void *argp2 = 0 ;
51095 int res2 = 0 ;
51096
51097 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51099 if (!SWIG_IsOK(res1)) {
51100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51101 }
51102 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51103 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51104 if (!SWIG_IsOK(res2)) {
51105 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51106 }
51107 arg2 = reinterpret_cast< wxWindow * >(argp2);
51108 {
51109 PyThreadState* __tstate = wxPyBeginAllowThreads();
51110 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51111 wxPyEndAllowThreads(__tstate);
51112 if (PyErr_Occurred()) SWIG_fail;
51113 }
51114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51115 return resultobj;
51116 fail:
51117 return NULL;
51118 }
51119
51120
51121 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51122 PyObject *resultobj = 0;
51123 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51124 wxSizer *arg2 = (wxSizer *) 0 ;
51125 wxGBSizerItem *result = 0 ;
51126 void *argp1 = 0 ;
51127 int res1 = 0 ;
51128 void *argp2 = 0 ;
51129 int res2 = 0 ;
51130
51131 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51133 if (!SWIG_IsOK(res1)) {
51134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51135 }
51136 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51137 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51138 if (!SWIG_IsOK(res2)) {
51139 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51140 }
51141 arg2 = reinterpret_cast< wxSizer * >(argp2);
51142 {
51143 PyThreadState* __tstate = wxPyBeginAllowThreads();
51144 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51145 wxPyEndAllowThreads(__tstate);
51146 if (PyErr_Occurred()) SWIG_fail;
51147 }
51148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51149 return resultobj;
51150 fail:
51151 return NULL;
51152 }
51153
51154
51155 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51156 int argc;
51157 PyObject *argv[3];
51158
51159 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51160 --argc;
51161 if (argc == 2) {
51162 int _v = 0;
51163 {
51164 void *vptr = 0;
51165 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51166 _v = SWIG_CheckState(res);
51167 }
51168 if (!_v) goto check_1;
51169 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51170 }
51171 check_1:
51172
51173 if (argc == 2) {
51174 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51175 }
51176
51177 fail:
51178 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51179 return NULL;
51180 }
51181
51182
51183 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51184 PyObject *resultobj = 0;
51185 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51186 wxGBPosition *arg2 = 0 ;
51187 wxGBSizerItem *result = 0 ;
51188 void *argp1 = 0 ;
51189 int res1 = 0 ;
51190 wxGBPosition temp2 ;
51191 PyObject * obj0 = 0 ;
51192 PyObject * obj1 = 0 ;
51193 char * kwnames[] = {
51194 (char *) "self",(char *) "pos", NULL
51195 };
51196
51197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51199 if (!SWIG_IsOK(res1)) {
51200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51201 }
51202 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51203 {
51204 arg2 = &temp2;
51205 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51206 }
51207 {
51208 PyThreadState* __tstate = wxPyBeginAllowThreads();
51209 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51210 wxPyEndAllowThreads(__tstate);
51211 if (PyErr_Occurred()) SWIG_fail;
51212 }
51213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51214 return resultobj;
51215 fail:
51216 return NULL;
51217 }
51218
51219
51220 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51221 PyObject *resultobj = 0;
51222 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51223 wxPoint *arg2 = 0 ;
51224 wxGBSizerItem *result = 0 ;
51225 void *argp1 = 0 ;
51226 int res1 = 0 ;
51227 wxPoint temp2 ;
51228 PyObject * obj0 = 0 ;
51229 PyObject * obj1 = 0 ;
51230 char * kwnames[] = {
51231 (char *) "self",(char *) "pt", NULL
51232 };
51233
51234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51236 if (!SWIG_IsOK(res1)) {
51237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51238 }
51239 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51240 {
51241 arg2 = &temp2;
51242 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51243 }
51244 {
51245 PyThreadState* __tstate = wxPyBeginAllowThreads();
51246 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51247 wxPyEndAllowThreads(__tstate);
51248 if (PyErr_Occurred()) SWIG_fail;
51249 }
51250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51251 return resultobj;
51252 fail:
51253 return NULL;
51254 }
51255
51256
51257 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51258 PyObject *resultobj = 0;
51259 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51260 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51261 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51262 bool result;
51263 void *argp1 = 0 ;
51264 int res1 = 0 ;
51265 void *argp2 = 0 ;
51266 int res2 = 0 ;
51267 void *argp3 = 0 ;
51268 int res3 = 0 ;
51269 PyObject * obj0 = 0 ;
51270 PyObject * obj1 = 0 ;
51271 PyObject * obj2 = 0 ;
51272 char * kwnames[] = {
51273 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51274 };
51275
51276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51278 if (!SWIG_IsOK(res1)) {
51279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51280 }
51281 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51282 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51283 if (!SWIG_IsOK(res2)) {
51284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51285 }
51286 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51287 if (obj2) {
51288 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51289 if (!SWIG_IsOK(res3)) {
51290 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51291 }
51292 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51293 }
51294 {
51295 PyThreadState* __tstate = wxPyBeginAllowThreads();
51296 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51297 wxPyEndAllowThreads(__tstate);
51298 if (PyErr_Occurred()) SWIG_fail;
51299 }
51300 {
51301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51302 }
51303 return resultobj;
51304 fail:
51305 return NULL;
51306 }
51307
51308
51309 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51310 PyObject *resultobj = 0;
51311 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51312 wxGBPosition *arg2 = 0 ;
51313 wxGBSpan *arg3 = 0 ;
51314 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51315 bool result;
51316 void *argp1 = 0 ;
51317 int res1 = 0 ;
51318 wxGBPosition temp2 ;
51319 wxGBSpan temp3 ;
51320 void *argp4 = 0 ;
51321 int res4 = 0 ;
51322 PyObject * obj0 = 0 ;
51323 PyObject * obj1 = 0 ;
51324 PyObject * obj2 = 0 ;
51325 PyObject * obj3 = 0 ;
51326 char * kwnames[] = {
51327 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51328 };
51329
51330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51332 if (!SWIG_IsOK(res1)) {
51333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51334 }
51335 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51336 {
51337 arg2 = &temp2;
51338 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51339 }
51340 {
51341 arg3 = &temp3;
51342 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51343 }
51344 if (obj3) {
51345 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51346 if (!SWIG_IsOK(res4)) {
51347 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51348 }
51349 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51350 }
51351 {
51352 PyThreadState* __tstate = wxPyBeginAllowThreads();
51353 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51354 wxPyEndAllowThreads(__tstate);
51355 if (PyErr_Occurred()) SWIG_fail;
51356 }
51357 {
51358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51359 }
51360 return resultobj;
51361 fail:
51362 return NULL;
51363 }
51364
51365
51366 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51367 PyObject *obj;
51368 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51369 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51370 return SWIG_Py_Void();
51371 }
51372
51373 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51374 return SWIG_Python_InitShadowInstance(args);
51375 }
51376
51377 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51378 PyObject *resultobj = 0;
51379 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51380 wxRelationship arg2 ;
51381 wxWindow *arg3 = (wxWindow *) 0 ;
51382 wxEdge arg4 ;
51383 int arg5 = (int) 0 ;
51384 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51385 void *argp1 = 0 ;
51386 int res1 = 0 ;
51387 int val2 ;
51388 int ecode2 = 0 ;
51389 void *argp3 = 0 ;
51390 int res3 = 0 ;
51391 int val4 ;
51392 int ecode4 = 0 ;
51393 int val5 ;
51394 int ecode5 = 0 ;
51395 int val6 ;
51396 int ecode6 = 0 ;
51397 PyObject * obj0 = 0 ;
51398 PyObject * obj1 = 0 ;
51399 PyObject * obj2 = 0 ;
51400 PyObject * obj3 = 0 ;
51401 PyObject * obj4 = 0 ;
51402 PyObject * obj5 = 0 ;
51403 char * kwnames[] = {
51404 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51405 };
51406
51407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51409 if (!SWIG_IsOK(res1)) {
51410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51411 }
51412 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51413 ecode2 = SWIG_AsVal_int(obj1, &val2);
51414 if (!SWIG_IsOK(ecode2)) {
51415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51416 }
51417 arg2 = static_cast< wxRelationship >(val2);
51418 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51419 if (!SWIG_IsOK(res3)) {
51420 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51421 }
51422 arg3 = reinterpret_cast< wxWindow * >(argp3);
51423 ecode4 = SWIG_AsVal_int(obj3, &val4);
51424 if (!SWIG_IsOK(ecode4)) {
51425 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51426 }
51427 arg4 = static_cast< wxEdge >(val4);
51428 if (obj4) {
51429 ecode5 = SWIG_AsVal_int(obj4, &val5);
51430 if (!SWIG_IsOK(ecode5)) {
51431 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51432 }
51433 arg5 = static_cast< int >(val5);
51434 }
51435 if (obj5) {
51436 ecode6 = SWIG_AsVal_int(obj5, &val6);
51437 if (!SWIG_IsOK(ecode6)) {
51438 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51439 }
51440 arg6 = static_cast< int >(val6);
51441 }
51442 {
51443 PyThreadState* __tstate = wxPyBeginAllowThreads();
51444 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51445 wxPyEndAllowThreads(__tstate);
51446 if (PyErr_Occurred()) SWIG_fail;
51447 }
51448 resultobj = SWIG_Py_Void();
51449 return resultobj;
51450 fail:
51451 return NULL;
51452 }
51453
51454
51455 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51456 PyObject *resultobj = 0;
51457 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51458 wxWindow *arg2 = (wxWindow *) 0 ;
51459 int arg3 = (int) 0 ;
51460 void *argp1 = 0 ;
51461 int res1 = 0 ;
51462 void *argp2 = 0 ;
51463 int res2 = 0 ;
51464 int val3 ;
51465 int ecode3 = 0 ;
51466 PyObject * obj0 = 0 ;
51467 PyObject * obj1 = 0 ;
51468 PyObject * obj2 = 0 ;
51469 char * kwnames[] = {
51470 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51471 };
51472
51473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51475 if (!SWIG_IsOK(res1)) {
51476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51477 }
51478 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51479 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51480 if (!SWIG_IsOK(res2)) {
51481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51482 }
51483 arg2 = reinterpret_cast< wxWindow * >(argp2);
51484 if (obj2) {
51485 ecode3 = SWIG_AsVal_int(obj2, &val3);
51486 if (!SWIG_IsOK(ecode3)) {
51487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51488 }
51489 arg3 = static_cast< int >(val3);
51490 }
51491 {
51492 PyThreadState* __tstate = wxPyBeginAllowThreads();
51493 (arg1)->LeftOf(arg2,arg3);
51494 wxPyEndAllowThreads(__tstate);
51495 if (PyErr_Occurred()) SWIG_fail;
51496 }
51497 resultobj = SWIG_Py_Void();
51498 return resultobj;
51499 fail:
51500 return NULL;
51501 }
51502
51503
51504 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51505 PyObject *resultobj = 0;
51506 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51507 wxWindow *arg2 = (wxWindow *) 0 ;
51508 int arg3 = (int) 0 ;
51509 void *argp1 = 0 ;
51510 int res1 = 0 ;
51511 void *argp2 = 0 ;
51512 int res2 = 0 ;
51513 int val3 ;
51514 int ecode3 = 0 ;
51515 PyObject * obj0 = 0 ;
51516 PyObject * obj1 = 0 ;
51517 PyObject * obj2 = 0 ;
51518 char * kwnames[] = {
51519 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51520 };
51521
51522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51524 if (!SWIG_IsOK(res1)) {
51525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51526 }
51527 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51528 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51529 if (!SWIG_IsOK(res2)) {
51530 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51531 }
51532 arg2 = reinterpret_cast< wxWindow * >(argp2);
51533 if (obj2) {
51534 ecode3 = SWIG_AsVal_int(obj2, &val3);
51535 if (!SWIG_IsOK(ecode3)) {
51536 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51537 }
51538 arg3 = static_cast< int >(val3);
51539 }
51540 {
51541 PyThreadState* __tstate = wxPyBeginAllowThreads();
51542 (arg1)->RightOf(arg2,arg3);
51543 wxPyEndAllowThreads(__tstate);
51544 if (PyErr_Occurred()) SWIG_fail;
51545 }
51546 resultobj = SWIG_Py_Void();
51547 return resultobj;
51548 fail:
51549 return NULL;
51550 }
51551
51552
51553 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51554 PyObject *resultobj = 0;
51555 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51556 wxWindow *arg2 = (wxWindow *) 0 ;
51557 int arg3 = (int) 0 ;
51558 void *argp1 = 0 ;
51559 int res1 = 0 ;
51560 void *argp2 = 0 ;
51561 int res2 = 0 ;
51562 int val3 ;
51563 int ecode3 = 0 ;
51564 PyObject * obj0 = 0 ;
51565 PyObject * obj1 = 0 ;
51566 PyObject * obj2 = 0 ;
51567 char * kwnames[] = {
51568 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51569 };
51570
51571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51573 if (!SWIG_IsOK(res1)) {
51574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51575 }
51576 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51577 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51578 if (!SWIG_IsOK(res2)) {
51579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51580 }
51581 arg2 = reinterpret_cast< wxWindow * >(argp2);
51582 if (obj2) {
51583 ecode3 = SWIG_AsVal_int(obj2, &val3);
51584 if (!SWIG_IsOK(ecode3)) {
51585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51586 }
51587 arg3 = static_cast< int >(val3);
51588 }
51589 {
51590 PyThreadState* __tstate = wxPyBeginAllowThreads();
51591 (arg1)->Above(arg2,arg3);
51592 wxPyEndAllowThreads(__tstate);
51593 if (PyErr_Occurred()) SWIG_fail;
51594 }
51595 resultobj = SWIG_Py_Void();
51596 return resultobj;
51597 fail:
51598 return NULL;
51599 }
51600
51601
51602 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51603 PyObject *resultobj = 0;
51604 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51605 wxWindow *arg2 = (wxWindow *) 0 ;
51606 int arg3 = (int) 0 ;
51607 void *argp1 = 0 ;
51608 int res1 = 0 ;
51609 void *argp2 = 0 ;
51610 int res2 = 0 ;
51611 int val3 ;
51612 int ecode3 = 0 ;
51613 PyObject * obj0 = 0 ;
51614 PyObject * obj1 = 0 ;
51615 PyObject * obj2 = 0 ;
51616 char * kwnames[] = {
51617 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51618 };
51619
51620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51622 if (!SWIG_IsOK(res1)) {
51623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51624 }
51625 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51626 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51627 if (!SWIG_IsOK(res2)) {
51628 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51629 }
51630 arg2 = reinterpret_cast< wxWindow * >(argp2);
51631 if (obj2) {
51632 ecode3 = SWIG_AsVal_int(obj2, &val3);
51633 if (!SWIG_IsOK(ecode3)) {
51634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51635 }
51636 arg3 = static_cast< int >(val3);
51637 }
51638 {
51639 PyThreadState* __tstate = wxPyBeginAllowThreads();
51640 (arg1)->Below(arg2,arg3);
51641 wxPyEndAllowThreads(__tstate);
51642 if (PyErr_Occurred()) SWIG_fail;
51643 }
51644 resultobj = SWIG_Py_Void();
51645 return resultobj;
51646 fail:
51647 return NULL;
51648 }
51649
51650
51651 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51652 PyObject *resultobj = 0;
51653 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51654 wxWindow *arg2 = (wxWindow *) 0 ;
51655 wxEdge arg3 ;
51656 int arg4 = (int) 0 ;
51657 void *argp1 = 0 ;
51658 int res1 = 0 ;
51659 void *argp2 = 0 ;
51660 int res2 = 0 ;
51661 int val3 ;
51662 int ecode3 = 0 ;
51663 int val4 ;
51664 int ecode4 = 0 ;
51665 PyObject * obj0 = 0 ;
51666 PyObject * obj1 = 0 ;
51667 PyObject * obj2 = 0 ;
51668 PyObject * obj3 = 0 ;
51669 char * kwnames[] = {
51670 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51671 };
51672
51673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51675 if (!SWIG_IsOK(res1)) {
51676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51677 }
51678 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51679 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51680 if (!SWIG_IsOK(res2)) {
51681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51682 }
51683 arg2 = reinterpret_cast< wxWindow * >(argp2);
51684 ecode3 = SWIG_AsVal_int(obj2, &val3);
51685 if (!SWIG_IsOK(ecode3)) {
51686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51687 }
51688 arg3 = static_cast< wxEdge >(val3);
51689 if (obj3) {
51690 ecode4 = SWIG_AsVal_int(obj3, &val4);
51691 if (!SWIG_IsOK(ecode4)) {
51692 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51693 }
51694 arg4 = static_cast< int >(val4);
51695 }
51696 {
51697 PyThreadState* __tstate = wxPyBeginAllowThreads();
51698 (arg1)->SameAs(arg2,arg3,arg4);
51699 wxPyEndAllowThreads(__tstate);
51700 if (PyErr_Occurred()) SWIG_fail;
51701 }
51702 resultobj = SWIG_Py_Void();
51703 return resultobj;
51704 fail:
51705 return NULL;
51706 }
51707
51708
51709 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51710 PyObject *resultobj = 0;
51711 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51712 wxWindow *arg2 = (wxWindow *) 0 ;
51713 wxEdge arg3 ;
51714 int arg4 ;
51715 void *argp1 = 0 ;
51716 int res1 = 0 ;
51717 void *argp2 = 0 ;
51718 int res2 = 0 ;
51719 int val3 ;
51720 int ecode3 = 0 ;
51721 int val4 ;
51722 int ecode4 = 0 ;
51723 PyObject * obj0 = 0 ;
51724 PyObject * obj1 = 0 ;
51725 PyObject * obj2 = 0 ;
51726 PyObject * obj3 = 0 ;
51727 char * kwnames[] = {
51728 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51729 };
51730
51731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51733 if (!SWIG_IsOK(res1)) {
51734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51735 }
51736 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51737 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51738 if (!SWIG_IsOK(res2)) {
51739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51740 }
51741 arg2 = reinterpret_cast< wxWindow * >(argp2);
51742 ecode3 = SWIG_AsVal_int(obj2, &val3);
51743 if (!SWIG_IsOK(ecode3)) {
51744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51745 }
51746 arg3 = static_cast< wxEdge >(val3);
51747 ecode4 = SWIG_AsVal_int(obj3, &val4);
51748 if (!SWIG_IsOK(ecode4)) {
51749 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51750 }
51751 arg4 = static_cast< int >(val4);
51752 {
51753 PyThreadState* __tstate = wxPyBeginAllowThreads();
51754 (arg1)->PercentOf(arg2,arg3,arg4);
51755 wxPyEndAllowThreads(__tstate);
51756 if (PyErr_Occurred()) SWIG_fail;
51757 }
51758 resultobj = SWIG_Py_Void();
51759 return resultobj;
51760 fail:
51761 return NULL;
51762 }
51763
51764
51765 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51766 PyObject *resultobj = 0;
51767 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51768 int arg2 ;
51769 void *argp1 = 0 ;
51770 int res1 = 0 ;
51771 int val2 ;
51772 int ecode2 = 0 ;
51773 PyObject * obj0 = 0 ;
51774 PyObject * obj1 = 0 ;
51775 char * kwnames[] = {
51776 (char *) "self",(char *) "val", NULL
51777 };
51778
51779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51781 if (!SWIG_IsOK(res1)) {
51782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51783 }
51784 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51785 ecode2 = SWIG_AsVal_int(obj1, &val2);
51786 if (!SWIG_IsOK(ecode2)) {
51787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51788 }
51789 arg2 = static_cast< int >(val2);
51790 {
51791 PyThreadState* __tstate = wxPyBeginAllowThreads();
51792 (arg1)->Absolute(arg2);
51793 wxPyEndAllowThreads(__tstate);
51794 if (PyErr_Occurred()) SWIG_fail;
51795 }
51796 resultobj = SWIG_Py_Void();
51797 return resultobj;
51798 fail:
51799 return NULL;
51800 }
51801
51802
51803 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51804 PyObject *resultobj = 0;
51805 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51806 void *argp1 = 0 ;
51807 int res1 = 0 ;
51808 PyObject *swig_obj[1] ;
51809
51810 if (!args) SWIG_fail;
51811 swig_obj[0] = args;
51812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51813 if (!SWIG_IsOK(res1)) {
51814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51815 }
51816 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51817 {
51818 PyThreadState* __tstate = wxPyBeginAllowThreads();
51819 (arg1)->Unconstrained();
51820 wxPyEndAllowThreads(__tstate);
51821 if (PyErr_Occurred()) SWIG_fail;
51822 }
51823 resultobj = SWIG_Py_Void();
51824 return resultobj;
51825 fail:
51826 return NULL;
51827 }
51828
51829
51830 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51831 PyObject *resultobj = 0;
51832 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51833 void *argp1 = 0 ;
51834 int res1 = 0 ;
51835 PyObject *swig_obj[1] ;
51836
51837 if (!args) SWIG_fail;
51838 swig_obj[0] = args;
51839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51840 if (!SWIG_IsOK(res1)) {
51841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51842 }
51843 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51844 {
51845 PyThreadState* __tstate = wxPyBeginAllowThreads();
51846 (arg1)->AsIs();
51847 wxPyEndAllowThreads(__tstate);
51848 if (PyErr_Occurred()) SWIG_fail;
51849 }
51850 resultobj = SWIG_Py_Void();
51851 return resultobj;
51852 fail:
51853 return NULL;
51854 }
51855
51856
51857 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51858 PyObject *resultobj = 0;
51859 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51860 wxWindow *result = 0 ;
51861 void *argp1 = 0 ;
51862 int res1 = 0 ;
51863 PyObject *swig_obj[1] ;
51864
51865 if (!args) SWIG_fail;
51866 swig_obj[0] = args;
51867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51868 if (!SWIG_IsOK(res1)) {
51869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51870 }
51871 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51872 {
51873 PyThreadState* __tstate = wxPyBeginAllowThreads();
51874 result = (wxWindow *)(arg1)->GetOtherWindow();
51875 wxPyEndAllowThreads(__tstate);
51876 if (PyErr_Occurred()) SWIG_fail;
51877 }
51878 {
51879 resultobj = wxPyMake_wxObject(result, 0);
51880 }
51881 return resultobj;
51882 fail:
51883 return NULL;
51884 }
51885
51886
51887 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51888 PyObject *resultobj = 0;
51889 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51890 wxEdge result;
51891 void *argp1 = 0 ;
51892 int res1 = 0 ;
51893 PyObject *swig_obj[1] ;
51894
51895 if (!args) SWIG_fail;
51896 swig_obj[0] = args;
51897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51898 if (!SWIG_IsOK(res1)) {
51899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51900 }
51901 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51902 {
51903 PyThreadState* __tstate = wxPyBeginAllowThreads();
51904 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51905 wxPyEndAllowThreads(__tstate);
51906 if (PyErr_Occurred()) SWIG_fail;
51907 }
51908 resultobj = SWIG_From_int(static_cast< int >(result));
51909 return resultobj;
51910 fail:
51911 return NULL;
51912 }
51913
51914
51915 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51916 PyObject *resultobj = 0;
51917 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51918 wxEdge arg2 ;
51919 void *argp1 = 0 ;
51920 int res1 = 0 ;
51921 int val2 ;
51922 int ecode2 = 0 ;
51923 PyObject * obj0 = 0 ;
51924 PyObject * obj1 = 0 ;
51925 char * kwnames[] = {
51926 (char *) "self",(char *) "which", NULL
51927 };
51928
51929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51931 if (!SWIG_IsOK(res1)) {
51932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51933 }
51934 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51935 ecode2 = SWIG_AsVal_int(obj1, &val2);
51936 if (!SWIG_IsOK(ecode2)) {
51937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51938 }
51939 arg2 = static_cast< wxEdge >(val2);
51940 {
51941 PyThreadState* __tstate = wxPyBeginAllowThreads();
51942 (arg1)->SetEdge(arg2);
51943 wxPyEndAllowThreads(__tstate);
51944 if (PyErr_Occurred()) SWIG_fail;
51945 }
51946 resultobj = SWIG_Py_Void();
51947 return resultobj;
51948 fail:
51949 return NULL;
51950 }
51951
51952
51953 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51954 PyObject *resultobj = 0;
51955 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51956 int arg2 ;
51957 void *argp1 = 0 ;
51958 int res1 = 0 ;
51959 int val2 ;
51960 int ecode2 = 0 ;
51961 PyObject * obj0 = 0 ;
51962 PyObject * obj1 = 0 ;
51963 char * kwnames[] = {
51964 (char *) "self",(char *) "v", NULL
51965 };
51966
51967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51969 if (!SWIG_IsOK(res1)) {
51970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51971 }
51972 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51973 ecode2 = SWIG_AsVal_int(obj1, &val2);
51974 if (!SWIG_IsOK(ecode2)) {
51975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51976 }
51977 arg2 = static_cast< int >(val2);
51978 {
51979 PyThreadState* __tstate = wxPyBeginAllowThreads();
51980 (arg1)->SetValue(arg2);
51981 wxPyEndAllowThreads(__tstate);
51982 if (PyErr_Occurred()) SWIG_fail;
51983 }
51984 resultobj = SWIG_Py_Void();
51985 return resultobj;
51986 fail:
51987 return NULL;
51988 }
51989
51990
51991 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51992 PyObject *resultobj = 0;
51993 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51994 int result;
51995 void *argp1 = 0 ;
51996 int res1 = 0 ;
51997 PyObject *swig_obj[1] ;
51998
51999 if (!args) SWIG_fail;
52000 swig_obj[0] = args;
52001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52002 if (!SWIG_IsOK(res1)) {
52003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52004 }
52005 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52006 {
52007 PyThreadState* __tstate = wxPyBeginAllowThreads();
52008 result = (int)(arg1)->GetMargin();
52009 wxPyEndAllowThreads(__tstate);
52010 if (PyErr_Occurred()) SWIG_fail;
52011 }
52012 resultobj = SWIG_From_int(static_cast< int >(result));
52013 return resultobj;
52014 fail:
52015 return NULL;
52016 }
52017
52018
52019 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52020 PyObject *resultobj = 0;
52021 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52022 int arg2 ;
52023 void *argp1 = 0 ;
52024 int res1 = 0 ;
52025 int val2 ;
52026 int ecode2 = 0 ;
52027 PyObject * obj0 = 0 ;
52028 PyObject * obj1 = 0 ;
52029 char * kwnames[] = {
52030 (char *) "self",(char *) "m", NULL
52031 };
52032
52033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52035 if (!SWIG_IsOK(res1)) {
52036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52037 }
52038 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52039 ecode2 = SWIG_AsVal_int(obj1, &val2);
52040 if (!SWIG_IsOK(ecode2)) {
52041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52042 }
52043 arg2 = static_cast< int >(val2);
52044 {
52045 PyThreadState* __tstate = wxPyBeginAllowThreads();
52046 (arg1)->SetMargin(arg2);
52047 wxPyEndAllowThreads(__tstate);
52048 if (PyErr_Occurred()) SWIG_fail;
52049 }
52050 resultobj = SWIG_Py_Void();
52051 return resultobj;
52052 fail:
52053 return NULL;
52054 }
52055
52056
52057 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52058 PyObject *resultobj = 0;
52059 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52060 int result;
52061 void *argp1 = 0 ;
52062 int res1 = 0 ;
52063 PyObject *swig_obj[1] ;
52064
52065 if (!args) SWIG_fail;
52066 swig_obj[0] = args;
52067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52068 if (!SWIG_IsOK(res1)) {
52069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52070 }
52071 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52072 {
52073 PyThreadState* __tstate = wxPyBeginAllowThreads();
52074 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52075 wxPyEndAllowThreads(__tstate);
52076 if (PyErr_Occurred()) SWIG_fail;
52077 }
52078 resultobj = SWIG_From_int(static_cast< int >(result));
52079 return resultobj;
52080 fail:
52081 return NULL;
52082 }
52083
52084
52085 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52086 PyObject *resultobj = 0;
52087 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52088 int result;
52089 void *argp1 = 0 ;
52090 int res1 = 0 ;
52091 PyObject *swig_obj[1] ;
52092
52093 if (!args) SWIG_fail;
52094 swig_obj[0] = args;
52095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52096 if (!SWIG_IsOK(res1)) {
52097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52098 }
52099 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52100 {
52101 PyThreadState* __tstate = wxPyBeginAllowThreads();
52102 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52103 wxPyEndAllowThreads(__tstate);
52104 if (PyErr_Occurred()) SWIG_fail;
52105 }
52106 resultobj = SWIG_From_int(static_cast< int >(result));
52107 return resultobj;
52108 fail:
52109 return NULL;
52110 }
52111
52112
52113 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52114 PyObject *resultobj = 0;
52115 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52116 int result;
52117 void *argp1 = 0 ;
52118 int res1 = 0 ;
52119 PyObject *swig_obj[1] ;
52120
52121 if (!args) SWIG_fail;
52122 swig_obj[0] = args;
52123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52124 if (!SWIG_IsOK(res1)) {
52125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52126 }
52127 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52128 {
52129 PyThreadState* __tstate = wxPyBeginAllowThreads();
52130 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52131 wxPyEndAllowThreads(__tstate);
52132 if (PyErr_Occurred()) SWIG_fail;
52133 }
52134 resultobj = SWIG_From_int(static_cast< int >(result));
52135 return resultobj;
52136 fail:
52137 return NULL;
52138 }
52139
52140
52141 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52142 PyObject *resultobj = 0;
52143 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52144 bool result;
52145 void *argp1 = 0 ;
52146 int res1 = 0 ;
52147 PyObject *swig_obj[1] ;
52148
52149 if (!args) SWIG_fail;
52150 swig_obj[0] = args;
52151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52152 if (!SWIG_IsOK(res1)) {
52153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52154 }
52155 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52156 {
52157 PyThreadState* __tstate = wxPyBeginAllowThreads();
52158 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52159 wxPyEndAllowThreads(__tstate);
52160 if (PyErr_Occurred()) SWIG_fail;
52161 }
52162 {
52163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52164 }
52165 return resultobj;
52166 fail:
52167 return NULL;
52168 }
52169
52170
52171 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52172 PyObject *resultobj = 0;
52173 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52174 bool arg2 ;
52175 void *argp1 = 0 ;
52176 int res1 = 0 ;
52177 bool val2 ;
52178 int ecode2 = 0 ;
52179 PyObject * obj0 = 0 ;
52180 PyObject * obj1 = 0 ;
52181 char * kwnames[] = {
52182 (char *) "self",(char *) "d", NULL
52183 };
52184
52185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52187 if (!SWIG_IsOK(res1)) {
52188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52189 }
52190 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52191 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52192 if (!SWIG_IsOK(ecode2)) {
52193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52194 }
52195 arg2 = static_cast< bool >(val2);
52196 {
52197 PyThreadState* __tstate = wxPyBeginAllowThreads();
52198 (arg1)->SetDone(arg2);
52199 wxPyEndAllowThreads(__tstate);
52200 if (PyErr_Occurred()) SWIG_fail;
52201 }
52202 resultobj = SWIG_Py_Void();
52203 return resultobj;
52204 fail:
52205 return NULL;
52206 }
52207
52208
52209 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52210 PyObject *resultobj = 0;
52211 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52212 wxRelationship result;
52213 void *argp1 = 0 ;
52214 int res1 = 0 ;
52215 PyObject *swig_obj[1] ;
52216
52217 if (!args) SWIG_fail;
52218 swig_obj[0] = args;
52219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52220 if (!SWIG_IsOK(res1)) {
52221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52222 }
52223 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52224 {
52225 PyThreadState* __tstate = wxPyBeginAllowThreads();
52226 result = (wxRelationship)(arg1)->GetRelationship();
52227 wxPyEndAllowThreads(__tstate);
52228 if (PyErr_Occurred()) SWIG_fail;
52229 }
52230 resultobj = SWIG_From_int(static_cast< int >(result));
52231 return resultobj;
52232 fail:
52233 return NULL;
52234 }
52235
52236
52237 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52238 PyObject *resultobj = 0;
52239 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52240 wxRelationship arg2 ;
52241 void *argp1 = 0 ;
52242 int res1 = 0 ;
52243 int val2 ;
52244 int ecode2 = 0 ;
52245 PyObject * obj0 = 0 ;
52246 PyObject * obj1 = 0 ;
52247 char * kwnames[] = {
52248 (char *) "self",(char *) "r", NULL
52249 };
52250
52251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52253 if (!SWIG_IsOK(res1)) {
52254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52255 }
52256 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52257 ecode2 = SWIG_AsVal_int(obj1, &val2);
52258 if (!SWIG_IsOK(ecode2)) {
52259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52260 }
52261 arg2 = static_cast< wxRelationship >(val2);
52262 {
52263 PyThreadState* __tstate = wxPyBeginAllowThreads();
52264 (arg1)->SetRelationship(arg2);
52265 wxPyEndAllowThreads(__tstate);
52266 if (PyErr_Occurred()) SWIG_fail;
52267 }
52268 resultobj = SWIG_Py_Void();
52269 return resultobj;
52270 fail:
52271 return NULL;
52272 }
52273
52274
52275 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52276 PyObject *resultobj = 0;
52277 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52278 wxWindow *arg2 = (wxWindow *) 0 ;
52279 bool result;
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 *) "otherW", NULL
52288 };
52289
52290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52292 if (!SWIG_IsOK(res1)) {
52293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52294 }
52295 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(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 '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52299 }
52300 arg2 = reinterpret_cast< wxWindow * >(argp2);
52301 {
52302 PyThreadState* __tstate = wxPyBeginAllowThreads();
52303 result = (bool)(arg1)->ResetIfWin(arg2);
52304 wxPyEndAllowThreads(__tstate);
52305 if (PyErr_Occurred()) SWIG_fail;
52306 }
52307 {
52308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52309 }
52310 return resultobj;
52311 fail:
52312 return NULL;
52313 }
52314
52315
52316 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52317 PyObject *resultobj = 0;
52318 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52319 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52320 wxWindow *arg3 = (wxWindow *) 0 ;
52321 bool result;
52322 void *argp1 = 0 ;
52323 int res1 = 0 ;
52324 void *argp2 = 0 ;
52325 int res2 = 0 ;
52326 void *argp3 = 0 ;
52327 int res3 = 0 ;
52328 PyObject * obj0 = 0 ;
52329 PyObject * obj1 = 0 ;
52330 PyObject * obj2 = 0 ;
52331 char * kwnames[] = {
52332 (char *) "self",(char *) "constraints",(char *) "win", NULL
52333 };
52334
52335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52337 if (!SWIG_IsOK(res1)) {
52338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52339 }
52340 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52341 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52342 if (!SWIG_IsOK(res2)) {
52343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52344 }
52345 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52346 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52347 if (!SWIG_IsOK(res3)) {
52348 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52349 }
52350 arg3 = reinterpret_cast< wxWindow * >(argp3);
52351 {
52352 PyThreadState* __tstate = wxPyBeginAllowThreads();
52353 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52354 wxPyEndAllowThreads(__tstate);
52355 if (PyErr_Occurred()) SWIG_fail;
52356 }
52357 {
52358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52359 }
52360 return resultobj;
52361 fail:
52362 return NULL;
52363 }
52364
52365
52366 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52367 PyObject *resultobj = 0;
52368 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52369 wxEdge arg2 ;
52370 wxWindow *arg3 = (wxWindow *) 0 ;
52371 wxWindow *arg4 = (wxWindow *) 0 ;
52372 int result;
52373 void *argp1 = 0 ;
52374 int res1 = 0 ;
52375 int val2 ;
52376 int ecode2 = 0 ;
52377 void *argp3 = 0 ;
52378 int res3 = 0 ;
52379 void *argp4 = 0 ;
52380 int res4 = 0 ;
52381 PyObject * obj0 = 0 ;
52382 PyObject * obj1 = 0 ;
52383 PyObject * obj2 = 0 ;
52384 PyObject * obj3 = 0 ;
52385 char * kwnames[] = {
52386 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52387 };
52388
52389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52391 if (!SWIG_IsOK(res1)) {
52392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52393 }
52394 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52395 ecode2 = SWIG_AsVal_int(obj1, &val2);
52396 if (!SWIG_IsOK(ecode2)) {
52397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52398 }
52399 arg2 = static_cast< wxEdge >(val2);
52400 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52401 if (!SWIG_IsOK(res3)) {
52402 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52403 }
52404 arg3 = reinterpret_cast< wxWindow * >(argp3);
52405 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52406 if (!SWIG_IsOK(res4)) {
52407 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52408 }
52409 arg4 = reinterpret_cast< wxWindow * >(argp4);
52410 {
52411 PyThreadState* __tstate = wxPyBeginAllowThreads();
52412 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52413 wxPyEndAllowThreads(__tstate);
52414 if (PyErr_Occurred()) SWIG_fail;
52415 }
52416 resultobj = SWIG_From_int(static_cast< int >(result));
52417 return resultobj;
52418 fail:
52419 return NULL;
52420 }
52421
52422
52423 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52424 PyObject *obj;
52425 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52426 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52427 return SWIG_Py_Void();
52428 }
52429
52430 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52431 PyObject *resultobj = 0;
52432 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52433 wxIndividualLayoutConstraint *result = 0 ;
52434 void *argp1 = 0 ;
52435 int res1 = 0 ;
52436 PyObject *swig_obj[1] ;
52437
52438 if (!args) SWIG_fail;
52439 swig_obj[0] = args;
52440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52441 if (!SWIG_IsOK(res1)) {
52442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52443 }
52444 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52445 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52447 return resultobj;
52448 fail:
52449 return NULL;
52450 }
52451
52452
52453 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52454 PyObject *resultobj = 0;
52455 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52456 wxIndividualLayoutConstraint *result = 0 ;
52457 void *argp1 = 0 ;
52458 int res1 = 0 ;
52459 PyObject *swig_obj[1] ;
52460
52461 if (!args) SWIG_fail;
52462 swig_obj[0] = args;
52463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52464 if (!SWIG_IsOK(res1)) {
52465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52466 }
52467 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52468 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52470 return resultobj;
52471 fail:
52472 return NULL;
52473 }
52474
52475
52476 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52477 PyObject *resultobj = 0;
52478 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52479 wxIndividualLayoutConstraint *result = 0 ;
52480 void *argp1 = 0 ;
52481 int res1 = 0 ;
52482 PyObject *swig_obj[1] ;
52483
52484 if (!args) SWIG_fail;
52485 swig_obj[0] = args;
52486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52487 if (!SWIG_IsOK(res1)) {
52488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52489 }
52490 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52491 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52493 return resultobj;
52494 fail:
52495 return NULL;
52496 }
52497
52498
52499 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52500 PyObject *resultobj = 0;
52501 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52502 wxIndividualLayoutConstraint *result = 0 ;
52503 void *argp1 = 0 ;
52504 int res1 = 0 ;
52505 PyObject *swig_obj[1] ;
52506
52507 if (!args) SWIG_fail;
52508 swig_obj[0] = args;
52509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52510 if (!SWIG_IsOK(res1)) {
52511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52512 }
52513 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52514 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52516 return resultobj;
52517 fail:
52518 return NULL;
52519 }
52520
52521
52522 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52523 PyObject *resultobj = 0;
52524 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52525 wxIndividualLayoutConstraint *result = 0 ;
52526 void *argp1 = 0 ;
52527 int res1 = 0 ;
52528 PyObject *swig_obj[1] ;
52529
52530 if (!args) SWIG_fail;
52531 swig_obj[0] = args;
52532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52533 if (!SWIG_IsOK(res1)) {
52534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52535 }
52536 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52537 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52539 return resultobj;
52540 fail:
52541 return NULL;
52542 }
52543
52544
52545 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52546 PyObject *resultobj = 0;
52547 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52548 wxIndividualLayoutConstraint *result = 0 ;
52549 void *argp1 = 0 ;
52550 int res1 = 0 ;
52551 PyObject *swig_obj[1] ;
52552
52553 if (!args) SWIG_fail;
52554 swig_obj[0] = args;
52555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52556 if (!SWIG_IsOK(res1)) {
52557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52558 }
52559 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52560 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52562 return resultobj;
52563 fail:
52564 return NULL;
52565 }
52566
52567
52568 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52569 PyObject *resultobj = 0;
52570 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52571 wxIndividualLayoutConstraint *result = 0 ;
52572 void *argp1 = 0 ;
52573 int res1 = 0 ;
52574 PyObject *swig_obj[1] ;
52575
52576 if (!args) SWIG_fail;
52577 swig_obj[0] = args;
52578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52579 if (!SWIG_IsOK(res1)) {
52580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52581 }
52582 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52583 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52585 return resultobj;
52586 fail:
52587 return NULL;
52588 }
52589
52590
52591 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52592 PyObject *resultobj = 0;
52593 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52594 wxIndividualLayoutConstraint *result = 0 ;
52595 void *argp1 = 0 ;
52596 int res1 = 0 ;
52597 PyObject *swig_obj[1] ;
52598
52599 if (!args) SWIG_fail;
52600 swig_obj[0] = args;
52601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52602 if (!SWIG_IsOK(res1)) {
52603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52604 }
52605 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52606 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52608 return resultobj;
52609 fail:
52610 return NULL;
52611 }
52612
52613
52614 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52615 PyObject *resultobj = 0;
52616 wxLayoutConstraints *result = 0 ;
52617
52618 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52619 {
52620 PyThreadState* __tstate = wxPyBeginAllowThreads();
52621 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52622 wxPyEndAllowThreads(__tstate);
52623 if (PyErr_Occurred()) SWIG_fail;
52624 }
52625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52626 return resultobj;
52627 fail:
52628 return NULL;
52629 }
52630
52631
52632 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52633 PyObject *resultobj = 0;
52634 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52635 void *argp1 = 0 ;
52636 int res1 = 0 ;
52637 PyObject *swig_obj[1] ;
52638
52639 if (!args) SWIG_fail;
52640 swig_obj[0] = args;
52641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52642 if (!SWIG_IsOK(res1)) {
52643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52644 }
52645 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52646 {
52647 PyThreadState* __tstate = wxPyBeginAllowThreads();
52648 delete arg1;
52649
52650 wxPyEndAllowThreads(__tstate);
52651 if (PyErr_Occurred()) SWIG_fail;
52652 }
52653 resultobj = SWIG_Py_Void();
52654 return resultobj;
52655 fail:
52656 return NULL;
52657 }
52658
52659
52660 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52661 PyObject *resultobj = 0;
52662 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52663 wxWindow *arg2 = (wxWindow *) 0 ;
52664 int *arg3 = (int *) 0 ;
52665 bool result;
52666 void *argp1 = 0 ;
52667 int res1 = 0 ;
52668 void *argp2 = 0 ;
52669 int res2 = 0 ;
52670 int temp3 ;
52671 int res3 = SWIG_TMPOBJ ;
52672 PyObject * obj0 = 0 ;
52673 PyObject * obj1 = 0 ;
52674 char * kwnames[] = {
52675 (char *) "self",(char *) "win", NULL
52676 };
52677
52678 arg3 = &temp3;
52679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52681 if (!SWIG_IsOK(res1)) {
52682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52683 }
52684 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52686 if (!SWIG_IsOK(res2)) {
52687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52688 }
52689 arg2 = reinterpret_cast< wxWindow * >(argp2);
52690 {
52691 PyThreadState* __tstate = wxPyBeginAllowThreads();
52692 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52693 wxPyEndAllowThreads(__tstate);
52694 if (PyErr_Occurred()) SWIG_fail;
52695 }
52696 {
52697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52698 }
52699 if (SWIG_IsTmpObj(res3)) {
52700 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52701 } else {
52702 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52704 }
52705 return resultobj;
52706 fail:
52707 return NULL;
52708 }
52709
52710
52711 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52712 PyObject *resultobj = 0;
52713 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52714 bool result;
52715 void *argp1 = 0 ;
52716 int res1 = 0 ;
52717 PyObject *swig_obj[1] ;
52718
52719 if (!args) SWIG_fail;
52720 swig_obj[0] = args;
52721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52722 if (!SWIG_IsOK(res1)) {
52723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52724 }
52725 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52726 {
52727 PyThreadState* __tstate = wxPyBeginAllowThreads();
52728 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52729 wxPyEndAllowThreads(__tstate);
52730 if (PyErr_Occurred()) SWIG_fail;
52731 }
52732 {
52733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52734 }
52735 return resultobj;
52736 fail:
52737 return NULL;
52738 }
52739
52740
52741 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52742 PyObject *obj;
52743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52744 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52745 return SWIG_Py_Void();
52746 }
52747
52748 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52749 return SWIG_Python_InitShadowInstance(args);
52750 }
52751
52752 static PyMethodDef SwigMethods[] = {
52753 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52754 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52755 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52756 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52757 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52758 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52759 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52760 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52761 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52762 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52763 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52764 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52765 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52766 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52767 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52769 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52770 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52771 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52772 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52773 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52774 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52775 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52776 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52777 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52778 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52779 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52780 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52781 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52782 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52783 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52784 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52785 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52786 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52787 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52788 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52789 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52790 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52791 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52792 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52793 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52794 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52795 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52796 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52797 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52798 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52799 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52800 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52801 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52802 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52803 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52804 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52805 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52807 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52808 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52809 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52812 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52813 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52814 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52815 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52817 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52819 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52821 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52822 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52823 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52824 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52825 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52826 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52827 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52828 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52829 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52830 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52831 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52832 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52833 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52834 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52835 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52839 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52840 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52841 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52843 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52849 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52850 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52851 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52853 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52854 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52855 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52856 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52857 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52858 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52859 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52860 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52861 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52863 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52864 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52865 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52867 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52868 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52869 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52870 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52871 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52872 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52873 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52874 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52875 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52877 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52878 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52879 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52880 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52883 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52884 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52885 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52887 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52888 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52889 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52890 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52891 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52892 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52893 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52894 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52895 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52896 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52897 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52898 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52899 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52900 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52901 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52902 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52903 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52904 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52905 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52906 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52907 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52908 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52909 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52910 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52911 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52912 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52913 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52914 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52916 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52917 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52918 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52919 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52920 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52921 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52922 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52923 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52924 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52925 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52926 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52927 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52928 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52929 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52930 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52932 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52933 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52934 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52935 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52936 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52937 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52940 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52941 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52942 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52943 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52945 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52946 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52947 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52948 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52949 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52950 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52951 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52952 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52953 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52954 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52955 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52956 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52957 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52958 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52959 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52960 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52962 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52963 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52964 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52965 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52966 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52967 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52968 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52969 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52970 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52971 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52972 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52973 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52974 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52975 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52976 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52977 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52978 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52979 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52980 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52981 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52982 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52983 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52984 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52986 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52988 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52989 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52990 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52991 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52992 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52993 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52994 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52995 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52996 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52997 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52998 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52999 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53000 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53002 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53003 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53004 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53005 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53006 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53007 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53008 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53009 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53010 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53011 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53012 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53013 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53014 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53015 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53016 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53017 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53018 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53019 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53020 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53021 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53022 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53024 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53025 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53027 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53028 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53029 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53030 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53031 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53033 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53034 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53035 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53036 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53037 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53038 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53039 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53040 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53041 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53042 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53043 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53044 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53045 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53046 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53047 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53048 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53049 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53050 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53051 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53052 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53054 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53056 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53057 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53058 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53059 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53060 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53062 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53063 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53064 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53065 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53067 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53069 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53071 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53074 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53075 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53076 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53077 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53079 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53080 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53081 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53082 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53083 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53084 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53088 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53089 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53090 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53091 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53096 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53097 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53103 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53104 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53105 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53106 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53107 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53108 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53109 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53110 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53111 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53112 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53113 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53114 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53115 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53116 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53117 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53118 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53119 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53120 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53121 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53122 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53123 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53124 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53125 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53126 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53127 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53128 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53129 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53130 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53131 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53132 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53133 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53134 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53135 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53136 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53137 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53138 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53139 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53140 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53141 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53142 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53145 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53146 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53149 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53153 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53154 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53155 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53156 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53158 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53159 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53161 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53163 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53165 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53167 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53168 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53169 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53171 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53172 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53174 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53175 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53176 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53178 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53179 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53180 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53182 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53184 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53185 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53186 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53188 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53189 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53190 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53191 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53193 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53194 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53195 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53197 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53198 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53199 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53200 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53201 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53202 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53203 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53204 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53205 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53206 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53207 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53208 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53209 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53210 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53211 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53212 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53213 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53214 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53215 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53216 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53217 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53219 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53220 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53221 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53223 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53224 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53225 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53226 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53227 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53228 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53229 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53230 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53231 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53232 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53233 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53234 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53235 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53236 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53237 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53238 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53239 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53240 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53241 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53242 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53243 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53244 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53245 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53246 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53247 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53248 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53249 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53250 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53251 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53252 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53253 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53254 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53255 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53256 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53257 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53258 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53259 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53260 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53261 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53262 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53263 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53264 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53265 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53266 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53267 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53268 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53269 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53270 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53271 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53272 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53273 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53274 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53275 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53276 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53277 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53278 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53279 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53280 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53281 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53282 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53284 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53285 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53286 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53287 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53288 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53289 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53290 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53291 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53292 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53293 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53294 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53295 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53296 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53297 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53298 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53299 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53300 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53301 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53302 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53303 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53304 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53305 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53306 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53307 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53308 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53309 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53310 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53311 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53312 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53313 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53314 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53315 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53316 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53317 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53318 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53319 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53320 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53321 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53322 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53323 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53324 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53325 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53326 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53328 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53329 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53332 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53333 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53334 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53335 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53336 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53337 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53339 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53340 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53341 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53342 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53343 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53344 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53346 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53347 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53349 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53350 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53352 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53353 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53354 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53356 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53358 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53359 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53361 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53362 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53363 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53365 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53366 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53367 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53369 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53370 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53372 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53373 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53374 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53375 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53376 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53379 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53381 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53383 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53384 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53385 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53388 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53389 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53390 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53392 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53393 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53394 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53396 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53397 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53398 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53399 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53400 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53401 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53402 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53403 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53404 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53405 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53406 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53407 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53408 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53409 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53410 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53415 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53416 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53418 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53419 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53420 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53421 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53422 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53423 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53424 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53425 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53427 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53428 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53429 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53430 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53431 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53432 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53435 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53436 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53437 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53440 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53441 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53442 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53443 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53444 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53446 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53448 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53449 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53451 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53453 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53454 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53456 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53457 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53458 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53460 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53461 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53462 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53464 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53466 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53467 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53468 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53470 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53472 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53474 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53475 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53477 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53478 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53480 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53482 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53483 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53484 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53486 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53488 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53489 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53490 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53492 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53494 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53495 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53496 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53497 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53499 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53501 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53502 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53503 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53505 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53506 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53508 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53509 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53510 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53511 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53512 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53513 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53514 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53515 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53517 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53519 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53521 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53523 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53525 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53527 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53528 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53529 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53530 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53531 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53532 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53536 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53538 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53539 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53540 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53541 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53542 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53543 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53544 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53546 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53548 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53549 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53551 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53552 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53553 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53554 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53556 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53557 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53558 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53559 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53561 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53562 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53564 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53565 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53566 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53568 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53570 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53571 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53572 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53573 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53574 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53576 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53577 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53578 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53579 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53581 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53582 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53583 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53584 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53585 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53586 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53587 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53588 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53589 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53590 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53591 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53592 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53593 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53594 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53595 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53596 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53597 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53599 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53601 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53603 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53605 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53606 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53610 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53616 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53617 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53619 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53621 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53622 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53623 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53624 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53625 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53626 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53627 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53628 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53629 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53630 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53631 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53632 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53633 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53634 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53635 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53637 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53638 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53641 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53642 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53647 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53648 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53649 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53651 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53652 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53653 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53654 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53657 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53658 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53659 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53661 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53662 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53663 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53664 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53665 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53667 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53669 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53671 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53674 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53675 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53676 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53677 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53678 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53679 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53680 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53684 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53686 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53687 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53688 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53689 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53696 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53700 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53701 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53702 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53703 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53704 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53705 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53706 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53708 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53718 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53719 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53720 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53721 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53724 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53725 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53726 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53727 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53729 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53730 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53734 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53740 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53741 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53742 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53743 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53745 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53746 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53748 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53751 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53753 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53754 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53755 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53764 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53768 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53770 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53781 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53782 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53783 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53784 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53788 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53791 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53793 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53796 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53798 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53799 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53802 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53804 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53805 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53806 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53807 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53808 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53813 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53814 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53815 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53817 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53818 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53819 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53821 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53823 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53824 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53825 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53827 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53828 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53831 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53839 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53846 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53854 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53857 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53858 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53871 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53873 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53875 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53876 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53878 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53880 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53881 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53883 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53884 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53885 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53889 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53891 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53908 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53909 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53911 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53913 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53914 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53915 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53917 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53918 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53921 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53922 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53924 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53925 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53927 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53929 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53930 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53931 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53933 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53935 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53937 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53938 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53940 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53941 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53944 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53946 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53948 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53950 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53953 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53955 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53956 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53957 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53959 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53960 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53961 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53963 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53965 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53966 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53968 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53969 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53973 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53977 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53978 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53980 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53984 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53986 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53988 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53989 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53990 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53991 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53994 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53995 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53996 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53997 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53998 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54000 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54001 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54006 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54007 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54008 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54009 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54010 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54012 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54014 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54016 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54017 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54019 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54021 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54024 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54025 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54026 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54028 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54029 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54030 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54035 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54044 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54045 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54046 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54047 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54048 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54049 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54052 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54055 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54056 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54060 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54061 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54063 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54064 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54066 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54068 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54069 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54071 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54072 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54073 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54079 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54080 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54081 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54082 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54083 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54084 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54091 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54093 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54094 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54095 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54096 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54097 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54098 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54099 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54100 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54104 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54105 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54106 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54107 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54108 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54109 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54110 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54111 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54112 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54113 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54114 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54116 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54117 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54118 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54119 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54120 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54121 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54122 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54124 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54125 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54126 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54127 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54130 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54132 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54133 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54134 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54135 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54136 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54140 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54141 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54146 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54147 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54149 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54150 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54151 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54152 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54155 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54157 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54158 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54159 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54160 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54161 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54165 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54166 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54167 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54174 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54175 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54176 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54177 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54178 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54179 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54180 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54182 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54183 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54184 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54185 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54186 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54187 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54189 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54190 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54191 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54192 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54193 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54194 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54195 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54196 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54197 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54198 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54199 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54200 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54201 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54202 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54203 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54204 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54205 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54206 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54207 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54208 { NULL, NULL, 0, NULL }
54209 };
54210
54211
54212 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54213
54214 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54215 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54216 }
54217 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54218 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54219 }
54220 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54221 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54222 }
54223 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54224 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54225 }
54226 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54227 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54228 }
54229 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54230 return (void *)((wxSizer *) ((wxGridSizer *) x));
54231 }
54232 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54233 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54234 }
54235 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54236 return (void *)((wxSizer *) ((wxPySizer *) x));
54237 }
54238 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54239 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54240 }
54241 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54242 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54243 }
54244 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54245 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54246 }
54247 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54248 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54249 }
54250 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54251 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54252 }
54253 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54254 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54255 }
54256 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54257 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54258 }
54259 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54260 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54261 }
54262 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54263 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54264 }
54265 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54266 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54267 }
54268 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54269 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54270 }
54271 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54272 return (void *)((wxEvent *) ((wxPyEvent *) x));
54273 }
54274 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54275 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54276 }
54277 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54278 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54279 }
54280 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54281 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54282 }
54283 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54284 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54285 }
54286 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54287 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54288 }
54289 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54290 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54291 }
54292 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54293 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54294 }
54295 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54296 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54297 }
54298 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54299 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54300 }
54301 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54302 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54303 }
54304 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54305 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54306 }
54307 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54308 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54309 }
54310 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54311 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54312 }
54313 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54314 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54315 }
54316 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54317 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54318 }
54319 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54320 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54321 }
54322 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54323 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54324 }
54325 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54326 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54327 }
54328 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54329 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54330 }
54331 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54332 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54333 }
54334 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54335 return (void *)((wxEvent *) ((wxShowEvent *) x));
54336 }
54337 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54338 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54339 }
54340 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54341 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54342 }
54343 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54344 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54345 }
54346 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54347 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54348 }
54349 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54350 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54351 }
54352 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54353 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54354 }
54355 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54356 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54357 }
54358 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54359 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54360 }
54361 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54362 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54363 }
54364 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54365 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54366 }
54367 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54368 return (void *)((wxControl *) ((wxControlWithItems *) x));
54369 }
54370 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54371 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54372 }
54373 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54374 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54375 }
54376 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54377 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54378 }
54379 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54380 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54381 }
54382 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54383 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54384 }
54385 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54386 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54387 }
54388 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54389 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54390 }
54391 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54392 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54393 }
54394 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54395 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54396 }
54397 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54398 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54399 }
54400 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54401 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54402 }
54403 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54404 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54405 }
54406 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54407 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54408 }
54409 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54410 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54411 }
54412 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54413 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54414 }
54415 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54416 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54417 }
54418 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54419 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54420 }
54421 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54422 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54423 }
54424 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54425 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54426 }
54427 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54428 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54429 }
54430 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54431 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54432 }
54433 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54434 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54435 }
54436 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54437 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54438 }
54439 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54440 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54441 }
54442 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54443 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54444 }
54445 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54446 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54447 }
54448 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54449 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54450 }
54451 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54452 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54453 }
54454 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54455 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54456 }
54457 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54458 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54459 }
54460 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54461 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54462 }
54463 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54464 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54465 }
54466 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54467 return (void *)((wxObject *) ((wxSizerItem *) x));
54468 }
54469 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54470 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54471 }
54472 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54473 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54474 }
54475 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54476 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54477 }
54478 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54479 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54480 }
54481 static void *_p_wxSizerTo_p_wxObject(void *x) {
54482 return (void *)((wxObject *) ((wxSizer *) x));
54483 }
54484 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54485 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54486 }
54487 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54488 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54489 }
54490 static void *_p_wxEventTo_p_wxObject(void *x) {
54491 return (void *)((wxObject *) ((wxEvent *) x));
54492 }
54493 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54494 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54495 }
54496 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54497 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54498 }
54499 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54500 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54501 }
54502 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54503 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54504 }
54505 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54506 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54507 }
54508 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54509 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54510 }
54511 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54512 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54513 }
54514 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54515 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54516 }
54517 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54518 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54519 }
54520 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54521 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54522 }
54523 static void *_p_wxControlTo_p_wxObject(void *x) {
54524 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54525 }
54526 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54527 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54528 }
54529 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54530 return (void *)((wxObject *) ((wxFSFile *) x));
54531 }
54532 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54533 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54534 }
54535 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54536 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54537 }
54538 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54539 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54540 }
54541 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54542 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54543 }
54544 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54545 return (void *)((wxObject *) ((wxMenuItem *) x));
54546 }
54547 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54548 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54549 }
54550 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54551 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54552 }
54553 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54554 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54555 }
54556 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54557 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54558 }
54559 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54560 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54561 }
54562 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54563 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54564 }
54565 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54566 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54567 }
54568 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54569 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54570 }
54571 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54572 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54573 }
54574 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54575 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54576 }
54577 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54578 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54579 }
54580 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54581 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54582 }
54583 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54584 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54585 }
54586 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54587 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54588 }
54589 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54590 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54591 }
54592 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54593 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54594 }
54595 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54596 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54597 }
54598 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54599 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54600 }
54601 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54602 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54603 }
54604 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54605 return (void *)((wxObject *) ((wxImageHandler *) x));
54606 }
54607 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54608 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54609 }
54610 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54611 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54612 }
54613 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54614 return (void *)((wxObject *) ((wxEvtHandler *) x));
54615 }
54616 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54617 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54618 }
54619 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54620 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54621 }
54622 static void *_p_wxImageTo_p_wxObject(void *x) {
54623 return (void *)((wxObject *) ((wxImage *) x));
54624 }
54625 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54626 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54627 }
54628 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54629 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54630 }
54631 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54632 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54633 }
54634 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54635 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54636 }
54637 static void *_p_wxWindowTo_p_wxObject(void *x) {
54638 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54639 }
54640 static void *_p_wxMenuTo_p_wxObject(void *x) {
54641 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54642 }
54643 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54644 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54645 }
54646 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54647 return (void *)((wxObject *) ((wxFileSystem *) x));
54648 }
54649 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54650 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54651 }
54652 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54653 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54654 }
54655 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54656 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54657 }
54658 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54659 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54660 }
54661 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54662 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54663 }
54664 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54665 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54666 }
54667 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54668 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54669 }
54670 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54671 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54672 }
54673 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54674 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54675 }
54676 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54677 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54678 }
54679 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54680 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54681 }
54682 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54683 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54684 }
54685 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54686 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54687 }
54688 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54689 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54690 }
54691 static void *_p_wxControlTo_p_wxWindow(void *x) {
54692 return (void *)((wxWindow *) ((wxControl *) x));
54693 }
54694 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54695 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54696 }
54697 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54698 return (void *)((wxWindow *) ((wxMenuBar *) x));
54699 }
54700 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54701 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54702 }
54703 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54704 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54705 }
54706 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54707 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54708 }
54709 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54710 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54711 }
54712 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54713 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54714 }
54715 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54716 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54717 }
54718 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54719 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54720 }
54721 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54722 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54723 }
54724 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54725 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54726 }
54727 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54728 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54729 }
54730 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54731 return (void *)((wxValidator *) ((wxPyValidator *) x));
54732 }
54733 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54734 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54735 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};
54736 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54737 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54738 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54739 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54740 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54741 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54742 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54743 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54744 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54745 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54746 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54747 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54748 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54749 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54750 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54751 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54752 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54753 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54754 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54755 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54756 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54757 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54758 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54759 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54760 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54761 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54762 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54763 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54764 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54765 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54766 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54767 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54768 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54769 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54770 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54771 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54772 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54773 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54774 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54775 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54776 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54777 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54778 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54779 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54780 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54781 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54782 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54783 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54784 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54785 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54786 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54787 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54788 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54789 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54790 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54791 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54792 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54793 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54794 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54795 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54796 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54797 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54798 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54799 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54800 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54801 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54802 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54803 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54804 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54805 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54806 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54807 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54808 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54809 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54810 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54811 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54812 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54813 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54814 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54815 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54816 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54817 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54818 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54819 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54820 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54821 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54822 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54823 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54824 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54825 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54826 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54827 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54828 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54829 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54830 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54831 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54832 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54833 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54834 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54835 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54836 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54837 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54838 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54839 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54840 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54841 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54842 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54843 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54844 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54845 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54846 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54847 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54848 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54849 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54850 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54851 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54852 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54853 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54854 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54855 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54856 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54857 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54858 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54859 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54860 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54861 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54862 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54863 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54864
54865 static swig_type_info *swig_type_initial[] = {
54866 &_swigt__p_buffer,
54867 &_swigt__p_char,
54868 &_swigt__p_form_ops_t,
54869 &_swigt__p_int,
54870 &_swigt__p_long,
54871 &_swigt__p_unsigned_char,
54872 &_swigt__p_unsigned_int,
54873 &_swigt__p_unsigned_long,
54874 &_swigt__p_wxANIHandler,
54875 &_swigt__p_wxAcceleratorEntry,
54876 &_swigt__p_wxAcceleratorTable,
54877 &_swigt__p_wxActivateEvent,
54878 &_swigt__p_wxAppTraits,
54879 &_swigt__p_wxArrayString,
54880 &_swigt__p_wxBMPHandler,
54881 &_swigt__p_wxBitmap,
54882 &_swigt__p_wxBoxSizer,
54883 &_swigt__p_wxButton,
54884 &_swigt__p_wxCURHandler,
54885 &_swigt__p_wxCaret,
54886 &_swigt__p_wxChildFocusEvent,
54887 &_swigt__p_wxClipboardTextEvent,
54888 &_swigt__p_wxCloseEvent,
54889 &_swigt__p_wxColour,
54890 &_swigt__p_wxCommandEvent,
54891 &_swigt__p_wxContextMenuEvent,
54892 &_swigt__p_wxControl,
54893 &_swigt__p_wxControlWithItems,
54894 &_swigt__p_wxCursor,
54895 &_swigt__p_wxDC,
54896 &_swigt__p_wxDateEvent,
54897 &_swigt__p_wxDateTime,
54898 &_swigt__p_wxDisplayChangedEvent,
54899 &_swigt__p_wxDropFilesEvent,
54900 &_swigt__p_wxDuplexMode,
54901 &_swigt__p_wxEraseEvent,
54902 &_swigt__p_wxEvent,
54903 &_swigt__p_wxEventLoop,
54904 &_swigt__p_wxEventLoopActivator,
54905 &_swigt__p_wxEvtHandler,
54906 &_swigt__p_wxFSFile,
54907 &_swigt__p_wxFileSystem,
54908 &_swigt__p_wxFileSystemHandler,
54909 &_swigt__p_wxFlexGridSizer,
54910 &_swigt__p_wxFocusEvent,
54911 &_swigt__p_wxFont,
54912 &_swigt__p_wxFrame,
54913 &_swigt__p_wxGBPosition,
54914 &_swigt__p_wxGBSizerItem,
54915 &_swigt__p_wxGBSpan,
54916 &_swigt__p_wxGIFHandler,
54917 &_swigt__p_wxGridBagSizer,
54918 &_swigt__p_wxGridSizer,
54919 &_swigt__p_wxHelpEvent__Origin,
54920 &_swigt__p_wxICOHandler,
54921 &_swigt__p_wxIconizeEvent,
54922 &_swigt__p_wxIdleEvent,
54923 &_swigt__p_wxImage,
54924 &_swigt__p_wxImageHandler,
54925 &_swigt__p_wxImageHistogram,
54926 &_swigt__p_wxImage_HSVValue,
54927 &_swigt__p_wxImage_RGBValue,
54928 &_swigt__p_wxIndividualLayoutConstraint,
54929 &_swigt__p_wxInitDialogEvent,
54930 &_swigt__p_wxInputStream,
54931 &_swigt__p_wxInternetFSHandler,
54932 &_swigt__p_wxItemContainer,
54933 &_swigt__p_wxJPEGHandler,
54934 &_swigt__p_wxKeyEvent,
54935 &_swigt__p_wxLayoutConstraints,
54936 &_swigt__p_wxMaximizeEvent,
54937 &_swigt__p_wxMemoryFSHandler,
54938 &_swigt__p_wxMenu,
54939 &_swigt__p_wxMenuBar,
54940 &_swigt__p_wxMenuBarBase,
54941 &_swigt__p_wxMenuEvent,
54942 &_swigt__p_wxMenuItem,
54943 &_swigt__p_wxMouseCaptureChangedEvent,
54944 &_swigt__p_wxMouseEvent,
54945 &_swigt__p_wxMoveEvent,
54946 &_swigt__p_wxNavigationKeyEvent,
54947 &_swigt__p_wxNcPaintEvent,
54948 &_swigt__p_wxNotifyEvent,
54949 &_swigt__p_wxObject,
54950 &_swigt__p_wxOutputStream,
54951 &_swigt__p_wxPCXHandler,
54952 &_swigt__p_wxPNGHandler,
54953 &_swigt__p_wxPNMHandler,
54954 &_swigt__p_wxPaintEvent,
54955 &_swigt__p_wxPaletteChangedEvent,
54956 &_swigt__p_wxPaperSize,
54957 &_swigt__p_wxPoint,
54958 &_swigt__p_wxPoint2D,
54959 &_swigt__p_wxPropagateOnce,
54960 &_swigt__p_wxPropagationDisabler,
54961 &_swigt__p_wxPyApp,
54962 &_swigt__p_wxPyCommandEvent,
54963 &_swigt__p_wxPyDropTarget,
54964 &_swigt__p_wxPyEvent,
54965 &_swigt__p_wxPyFileSystemHandler,
54966 &_swigt__p_wxPyImageHandler,
54967 &_swigt__p_wxPyInputStream,
54968 &_swigt__p_wxPySizer,
54969 &_swigt__p_wxPyValidator,
54970 &_swigt__p_wxQuantize,
54971 &_swigt__p_wxQueryNewPaletteEvent,
54972 &_swigt__p_wxRealPoint,
54973 &_swigt__p_wxRect,
54974 &_swigt__p_wxRegion,
54975 &_swigt__p_wxScrollEvent,
54976 &_swigt__p_wxScrollWinEvent,
54977 &_swigt__p_wxSetCursorEvent,
54978 &_swigt__p_wxShowEvent,
54979 &_swigt__p_wxSize,
54980 &_swigt__p_wxSizeEvent,
54981 &_swigt__p_wxSizer,
54982 &_swigt__p_wxSizerItem,
54983 &_swigt__p_wxStaticBox,
54984 &_swigt__p_wxStaticBoxSizer,
54985 &_swigt__p_wxStdDialogButtonSizer,
54986 &_swigt__p_wxSysColourChangedEvent,
54987 &_swigt__p_wxTIFFHandler,
54988 &_swigt__p_wxToolTip,
54989 &_swigt__p_wxUpdateUIEvent,
54990 &_swigt__p_wxValidator,
54991 &_swigt__p_wxVisualAttributes,
54992 &_swigt__p_wxWindow,
54993 &_swigt__p_wxWindowCreateEvent,
54994 &_swigt__p_wxWindowDestroyEvent,
54995 &_swigt__p_wxXPMHandler,
54996 &_swigt__p_wxZipFSHandler,
54997 };
54998
54999 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55000 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55001 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55002 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55003 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55004 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55005 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55006 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55007 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55008 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55009 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55010 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55011 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55012 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55013 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}};
55014 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55015 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}};
55016 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55017 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}};
55018 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55019 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55020 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55021 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55022 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55023 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}};
55024 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55025 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}};
55026 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55027 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55028 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55029 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55030 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55031 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55032 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55033 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55034 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55035 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
55036 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55037 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55038 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
55039 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55040 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55041 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}};
55042 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}};
55043 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55044 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55045 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55046 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55047 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55048 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55049 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55050 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55051 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}};
55052 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55053 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}};
55054 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55055 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55056 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55057 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_swigt__p_wxImageHandler, 0, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0},{0, 0, 0, 0}};
55058 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55059 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55060 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55061 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55062 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55063 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55064 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55065 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}};
55066 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55067 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55068 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55069 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55070 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55071 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55072 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55073 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55074 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55075 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55076 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55077 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55078 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55079 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55080 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55081 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55082 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
55083 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55084 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55085 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55086 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55087 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55088 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55089 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55090 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55091 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55092 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55093 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55094 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55095 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55096 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55097 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55098 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55099 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55100 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55101 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55102 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55103 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55104 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55105 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55106 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55107 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55108 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55109 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55110 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55111 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55112 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55113 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55114 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}};
55115 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}};
55116 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55117 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55118 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55119 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55120 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55121 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55122 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55123 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}};
55124 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55125 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}};
55126 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55127 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55128 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55129 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55130
55131 static swig_cast_info *swig_cast_initial[] = {
55132 _swigc__p_buffer,
55133 _swigc__p_char,
55134 _swigc__p_form_ops_t,
55135 _swigc__p_int,
55136 _swigc__p_long,
55137 _swigc__p_unsigned_char,
55138 _swigc__p_unsigned_int,
55139 _swigc__p_unsigned_long,
55140 _swigc__p_wxANIHandler,
55141 _swigc__p_wxAcceleratorEntry,
55142 _swigc__p_wxAcceleratorTable,
55143 _swigc__p_wxActivateEvent,
55144 _swigc__p_wxAppTraits,
55145 _swigc__p_wxArrayString,
55146 _swigc__p_wxBMPHandler,
55147 _swigc__p_wxBitmap,
55148 _swigc__p_wxBoxSizer,
55149 _swigc__p_wxButton,
55150 _swigc__p_wxCURHandler,
55151 _swigc__p_wxCaret,
55152 _swigc__p_wxChildFocusEvent,
55153 _swigc__p_wxClipboardTextEvent,
55154 _swigc__p_wxCloseEvent,
55155 _swigc__p_wxColour,
55156 _swigc__p_wxCommandEvent,
55157 _swigc__p_wxContextMenuEvent,
55158 _swigc__p_wxControl,
55159 _swigc__p_wxControlWithItems,
55160 _swigc__p_wxCursor,
55161 _swigc__p_wxDC,
55162 _swigc__p_wxDateEvent,
55163 _swigc__p_wxDateTime,
55164 _swigc__p_wxDisplayChangedEvent,
55165 _swigc__p_wxDropFilesEvent,
55166 _swigc__p_wxDuplexMode,
55167 _swigc__p_wxEraseEvent,
55168 _swigc__p_wxEvent,
55169 _swigc__p_wxEventLoop,
55170 _swigc__p_wxEventLoopActivator,
55171 _swigc__p_wxEvtHandler,
55172 _swigc__p_wxFSFile,
55173 _swigc__p_wxFileSystem,
55174 _swigc__p_wxFileSystemHandler,
55175 _swigc__p_wxFlexGridSizer,
55176 _swigc__p_wxFocusEvent,
55177 _swigc__p_wxFont,
55178 _swigc__p_wxFrame,
55179 _swigc__p_wxGBPosition,
55180 _swigc__p_wxGBSizerItem,
55181 _swigc__p_wxGBSpan,
55182 _swigc__p_wxGIFHandler,
55183 _swigc__p_wxGridBagSizer,
55184 _swigc__p_wxGridSizer,
55185 _swigc__p_wxHelpEvent__Origin,
55186 _swigc__p_wxICOHandler,
55187 _swigc__p_wxIconizeEvent,
55188 _swigc__p_wxIdleEvent,
55189 _swigc__p_wxImage,
55190 _swigc__p_wxImageHandler,
55191 _swigc__p_wxImageHistogram,
55192 _swigc__p_wxImage_HSVValue,
55193 _swigc__p_wxImage_RGBValue,
55194 _swigc__p_wxIndividualLayoutConstraint,
55195 _swigc__p_wxInitDialogEvent,
55196 _swigc__p_wxInputStream,
55197 _swigc__p_wxInternetFSHandler,
55198 _swigc__p_wxItemContainer,
55199 _swigc__p_wxJPEGHandler,
55200 _swigc__p_wxKeyEvent,
55201 _swigc__p_wxLayoutConstraints,
55202 _swigc__p_wxMaximizeEvent,
55203 _swigc__p_wxMemoryFSHandler,
55204 _swigc__p_wxMenu,
55205 _swigc__p_wxMenuBar,
55206 _swigc__p_wxMenuBarBase,
55207 _swigc__p_wxMenuEvent,
55208 _swigc__p_wxMenuItem,
55209 _swigc__p_wxMouseCaptureChangedEvent,
55210 _swigc__p_wxMouseEvent,
55211 _swigc__p_wxMoveEvent,
55212 _swigc__p_wxNavigationKeyEvent,
55213 _swigc__p_wxNcPaintEvent,
55214 _swigc__p_wxNotifyEvent,
55215 _swigc__p_wxObject,
55216 _swigc__p_wxOutputStream,
55217 _swigc__p_wxPCXHandler,
55218 _swigc__p_wxPNGHandler,
55219 _swigc__p_wxPNMHandler,
55220 _swigc__p_wxPaintEvent,
55221 _swigc__p_wxPaletteChangedEvent,
55222 _swigc__p_wxPaperSize,
55223 _swigc__p_wxPoint,
55224 _swigc__p_wxPoint2D,
55225 _swigc__p_wxPropagateOnce,
55226 _swigc__p_wxPropagationDisabler,
55227 _swigc__p_wxPyApp,
55228 _swigc__p_wxPyCommandEvent,
55229 _swigc__p_wxPyDropTarget,
55230 _swigc__p_wxPyEvent,
55231 _swigc__p_wxPyFileSystemHandler,
55232 _swigc__p_wxPyImageHandler,
55233 _swigc__p_wxPyInputStream,
55234 _swigc__p_wxPySizer,
55235 _swigc__p_wxPyValidator,
55236 _swigc__p_wxQuantize,
55237 _swigc__p_wxQueryNewPaletteEvent,
55238 _swigc__p_wxRealPoint,
55239 _swigc__p_wxRect,
55240 _swigc__p_wxRegion,
55241 _swigc__p_wxScrollEvent,
55242 _swigc__p_wxScrollWinEvent,
55243 _swigc__p_wxSetCursorEvent,
55244 _swigc__p_wxShowEvent,
55245 _swigc__p_wxSize,
55246 _swigc__p_wxSizeEvent,
55247 _swigc__p_wxSizer,
55248 _swigc__p_wxSizerItem,
55249 _swigc__p_wxStaticBox,
55250 _swigc__p_wxStaticBoxSizer,
55251 _swigc__p_wxStdDialogButtonSizer,
55252 _swigc__p_wxSysColourChangedEvent,
55253 _swigc__p_wxTIFFHandler,
55254 _swigc__p_wxToolTip,
55255 _swigc__p_wxUpdateUIEvent,
55256 _swigc__p_wxValidator,
55257 _swigc__p_wxVisualAttributes,
55258 _swigc__p_wxWindow,
55259 _swigc__p_wxWindowCreateEvent,
55260 _swigc__p_wxWindowDestroyEvent,
55261 _swigc__p_wxXPMHandler,
55262 _swigc__p_wxZipFSHandler,
55263 };
55264
55265
55266 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55267
55268 static swig_const_info swig_const_table[] = {
55269 {0, 0, 0, 0.0, 0, 0}};
55270
55271 #ifdef __cplusplus
55272 }
55273 #endif
55274 /* -----------------------------------------------------------------------------
55275 * Type initialization:
55276 * This problem is tough by the requirement that no dynamic
55277 * memory is used. Also, since swig_type_info structures store pointers to
55278 * swig_cast_info structures and swig_cast_info structures store pointers back
55279 * to swig_type_info structures, we need some lookup code at initialization.
55280 * The idea is that swig generates all the structures that are needed.
55281 * The runtime then collects these partially filled structures.
55282 * The SWIG_InitializeModule function takes these initial arrays out of
55283 * swig_module, and does all the lookup, filling in the swig_module.types
55284 * array with the correct data and linking the correct swig_cast_info
55285 * structures together.
55286 *
55287 * The generated swig_type_info structures are assigned staticly to an initial
55288 * array. We just loop though that array, and handle each type individually.
55289 * First we lookup if this type has been already loaded, and if so, use the
55290 * loaded structure instead of the generated one. Then we have to fill in the
55291 * cast linked list. The cast data is initially stored in something like a
55292 * two-dimensional array. Each row corresponds to a type (there are the same
55293 * number of rows as there are in the swig_type_initial array). Each entry in
55294 * a column is one of the swig_cast_info structures for that type.
55295 * The cast_initial array is actually an array of arrays, because each row has
55296 * a variable number of columns. So to actually build the cast linked list,
55297 * we find the array of casts associated with the type, and loop through it
55298 * adding the casts to the list. The one last trick we need to do is making
55299 * sure the type pointer in the swig_cast_info struct is correct.
55300 *
55301 * First off, we lookup the cast->type name to see if it is already loaded.
55302 * There are three cases to handle:
55303 * 1) If the cast->type has already been loaded AND the type we are adding
55304 * casting info to has not been loaded (it is in this module), THEN we
55305 * replace the cast->type pointer with the type pointer that has already
55306 * been loaded.
55307 * 2) If BOTH types (the one we are adding casting info to, and the
55308 * cast->type) are loaded, THEN the cast info has already been loaded by
55309 * the previous module so we just ignore it.
55310 * 3) Finally, if cast->type has not already been loaded, then we add that
55311 * swig_cast_info to the linked list (because the cast->type) pointer will
55312 * be correct.
55313 * ----------------------------------------------------------------------------- */
55314
55315 #ifdef __cplusplus
55316 extern "C" {
55317 #if 0
55318 } /* c-mode */
55319 #endif
55320 #endif
55321
55322 #if 0
55323 #define SWIGRUNTIME_DEBUG
55324 #endif
55325
55326 SWIGRUNTIME void
55327 SWIG_InitializeModule(void *clientdata) {
55328 size_t i;
55329 swig_module_info *module_head;
55330 static int init_run = 0;
55331
55332 clientdata = clientdata;
55333
55334 if (init_run) return;
55335 init_run = 1;
55336
55337 /* Initialize the swig_module */
55338 swig_module.type_initial = swig_type_initial;
55339 swig_module.cast_initial = swig_cast_initial;
55340
55341 /* Try and load any already created modules */
55342 module_head = SWIG_GetModule(clientdata);
55343 if (module_head) {
55344 swig_module.next = module_head->next;
55345 module_head->next = &swig_module;
55346 } else {
55347 /* This is the first module loaded */
55348 swig_module.next = &swig_module;
55349 SWIG_SetModule(clientdata, &swig_module);
55350 }
55351
55352 /* Now work on filling in swig_module.types */
55353 #ifdef SWIGRUNTIME_DEBUG
55354 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55355 #endif
55356 for (i = 0; i < swig_module.size; ++i) {
55357 swig_type_info *type = 0;
55358 swig_type_info *ret;
55359 swig_cast_info *cast;
55360
55361 #ifdef SWIGRUNTIME_DEBUG
55362 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55363 #endif
55364
55365 /* if there is another module already loaded */
55366 if (swig_module.next != &swig_module) {
55367 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55368 }
55369 if (type) {
55370 /* Overwrite clientdata field */
55371 #ifdef SWIGRUNTIME_DEBUG
55372 printf("SWIG_InitializeModule: found type %s\n", type->name);
55373 #endif
55374 if (swig_module.type_initial[i]->clientdata) {
55375 type->clientdata = swig_module.type_initial[i]->clientdata;
55376 #ifdef SWIGRUNTIME_DEBUG
55377 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55378 #endif
55379 }
55380 } else {
55381 type = swig_module.type_initial[i];
55382 }
55383
55384 /* Insert casting types */
55385 cast = swig_module.cast_initial[i];
55386 while (cast->type) {
55387 /* Don't need to add information already in the list */
55388 ret = 0;
55389 #ifdef SWIGRUNTIME_DEBUG
55390 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55391 #endif
55392 if (swig_module.next != &swig_module) {
55393 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55394 #ifdef SWIGRUNTIME_DEBUG
55395 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55396 #endif
55397 }
55398 if (ret) {
55399 if (type == swig_module.type_initial[i]) {
55400 #ifdef SWIGRUNTIME_DEBUG
55401 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55402 #endif
55403 cast->type = ret;
55404 ret = 0;
55405 } else {
55406 /* Check for casting already in the list */
55407 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55408 #ifdef SWIGRUNTIME_DEBUG
55409 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55410 #endif
55411 if (!ocast) ret = 0;
55412 }
55413 }
55414
55415 if (!ret) {
55416 #ifdef SWIGRUNTIME_DEBUG
55417 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55418 #endif
55419 if (type->cast) {
55420 type->cast->prev = cast;
55421 cast->next = type->cast;
55422 }
55423 type->cast = cast;
55424 }
55425 cast++;
55426 }
55427 /* Set entry in modules->types array equal to the type */
55428 swig_module.types[i] = type;
55429 }
55430 swig_module.types[i] = 0;
55431
55432 #ifdef SWIGRUNTIME_DEBUG
55433 printf("**** SWIG_InitializeModule: Cast List ******\n");
55434 for (i = 0; i < swig_module.size; ++i) {
55435 int j = 0;
55436 swig_cast_info *cast = swig_module.cast_initial[i];
55437 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55438 while (cast->type) {
55439 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55440 cast++;
55441 ++j;
55442 }
55443 printf("---- Total casts: %d\n",j);
55444 }
55445 printf("**** SWIG_InitializeModule: Cast List ******\n");
55446 #endif
55447 }
55448
55449 /* This function will propagate the clientdata field of type to
55450 * any new swig_type_info structures that have been added into the list
55451 * of equivalent types. It is like calling
55452 * SWIG_TypeClientData(type, clientdata) a second time.
55453 */
55454 SWIGRUNTIME void
55455 SWIG_PropagateClientData(void) {
55456 size_t i;
55457 swig_cast_info *equiv;
55458 static int init_run = 0;
55459
55460 if (init_run) return;
55461 init_run = 1;
55462
55463 for (i = 0; i < swig_module.size; i++) {
55464 if (swig_module.types[i]->clientdata) {
55465 equiv = swig_module.types[i]->cast;
55466 while (equiv) {
55467 if (!equiv->converter) {
55468 if (equiv->type && !equiv->type->clientdata)
55469 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55470 }
55471 equiv = equiv->next;
55472 }
55473 }
55474 }
55475 }
55476
55477 #ifdef __cplusplus
55478 #if 0
55479 {
55480 /* c-mode */
55481 #endif
55482 }
55483 #endif
55484
55485
55486
55487 #ifdef __cplusplus
55488 extern "C" {
55489 #endif
55490
55491 /* Python-specific SWIG API */
55492 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55493 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55494 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55495
55496 /* -----------------------------------------------------------------------------
55497 * global variable support code.
55498 * ----------------------------------------------------------------------------- */
55499
55500 typedef struct swig_globalvar {
55501 char *name; /* Name of global variable */
55502 PyObject *(*get_attr)(void); /* Return the current value */
55503 int (*set_attr)(PyObject *); /* Set the value */
55504 struct swig_globalvar *next;
55505 } swig_globalvar;
55506
55507 typedef struct swig_varlinkobject {
55508 PyObject_HEAD
55509 swig_globalvar *vars;
55510 } swig_varlinkobject;
55511
55512 SWIGINTERN PyObject *
55513 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55514 return PyString_FromString("<Swig global variables>");
55515 }
55516
55517 SWIGINTERN PyObject *
55518 swig_varlink_str(swig_varlinkobject *v) {
55519 PyObject *str = PyString_FromString("(");
55520 swig_globalvar *var;
55521 for (var = v->vars; var; var=var->next) {
55522 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55523 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55524 }
55525 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55526 return str;
55527 }
55528
55529 SWIGINTERN int
55530 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55531 PyObject *str = swig_varlink_str(v);
55532 fprintf(fp,"Swig global variables ");
55533 fprintf(fp,"%s\n", PyString_AsString(str));
55534 Py_DECREF(str);
55535 return 0;
55536 }
55537
55538 SWIGINTERN void
55539 swig_varlink_dealloc(swig_varlinkobject *v) {
55540 swig_globalvar *var = v->vars;
55541 while (var) {
55542 swig_globalvar *n = var->next;
55543 free(var->name);
55544 free(var);
55545 var = n;
55546 }
55547 }
55548
55549 SWIGINTERN PyObject *
55550 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55551 PyObject *res = NULL;
55552 swig_globalvar *var = v->vars;
55553 while (var) {
55554 if (strcmp(var->name,n) == 0) {
55555 res = (*var->get_attr)();
55556 break;
55557 }
55558 var = var->next;
55559 }
55560 if (res == NULL && !PyErr_Occurred()) {
55561 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55562 }
55563 return res;
55564 }
55565
55566 SWIGINTERN int
55567 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55568 int res = 1;
55569 swig_globalvar *var = v->vars;
55570 while (var) {
55571 if (strcmp(var->name,n) == 0) {
55572 res = (*var->set_attr)(p);
55573 break;
55574 }
55575 var = var->next;
55576 }
55577 if (res == 1 && !PyErr_Occurred()) {
55578 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55579 }
55580 return res;
55581 }
55582
55583 SWIGINTERN PyTypeObject*
55584 swig_varlink_type(void) {
55585 static char varlink__doc__[] = "Swig var link object";
55586 static PyTypeObject varlink_type;
55587 static int type_init = 0;
55588 if (!type_init) {
55589 const PyTypeObject tmp
55590 = {
55591 PyObject_HEAD_INIT(NULL)
55592 0, /* Number of items in variable part (ob_size) */
55593 (char *)"swigvarlink", /* Type name (tp_name) */
55594 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55595 0, /* Itemsize (tp_itemsize) */
55596 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55597 (printfunc) swig_varlink_print, /* Print (tp_print) */
55598 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55599 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55600 0, /* tp_compare */
55601 (reprfunc) swig_varlink_repr, /* tp_repr */
55602 0, /* tp_as_number */
55603 0, /* tp_as_sequence */
55604 0, /* tp_as_mapping */
55605 0, /* tp_hash */
55606 0, /* tp_call */
55607 (reprfunc)swig_varlink_str, /* tp_str */
55608 0, /* tp_getattro */
55609 0, /* tp_setattro */
55610 0, /* tp_as_buffer */
55611 0, /* tp_flags */
55612 varlink__doc__, /* tp_doc */
55613 0, /* tp_traverse */
55614 0, /* tp_clear */
55615 0, /* tp_richcompare */
55616 0, /* tp_weaklistoffset */
55617 #if PY_VERSION_HEX >= 0x02020000
55618 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55619 #endif
55620 #if PY_VERSION_HEX >= 0x02030000
55621 0, /* tp_del */
55622 #endif
55623 #ifdef COUNT_ALLOCS
55624 0,0,0,0 /* tp_alloc -> tp_next */
55625 #endif
55626 };
55627 varlink_type = tmp;
55628 varlink_type.ob_type = &PyType_Type;
55629 type_init = 1;
55630 }
55631 return &varlink_type;
55632 }
55633
55634 /* Create a variable linking object for use later */
55635 SWIGINTERN PyObject *
55636 SWIG_Python_newvarlink(void) {
55637 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55638 if (result) {
55639 result->vars = 0;
55640 }
55641 return ((PyObject*) result);
55642 }
55643
55644 SWIGINTERN void
55645 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55646 swig_varlinkobject *v = (swig_varlinkobject *) p;
55647 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55648 if (gv) {
55649 size_t size = strlen(name)+1;
55650 gv->name = (char *)malloc(size);
55651 if (gv->name) {
55652 strncpy(gv->name,name,size);
55653 gv->get_attr = get_attr;
55654 gv->set_attr = set_attr;
55655 gv->next = v->vars;
55656 }
55657 }
55658 v->vars = gv;
55659 }
55660
55661 SWIGINTERN PyObject *
55662 SWIG_globals() {
55663 static PyObject *_SWIG_globals = 0;
55664 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55665 return _SWIG_globals;
55666 }
55667
55668 /* -----------------------------------------------------------------------------
55669 * constants/methods manipulation
55670 * ----------------------------------------------------------------------------- */
55671
55672 /* Install Constants */
55673 SWIGINTERN void
55674 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55675 PyObject *obj = 0;
55676 size_t i;
55677 for (i = 0; constants[i].type; ++i) {
55678 switch(constants[i].type) {
55679 case SWIG_PY_POINTER:
55680 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55681 break;
55682 case SWIG_PY_BINARY:
55683 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55684 break;
55685 default:
55686 obj = 0;
55687 break;
55688 }
55689 if (obj) {
55690 PyDict_SetItemString(d, constants[i].name, obj);
55691 Py_DECREF(obj);
55692 }
55693 }
55694 }
55695
55696 /* -----------------------------------------------------------------------------*/
55697 /* Fix SwigMethods to carry the callback ptrs when needed */
55698 /* -----------------------------------------------------------------------------*/
55699
55700 SWIGINTERN void
55701 SWIG_Python_FixMethods(PyMethodDef *methods,
55702 swig_const_info *const_table,
55703 swig_type_info **types,
55704 swig_type_info **types_initial) {
55705 size_t i;
55706 for (i = 0; methods[i].ml_name; ++i) {
55707 const char *c = methods[i].ml_doc;
55708 if (c && (c = strstr(c, "swig_ptr: "))) {
55709 int j;
55710 swig_const_info *ci = 0;
55711 const char *name = c + 10;
55712 for (j = 0; const_table[j].type; ++j) {
55713 if (strncmp(const_table[j].name, name,
55714 strlen(const_table[j].name)) == 0) {
55715 ci = &(const_table[j]);
55716 break;
55717 }
55718 }
55719 if (ci) {
55720 size_t shift = (ci->ptype) - types;
55721 swig_type_info *ty = types_initial[shift];
55722 size_t ldoc = (c - methods[i].ml_doc);
55723 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55724 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55725 if (ndoc) {
55726 char *buff = ndoc;
55727 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55728 if (ptr) {
55729 strncpy(buff, methods[i].ml_doc, ldoc);
55730 buff += ldoc;
55731 strncpy(buff, "swig_ptr: ", 10);
55732 buff += 10;
55733 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55734 methods[i].ml_doc = ndoc;
55735 }
55736 }
55737 }
55738 }
55739 }
55740 }
55741
55742 #ifdef __cplusplus
55743 }
55744 #endif
55745
55746 /* -----------------------------------------------------------------------------*
55747 * Partial Init method
55748 * -----------------------------------------------------------------------------*/
55749
55750 #ifdef __cplusplus
55751 extern "C"
55752 #endif
55753 SWIGEXPORT void SWIG_init(void) {
55754 PyObject *m, *d;
55755
55756 /* Fix SwigMethods to carry the callback ptrs when needed */
55757 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55758
55759 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55760 d = PyModule_GetDict(m);
55761
55762 SWIG_InitializeModule(0);
55763 SWIG_InstallConstants(d,swig_const_table);
55764
55765
55766
55767 #ifndef wxPyUSE_EXPORT
55768 // Make our API structure a CObject so other modules can import it
55769 // from this module.
55770 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55771 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55772 Py_XDECREF(cobj);
55773 #endif
55774
55775 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55776 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55777 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55778 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55779 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55780 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55781 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55782 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55783 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55784 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55785 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55786 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55787 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55788 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55789 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55790 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55791 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55792 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55793 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55794 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55795 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55796 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55797 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55798 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55799 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55800 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55801 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55802 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55803 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55804 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55805 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55806 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55807 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55808 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55809 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55810 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55811 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55812 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55813 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55814 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55815 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55816 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55817 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55818 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55819 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55820 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55821 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55822 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55823 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55824 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55825 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55826 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55827 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55828 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55829 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55830 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55831 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55832 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55833 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55834 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55835 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55836 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55837 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55838 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55839 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55840 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55841 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55842 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55843 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55844 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55845 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55846 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55847 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55848 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55849 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55850 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55851 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55852 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55853 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55854 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55855 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55856 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55857 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55858 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55859 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55860 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55861 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55862 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55863 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55864 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55865 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55866 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55867 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55868 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55869 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55870 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55871 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55872 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55873 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55874 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55875 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55876 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55877 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55878 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55879 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55880 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55881 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55882 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55883 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55884 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55885 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55886 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55887 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55888 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55889 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55890 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55891 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55892 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55893 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55894 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55895 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55896 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55897 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55898 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55899 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55900 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55901 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55902 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55903 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55904 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55905 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55906 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55907 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55908 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55909 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55910 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55911 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55912 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55913 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55914 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55915 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55916 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55917 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55918 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55919 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55920 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55921 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55922 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55923 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55924 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55925 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55926 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55927 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55928 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55929 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55930 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55931 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55932 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55933 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55934 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55935 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55936 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55937 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55938 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55939 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55940 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55941 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55942 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55943 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55944 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55945 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55946 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55947 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55948 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55949 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55950 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55951 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55952 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55953 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55954 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55955 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55956 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55957 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55958 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55959 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55960 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55961 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55962 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55963 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55964 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55965 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55966 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55967 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55968 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55969 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55970 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55971 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55972 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55973 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55974 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55975 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55976 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55977 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55978 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55979 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55980 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55981 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55982 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55983 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55984 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55985 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55986 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55987 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55988 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55989 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55990 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55991 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55992 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55993 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55994 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55995 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55996 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55997 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55998 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55999 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56000 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56001 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56002 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56003 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56004 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56005 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56006 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56007 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56008 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56009 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56010 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56011 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56012 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56013 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56014 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56015 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56016 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56017 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56018 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56019 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56020 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56021 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56022 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56023 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56024 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56025 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56026 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56027 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56028 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56029 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56030 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56031 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56032 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56033 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56034 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56035 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56036 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56037 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56038 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56039 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56040 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56041 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56042 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56043 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56044 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56045 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56046 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56047 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56048 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56049 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56050 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56051 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56052 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56053 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56054 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56055 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56056 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56057 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56058 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56059 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56060 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56061 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56062 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56063 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56064 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56065 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56066 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56067 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56068 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56069 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56070 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56071 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56072 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56073 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56074 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56075 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56076 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56077 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56078 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56079 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56080 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56081 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56082 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56083 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56084 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56085 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56086 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56087 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56088 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56089 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56090 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56091 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56092 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56093 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56094 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56095 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56096 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56097 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56098 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56099 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56100 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56101 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56102 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56103 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56104 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56105 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56106 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56107 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56108 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56109 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56110 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56111 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56112 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56113 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56114 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56115 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56116 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56117 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56118 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56119 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56120 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56121 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56122 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56123 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56124 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56125 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56126 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56127 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56128 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56129 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56130 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56131 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56132 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56133 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56134 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56135 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56136 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56137 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56138 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56139 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56140 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56141 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56142 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56143 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56144 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56145 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56146 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56147 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56148 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56149 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56150 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56151 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56152 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56153 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56154 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56155 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56156 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56157 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56158 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56159 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56160 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56161 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56162 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56163 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56164 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56165 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56166 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56167 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56168 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56169 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56170 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56171 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56172 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56173 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56174 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56175 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56176 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56177 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56178 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56179 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56180 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56181 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56182 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56183 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56184 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56185 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56186 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56187 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56188 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56189 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56190 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56191 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56192 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56193 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56194 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56195 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56196 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56197 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56198 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56199 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56200 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56201 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56202 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56203 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56204 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56205 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56206 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56207 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56208 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56209 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56210 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56211 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56212 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56213 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56214 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56215 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56216 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56217 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56218 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56219 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56220 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56221 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56222 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56223 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56224 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56225 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56226 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56227 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56228 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56229 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56230 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56231 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56232 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56233 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56234 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56235 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56236 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56237 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56238 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56239 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56240 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56241 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56242 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56243 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56244 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56245 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56246 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56247 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56248 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56249 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56250 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56251 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56252 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56253 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56254 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56255 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56256 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56257 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56258 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56259 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56260 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56261 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56262 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56263 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56264 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56265 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56266 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56267 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56268 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56269 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56270 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56271 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56272 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56273 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56274 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56275 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56276 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56277 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56278 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56279 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56280 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56281 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56282 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56283 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56284 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56285 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56286 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56287 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56288 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56289 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56290 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56291 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56292 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56293 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56294 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56295 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56296 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56297 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56298 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56299 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56300 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56301 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56302 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56303 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56304 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56305 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56306 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56307 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56308 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56309 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56310 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56311 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56312 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56313 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56314 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56315 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56316 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56317 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56318 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56319 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56320 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56321 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56322 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56323 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56324 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56325 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56326 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56327 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56328 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56329 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56330 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56331 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56332 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56333 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56334 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56335 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56336 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56337 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56338 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56339 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56340 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56341 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56342 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56343 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56344 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56345 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56346 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56347 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56348 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56349 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56350 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56351 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56352 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56353 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56354 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56355 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56356 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56357 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56358 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56359 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56360 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56361 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56362 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56363 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56364 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56365 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56366 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56367 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56368 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56369 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56370 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56371 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56372 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56373 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56374 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56375 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56376 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56377 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56378 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56379 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56380 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56381 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56382 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56383 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56384 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56385 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56386 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56387 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56388 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56389 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56390 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56391 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56392 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56393 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56394 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56395 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56396 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56397 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56398 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56399 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56400 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56401 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56402 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56403 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56404 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56405 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56406 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56407 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56408 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56409 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56410 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56411 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56412 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56413 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56414 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56415 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56416 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56417 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56418 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56419 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56420 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56421 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56422 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56423 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56424 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56425 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56426 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56427 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56428 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56429 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56430 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56431 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56432 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56433 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56434 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56435 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56436 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56437 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56438
56439 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56440
56441
56442 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56443
56444 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56445 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56446 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56447 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56448 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56449 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56450 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56451 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56452 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56453 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56454 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56455 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56456 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56457 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56458 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56459 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56460 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56461 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56462 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56463 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56464 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56465 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56466 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56467 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56468 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56469 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56470 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56471 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56472 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56473 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56474 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56475 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56476 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56477 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56478 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56479 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56480 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56481 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56482 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56483 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56484 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56485 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56486 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56487 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56488 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56489 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56490 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56491 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56492 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56493 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56494 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56495 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56496 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56497 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56498 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56499 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56500 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56501 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56502 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56503 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56504 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56505 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56506 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56507 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56508 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56509 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56510 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56511 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56512 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56513 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56514 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56515 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56516 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56517 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56518 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56519 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56520 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56521 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56522 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56523 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56524 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56525 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56526 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56527 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56528 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56529 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56530 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56531 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56532 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56533 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56534 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56535 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56536 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56537 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56538 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56539 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56540 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56541 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56542 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56543 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56544 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56545 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56546 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56547 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56548 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56549 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56550 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56551 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56552 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56553 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56554 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56555 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56556 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56557 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56558 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56559 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56560 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56561 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56562 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56563 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56564 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56565 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56566 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56567 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56568 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56569 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56570 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56571 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56572 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56573 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56574 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56575 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56576 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56577 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56578 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56579 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56580 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56581 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56582 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56583 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56584 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56585 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56586 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56587 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56588 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56589 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56590 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56591 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56592 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56593 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56594 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56595 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56596 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56597 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56598 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56599 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56600 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56601 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56602 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56603 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56604 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56605 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56606 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56607 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56608 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56609 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56610 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56611 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56612 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56613 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56614 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56615 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56616 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56617 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56618 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56619 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56620 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56621 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56622 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56623 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56624 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56625 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56626 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56627 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56628 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56629 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56630 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56631 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56632 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56633 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56634 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56635 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56636 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56637 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56638 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56639 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56640 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56641 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56642 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56643 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56644 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56645 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56646 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56647 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56648 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56649 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56650
56651 // Initialize threading, some globals and such
56652 __wxPyPreStart(d);
56653
56654
56655 // Although these are defined in __version__ they need to be here too so
56656 // that an assert can be done to ensure that the wxPython and the wxWindows
56657 // versions match.
56658 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56659 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56660 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56661
56662 }
56663
wxWidgets (Impactor)