]> git.saurik.com Git - wxWidgets.git/blame - wxPython/src/mac/_core_wrap.cpp
bitwise vs. logical operator
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
CommitLineData
d55e5bfc
RD
1/* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
1bd55598 3 * Version 1.3.29
d55e5bfc
RD
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
1bd55598 12#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
d55e5bfc
RD
13
14#ifdef __cplusplus
15template<class T> class SwigValueWrapper {
16 T *tt;
17public:
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; }
25private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
36ed4f51 27};
d55e5bfc
RD
28#endif
29
1bd55598 30/* -----------------------------------------------------------------------------
32fe5131
RD
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
1bd55598 33 * ----------------------------------------------------------------------------- */
d55e5bfc 34
32fe5131
RD
35/* template workaround for compilers that cannot correctly implement the C++ standard */
36#ifndef SWIGTEMPLATEDISAMBIGUATOR
1bd55598
RD
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
36ed4f51 46#endif
d55e5bfc 47
32fe5131
RD
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
1bd55598
RD
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__))
32fe5131
RD
67# else
68# define SWIGUNUSED
69# endif
70#endif
71
1bd55598
RD
72#ifndef SWIGUNUSEDPARM
73# ifdef __cplusplus
74# define SWIGUNUSEDPARM(p)
75# else
76# define SWIGUNUSEDPARM(p) p SWIGUNUSED
77# endif
78#endif
79
32fe5131
RD
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
1bd55598
RD
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
32fe5131
RD
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
1bd55598
RD
105# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106# define SWIGEXPORT __attribute__ ((visibility("default")))
107# else
108# define SWIGEXPORT
109# endif
32fe5131
RD
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
1bd55598
RD
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
32fe5131 126
d55e5bfc 127
1bd55598 128/* Python.h has to appear first */
36ed4f51 129#include <Python.h>
d55e5bfc 130
1bd55598 131/* -----------------------------------------------------------------------------
36ed4f51 132 * swigrun.swg
d55e5bfc 133 *
1bd55598
RD
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
d55e5bfc 137
36ed4f51
RD
138/* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
32fe5131 140#define SWIG_RUNTIME_VERSION "2"
d55e5bfc 141
36ed4f51
RD
142/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143#ifdef SWIG_TYPE_TABLE
32fe5131
RD
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)
d55e5bfc 147#else
32fe5131 148# define SWIG_TYPE_TABLE_NAME
36ed4f51
RD
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*/
32fe5131 159
36ed4f51 160#ifndef SWIGRUNTIME
32fe5131 161# define SWIGRUNTIME SWIGINTERN
36ed4f51 162#endif
32fe5131 163
36ed4f51 164#ifndef SWIGRUNTIMEINLINE
32fe5131 165# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
d55e5bfc
RD
166#endif
167
1bd55598
RD
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)
295SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297}
298SWIGINTERNINLINE 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
32fe5131
RD
309#include <string.h>
310
d55e5bfc
RD
311#ifdef __cplusplus
312extern "C" {
313#endif
314
315typedef void *(*swig_converter_func)(void *);
316typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
32fe5131 318/* Structure to store inforomation on one type */
d55e5bfc 319typedef struct swig_type_info {
32fe5131
RD
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 */
1bd55598 325 int owndata; /* flag if the structure owns the clientdata */
d55e5bfc
RD
326} swig_type_info;
327
32fe5131
RD
328/* Structure to store a type and conversion function used for casting */
329typedef 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.*/
339typedef 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
36ed4f51
RD
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*/
355SWIGRUNTIME int
356SWIG_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;
1bd55598 361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
36ed4f51
RD
362 }
363 return (l1 - f1) - (l2 - f2);
364}
365
366/*
367 Check type equivalence in a name list like <name1>|<name2>|...
32fe5131 368 Return 0 if not equal, 1 if equal
36ed4f51
RD
369*/
370SWIGRUNTIME int
371SWIG_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 }
32fe5131 379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
36ed4f51
RD
380 if (*ne) ++ne;
381 }
382 return equiv;
383}
384
385/*
32fe5131
RD
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
36ed4f51 388*/
32fe5131
RD
389SWIGRUNTIME int
390SWIG_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;
36ed4f51 397 }
32fe5131
RD
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
36ed4f51 400 }
32fe5131 401 return equiv;
36ed4f51
RD
402}
403
32fe5131
RD
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
36ed4f51
RD
427/*
428 Check the typename
429*/
32fe5131 430SWIGRUNTIME swig_cast_info *
36ed4f51 431SWIG_TypeCheck(const char *c, swig_type_info *ty) {
32fe5131
RD
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 */
436SWIGRUNTIME swig_cast_info *
437SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
36ed4f51 439}
d55e5bfc 440
36ed4f51
RD
441/*
442 Cast a pointer up an inheritance hierarchy
443*/
444SWIGRUNTIMEINLINE void *
32fe5131 445SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
36ed4f51
RD
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447}
448
449/*
450 Dynamic pointer casting. Down an inheritance hierarchy
451*/
452SWIGRUNTIME swig_type_info *
453SWIG_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*/
466SWIGRUNTIMEINLINE const char *
467SWIG_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*/
475SWIGRUNTIME const char *
476SWIG_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. */
1bd55598 481 if (!type) return NULL;
36ed4f51
RD
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
36ed4f51
RD
493/*
494 Set the clientdata field for a type
495*/
496SWIGRUNTIME void
32fe5131
RD
497SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
36ed4f51
RD
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
32fe5131
RD
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
36ed4f51 507 }
32fe5131
RD
508 }
509 cast = cast->next;
510 }
511}
1bd55598
RD
512SWIGRUNTIME void
513SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516}
517
32fe5131
RD
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*/
526SWIGRUNTIME swig_type_info *
527SWIG_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);
36ed4f51 556 }
32fe5131
RD
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*/
571SWIGRUNTIME swig_type_info *
572SWIG_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);
36ed4f51 591 }
32fe5131
RD
592
593 /* neither found a match */
594 return 0;
36ed4f51
RD
595}
596
597/*
598 Pack binary data into a string
599*/
600SWIGRUNTIME char *
601SWIG_PackData(char *c, void *ptr, size_t sz) {
32fe5131
RD
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
36ed4f51 605 for (; u != eu; ++u) {
32fe5131 606 register unsigned char uu = *u;
36ed4f51
RD
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*/
616SWIGRUNTIME const char *
617SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
32fe5131 619 register const unsigned char *eu = u + sz;
36ed4f51 620 for (; u != eu; ++u) {
32fe5131 621 register char d = *(c++);
1bd55598 622 register unsigned char uu;
36ed4f51
RD
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
36ed4f51
RD
641/*
642 Pack 'void *' into a string buffer.
643*/
644SWIGRUNTIME char *
645SWIG_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
655SWIGRUNTIME const char *
656SWIG_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
668SWIGRUNTIME char *
669SWIG_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
683SWIGRUNTIME const char *
684SWIG_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}
d55e5bfc
RD
695
696#ifdef __cplusplus
697}
698#endif
699
1bd55598
RD
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
36ed4f51 714
1bd55598
RD
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
736static PyObject *
737PyString_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
790static
791PyObject *PyBool_FromLong(long ok)
792{
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796}
d55e5bfc
RD
797#endif
798
1bd55598 799
36ed4f51 800/* -----------------------------------------------------------------------------
1bd55598 801 * error manipulation
36ed4f51
RD
802 * ----------------------------------------------------------------------------- */
803
1bd55598
RD
804SWIGRUNTIME PyObject*
805SWIG_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}
36ed4f51 846
1bd55598
RD
847
848SWIGRUNTIME void
849SWIG_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
36ed4f51
RD
935#endif
936
1bd55598
RD
937/* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
36ed4f51 940
1bd55598
RD
941#ifdef __cplusplus
942extern "C" {
943#if 0
944} /* cc-mode */
945#endif
946#endif
36ed4f51
RD
947
948/* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952/* Constant Types */
d55e5bfc
RD
953#define SWIG_PY_POINTER 4
954#define SWIG_PY_BINARY 5
955
d55e5bfc
RD
956/* Constant information structure */
957typedef struct swig_const_info {
1bd55598
RD
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
d55e5bfc
RD
964} swig_const_info;
965
36ed4f51 966#ifdef __cplusplus
1bd55598
RD
967#if 0
968{ /* cc-mode */
969#endif
36ed4f51
RD
970}
971#endif
972
973
1bd55598
RD
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 *
36ed4f51
RD
978 * pyrun.swg
979 *
1bd55598
RD
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
36ed4f51 983 *
1bd55598 984 * ----------------------------------------------------------------------------- */
36ed4f51 985
d55e5bfc 986/* Common SWIG API */
d55e5bfc 987
4f89b6b7
RD
988#if PY_VERSION_HEX < 0x02050000
989typedef int Py_ssize_t;
990#endif
991
1bd55598
RD
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
d55e5bfc 1000
1bd55598
RD
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)
d55e5bfc 1004
1bd55598
RD
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)
d55e5bfc 1008
1bd55598
RD
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)
d55e5bfc 1012
1bd55598
RD
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)
32fe5131 1016
36ed4f51 1017
1bd55598 1018/* Runtime API */
36ed4f51 1019
1bd55598
RD
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)
32fe5131 1023
1bd55598
RD
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
32fe5131 1029
36ed4f51 1030
1bd55598 1031/* Runtime API implementation */
36ed4f51 1032
1bd55598 1033/* Error manipulation */
36ed4f51 1034
1bd55598
RD
1035SWIGINTERN void
1036SWIG_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;
36ed4f51
RD
1041}
1042
1bd55598
RD
1043SWIGINTERN void
1044SWIG_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;
36ed4f51
RD
1048}
1049
1bd55598 1050#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
32fe5131 1051
1bd55598 1052/* Set a constant value */
36ed4f51 1053
1bd55598
RD
1054SWIGINTERN void
1055SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
36ed4f51
RD
1058}
1059
1bd55598 1060/* Append a value to the result obj */
36ed4f51 1061
1bd55598
RD
1062SWIGINTERN PyObject*
1063SWIG_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;
36ed4f51 1088 } else {
1bd55598
RD
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);
36ed4f51 1100 }
1bd55598
RD
1101 return result;
1102#endif
36ed4f51
RD
1103}
1104
1bd55598 1105/* Unpack the argument tuple */
36ed4f51 1106
1bd55598
RD
1107SWIGINTERN int
1108SWIG_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
1173extern "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
1193SWIGRUNTIMEINLINE PyObject *
1194_SWIG_Py_None(void)
1195{
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199}
1200SWIGRUNTIME PyObject *
1201SWIG_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
1210SWIGRUNTIMEINLINE PyObject *
1211SWIG_Py_Void(void)
1212{
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216}
1217
1218/* PySwigClientData */
1219
1220typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227} PySwigClientData;
1228
1229SWIGRUNTIMEINLINE int
1230SWIG_Python_CheckImplicit(swig_type_info *ty)
1231{
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234}
1235
1236SWIGRUNTIMEINLINE PyObject *
1237SWIG_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
1244SWIGRUNTIME PySwigClientData *
1245PySwigClientData_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
1297SWIGRUNTIME void
1298PySwigClientData_Del(PySwigClientData* data)
1299{
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303}
1304
1305/* =============== PySwigObject =====================*/
1306
1307typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313} PySwigObject;
1314
1315SWIGRUNTIME PyObject *
1316PySwigObject_long(PySwigObject *v)
1317{
1318 return PyLong_FromVoidPtr(v->ptr);
1319}
1320
1321SWIGRUNTIME PyObject *
1322PySwigObject_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
1339SWIGRUNTIME PyObject *
1340PySwigObject_oct(PySwigObject *v)
1341{
1342 return PySwigObject_format("%o",v);
1343}
1344
1345SWIGRUNTIME PyObject *
1346PySwigObject_hex(PySwigObject *v)
1347{
1348 return PySwigObject_format("%x",v);
1349}
1350
1351SWIGRUNTIME PyObject *
1352#ifdef METH_NOARGS
1353PySwigObject_repr(PySwigObject *v)
1354#else
1355PySwigObject_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
1373SWIGRUNTIME int
1374PySwigObject_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
1390SWIGRUNTIME PyObject *
1391PySwigObject_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
1398SWIGRUNTIME int
1399PySwigObject_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
1406SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408SWIGRUNTIME PyTypeObject*
1409PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412}
1413
1414SWIGRUNTIMEINLINE int
1415PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418}
1419
1420SWIGRUNTIME PyObject *
1421PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423SWIGRUNTIME void
1424PySwigObject_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
1457SWIGRUNTIME PyObject*
1458PySwigObject_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
1474SWIGRUNTIME PyObject*
1475#ifdef METH_NOARGS
1476PySwigObject_next(PyObject* v)
1477#else
1478PySwigObject_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
1490SWIGINTERN PyObject*
1491#ifdef METH_NOARGS
1492PySwigObject_disown(PyObject *v)
1493#else
1494PySwigObject_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
1502SWIGINTERN PyObject*
1503#ifdef METH_NOARGS
1504PySwigObject_acquire(PyObject *v)
1505#else
1506PySwigObject_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
1514SWIGINTERN PyObject*
1515PySwigObject_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
1550static PyMethodDef
1551swigobject_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
1561static PyMethodDef
1562swigobject_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
1574SWIGINTERN PyObject *
1575PySwigObject_getattr(PySwigObject *sobj,char *name)
1576{
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578}
1579#endif
1580
1581SWIGRUNTIME 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*/
36ed4f51
RD
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*/
32fe5131 1609#if PY_VERSION_HEX >= 0x02020000
36ed4f51 1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
32fe5131
RD
1611#elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
36ed4f51
RD
1613#endif
1614 };
1615
1bd55598 1616 static PyTypeObject pyswigobject_type;
32fe5131 1617 static int type_init = 0;
36ed4f51 1618 if (!type_init) {
1bd55598
RD
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 */
36ed4f51 1632#endif
1bd55598
RD
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 */
36ed4f51 1651#if PY_VERSION_HEX >= 0x02020000
1bd55598
RD
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 */
36ed4f51
RD
1672#endif
1673#if PY_VERSION_HEX >= 0x02030000
1bd55598 1674 0, /* tp_del */
36ed4f51
RD
1675#endif
1676#ifdef COUNT_ALLOCS
1bd55598 1677 0,0,0,0 /* tp_alloc -> tp_next */
36ed4f51 1678#endif
1bd55598 1679 };
32fe5131 1680 pyswigobject_type = tmp;
1bd55598 1681 pyswigobject_type.ob_type = &PyType_Type;
36ed4f51
RD
1682 type_init = 1;
1683 }
32fe5131 1684 return &pyswigobject_type;
36ed4f51
RD
1685}
1686
1687SWIGRUNTIME PyObject *
1bd55598 1688PySwigObject_New(void *ptr, swig_type_info *ty, int own)
36ed4f51 1689{
1bd55598
RD
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;
32fe5131 1696 }
1bd55598 1697 return (PyObject *)sobj;
36ed4f51
RD
1698}
1699
1700/* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1bd55598 1707 swig_type_info *ty;
36ed4f51
RD
1708 size_t size;
1709} PySwigPacked;
1710
1711SWIGRUNTIME int
1bd55598 1712PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
36ed4f51
RD
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 }
1bd55598 1720 fputs(v->ty->name,fp);
36ed4f51
RD
1721 fputs(">", fp);
1722 return 0;
1723}
1724
1725SWIGRUNTIME PyObject *
1726PySwigPacked_repr(PySwigPacked *v)
1727{
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1bd55598 1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
36ed4f51 1731 } else {
1bd55598 1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
36ed4f51
RD
1733 }
1734}
1735
1736SWIGRUNTIME PyObject *
1737PySwigPacked_str(PySwigPacked *v)
1738{
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1bd55598 1741 return PyString_FromFormat("%s%s", result, v->ty->name);
36ed4f51 1742 } else {
1bd55598 1743 return PyString_FromString(v->ty->name);
36ed4f51
RD
1744 }
1745}
1746
1747SWIGRUNTIME int
1748PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749{
1bd55598
RD
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);
d55e5bfc 1754}
36ed4f51 1755
1bd55598 1756SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
36ed4f51
RD
1757
1758SWIGRUNTIME PyTypeObject*
32fe5131 1759PySwigPacked_type(void) {
1bd55598
RD
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762}
1763
1764SWIGRUNTIMEINLINE int
1765PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768}
1769
1770SWIGRUNTIME void
1771PySwigPacked_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
1780SWIGRUNTIME 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 */
d55e5bfc 1835#endif
36ed4f51 1836#if PY_VERSION_HEX >= 0x02030000
1bd55598 1837 0, /* tp_del */
36ed4f51
RD
1838#endif
1839#ifdef COUNT_ALLOCS
1bd55598 1840 0,0,0,0 /* tp_alloc -> tp_next */
36ed4f51 1841#endif
1bd55598 1842 };
32fe5131 1843 pyswigpacked_type = tmp;
1bd55598 1844 pyswigpacked_type.ob_type = &PyType_Type;
36ed4f51
RD
1845 type_init = 1;
1846 }
32fe5131 1847 return &pyswigpacked_type;
36ed4f51
RD
1848}
1849
1850SWIGRUNTIME PyObject *
1bd55598 1851PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
36ed4f51 1852{
1bd55598
RD
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
36ed4f51 1855 void *pack = malloc(size);
32fe5131
RD
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1bd55598
RD
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
32fe5131 1864 }
36ed4f51 1865 }
1bd55598 1866 return (PyObject *) sobj;
36ed4f51
RD
1867}
1868
1bd55598 1869SWIGRUNTIME swig_type_info *
36ed4f51
RD
1870PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871{
1bd55598
RD
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 }
36ed4f51
RD
1880}
1881
36ed4f51 1882/* -----------------------------------------------------------------------------
1bd55598 1883 * pointers/data manipulation
36ed4f51
RD
1884 * ----------------------------------------------------------------------------- */
1885
1bd55598
RD
1886SWIGRUNTIMEINLINE PyObject *
1887_SWIG_This(void)
1888{
1889 return PyString_FromString("this");
1890}
36ed4f51 1891
1bd55598
RD
1892SWIGRUNTIME PyObject *
1893SWIG_This(void)
1894{
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897}
36ed4f51 1898
1bd55598 1899/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
36ed4f51 1900
1bd55598
RD
1901SWIGRUNTIME PySwigObject *
1902SWIG_Python_GetSwigThis(PyObject *pyobj)
36ed4f51 1903{
1bd55598
RD
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);
36ed4f51 1926 } else {
1bd55598
RD
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
36ed4f51 1929 }
36ed4f51 1930 }
1bd55598
RD
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;
36ed4f51
RD
1947 }
1948}
1949
1bd55598
RD
1950/* Acquire a pointer value */
1951
1952SWIGRUNTIME int
1953SWIG_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 }
36ed4f51 1961 }
1bd55598 1962 return 0;
36ed4f51
RD
1963}
1964
1bd55598
RD
1965/* Convert a pointer value */
1966
36ed4f51 1967SWIGRUNTIME int
1bd55598
RD
1968SWIG_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 }
36ed4f51 1992 } else {
1bd55598
RD
1993 if (ptr) *ptr = vptr;
1994 break;
36ed4f51 1995 }
36ed4f51 1996 }
1bd55598
RD
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 }
36ed4f51
RD
2042 }
2043}
2044
1bd55598
RD
2045/* Convert a function ptr value */
2046
36ed4f51 2047SWIGRUNTIME int
1bd55598
RD
2048SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
36ed4f51 2051 } else {
1bd55598
RD
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
4f89b6b7 2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1bd55598
RD
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;
36ed4f51
RD
2069 }
2070}
2071
1bd55598 2072/* Convert a packed value value */
36ed4f51 2073
36ed4f51 2074SWIGRUNTIME int
1bd55598
RD
2075SWIG_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 }
36ed4f51 2084 }
1bd55598
RD
2085 return SWIG_OK;
2086}
36ed4f51 2087
1bd55598
RD
2088/* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
36ed4f51 2091
1bd55598
RD
2092/*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095*/
36ed4f51 2096
1bd55598
RD
2097SWIGRUNTIME PyObject*
2098SWIG_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 }
36ed4f51 2115 }
1bd55598
RD
2116#else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119#endif
36ed4f51 2120 }
1bd55598
RD
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);
36ed4f51 2126 }
1bd55598
RD
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;
36ed4f51 2140 }
1bd55598
RD
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;
36ed4f51 2147 }
1bd55598
RD
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
36ed4f51
RD
2158}
2159
1bd55598
RD
2160SWIGRUNTIME void
2161SWIG_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 }
36ed4f51 2175#endif
1bd55598
RD
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179}
36ed4f51 2180
1bd55598
RD
2181
2182SWIGINTERN PyObject *
2183SWIG_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]);
36ed4f51 2191 } else {
1bd55598 2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
36ed4f51 2193 }
1bd55598 2194 return SWIG_Py_Void();
36ed4f51 2195 }
1bd55598
RD
2196}
2197
2198/* Create a new pointer object */
36ed4f51 2199
36ed4f51 2200SWIGRUNTIME PyObject *
1bd55598 2201SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
36ed4f51 2202 if (!ptr) {
1bd55598
RD
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;
36ed4f51 2213 }
36ed4f51 2214 }
1bd55598 2215 return robj;
36ed4f51 2216 }
36ed4f51
RD
2217}
2218
1bd55598
RD
2219/* Create a new packed object */
2220
2221SWIGRUNTIMEINLINE PyObject *
36ed4f51 2222SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1bd55598 2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
36ed4f51
RD
2224}
2225
2226/* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230#ifdef SWIG_LINK_RUNTIME
2231void *SWIG_ReturnGlobalTypeList(void *);
2232#endif
2233
32fe5131
RD
2234SWIGRUNTIME swig_module_info *
2235SWIG_Python_GetModule(void) {
36ed4f51
RD
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 }
36ed4f51 2248#endif
32fe5131
RD
2249 }
2250 return (swig_module_info *) type_pointer;
36ed4f51
RD
2251}
2252
32fe5131
RD
2253#if PY_MAJOR_VERSION < 2
2254/* PyModule_AddObject function was introduced in Python 2.0. The following function
1bd55598 2255 is copied out of Python/modsupport.c in python version 2.3.4 */
32fe5131
RD
2256SWIGINTERN int
2257PyModule_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");
1bd55598 2263 return SWIG_ERROR;
32fe5131
RD
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
1bd55598 2268 return SWIG_ERROR;
32fe5131
RD
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));
1bd55598 2276 return SWIG_ERROR;
32fe5131
RD
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
1bd55598 2279 return SWIG_ERROR;
32fe5131 2280 Py_DECREF(o);
1bd55598 2281 return SWIG_OK;
36ed4f51 2282}
32fe5131 2283#endif
36ed4f51 2284
1bd55598
RD
2285SWIGRUNTIME void
2286SWIG_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
32fe5131
RD
2301SWIGRUNTIME void
2302SWIG_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);
1bd55598 2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
32fe5131
RD
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
1bd55598
RD
2310 } else {
2311 Py_XDECREF(pointer);
32fe5131
RD
2312 }
2313}
36ed4f51 2314
1bd55598
RD
2315/* The python cached type query */
2316SWIGRUNTIME PyObject *
2317SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
36ed4f51 2320}
1bd55598
RD
2321
2322SWIGRUNTIME swig_type_info *
2323SWIG_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
2351SWIGRUNTIME int
2352SWIG_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
2376SWIGRUNTIME int
2377SWIG_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
2389SWIGRUNTIMEINLINE const char *
2390PySwigObject_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
2397SWIGRUNTIME void
2398SWIG_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 */
2435SWIGRUNTIME void *
2436SWIG_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) -------- */
d55e5bfc 2465
32fe5131
RD
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]
2131d850
RD
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]
70d7cb34
RD
2499#define SWIGTYPE_p_wxDouble swig_types[33]
2500#define SWIGTYPE_p_wxDropFilesEvent swig_types[34]
2501#define SWIGTYPE_p_wxDuplexMode swig_types[35]
2502#define SWIGTYPE_p_wxEraseEvent swig_types[36]
2503#define SWIGTYPE_p_wxEvent swig_types[37]
2504#define SWIGTYPE_p_wxEventLoop swig_types[38]
2505#define SWIGTYPE_p_wxEventLoopActivator swig_types[39]
2506#define SWIGTYPE_p_wxEvtHandler swig_types[40]
2507#define SWIGTYPE_p_wxFSFile swig_types[41]
2508#define SWIGTYPE_p_wxFileSystem swig_types[42]
2509#define SWIGTYPE_p_wxFileSystemHandler swig_types[43]
2510#define SWIGTYPE_p_wxFlexGridSizer swig_types[44]
2511#define SWIGTYPE_p_wxFocusEvent swig_types[45]
2512#define SWIGTYPE_p_wxFont swig_types[46]
2513#define SWIGTYPE_p_wxFrame swig_types[47]
2514#define SWIGTYPE_p_wxGBPosition swig_types[48]
2515#define SWIGTYPE_p_wxGBSizerItem swig_types[49]
2516#define SWIGTYPE_p_wxGBSpan swig_types[50]
2517#define SWIGTYPE_p_wxGIFHandler swig_types[51]
2518#define SWIGTYPE_p_wxGridBagSizer swig_types[52]
2519#define SWIGTYPE_p_wxGridSizer swig_types[53]
2520#define SWIGTYPE_p_wxHelpEvent__Origin swig_types[54]
2521#define SWIGTYPE_p_wxICOHandler swig_types[55]
2522#define SWIGTYPE_p_wxIconizeEvent swig_types[56]
2523#define SWIGTYPE_p_wxIdleEvent swig_types[57]
2524#define SWIGTYPE_p_wxImage swig_types[58]
2525#define SWIGTYPE_p_wxImageHandler swig_types[59]
2526#define SWIGTYPE_p_wxImageHistogram swig_types[60]
2527#define SWIGTYPE_p_wxImage_HSVValue swig_types[61]
2528#define SWIGTYPE_p_wxImage_RGBValue swig_types[62]
2529#define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[63]
2530#define SWIGTYPE_p_wxInitDialogEvent swig_types[64]
2531#define SWIGTYPE_p_wxInputStream swig_types[65]
2532#define SWIGTYPE_p_wxInternetFSHandler swig_types[66]
2533#define SWIGTYPE_p_wxItemContainer swig_types[67]
2534#define SWIGTYPE_p_wxJPEGHandler swig_types[68]
2535#define SWIGTYPE_p_wxKeyEvent swig_types[69]
2536#define SWIGTYPE_p_wxLayoutConstraints swig_types[70]
2537#define SWIGTYPE_p_wxMaximizeEvent swig_types[71]
2538#define SWIGTYPE_p_wxMemoryFSHandler swig_types[72]
2539#define SWIGTYPE_p_wxMenu swig_types[73]
2540#define SWIGTYPE_p_wxMenuBar swig_types[74]
2541#define SWIGTYPE_p_wxMenuBarBase swig_types[75]
2542#define SWIGTYPE_p_wxMenuEvent swig_types[76]
2543#define SWIGTYPE_p_wxMenuItem swig_types[77]
2544#define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[78]
2545#define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[79]
2546#define SWIGTYPE_p_wxMouseEvent swig_types[80]
2547#define SWIGTYPE_p_wxMoveEvent swig_types[81]
2548#define SWIGTYPE_p_wxNavigationKeyEvent swig_types[82]
2549#define SWIGTYPE_p_wxNcPaintEvent swig_types[83]
2550#define SWIGTYPE_p_wxNotifyEvent swig_types[84]
2551#define SWIGTYPE_p_wxObject swig_types[85]
2552#define SWIGTYPE_p_wxOutputStream swig_types[86]
2553#define SWIGTYPE_p_wxPCXHandler swig_types[87]
2554#define SWIGTYPE_p_wxPNGHandler swig_types[88]
2555#define SWIGTYPE_p_wxPNMHandler swig_types[89]
2556#define SWIGTYPE_p_wxPaintEvent swig_types[90]
2557#define SWIGTYPE_p_wxPaletteChangedEvent swig_types[91]
2558#define SWIGTYPE_p_wxPaperSize swig_types[92]
2559#define SWIGTYPE_p_wxPoint swig_types[93]
2560#define SWIGTYPE_p_wxPoint2D swig_types[94]
2561#define SWIGTYPE_p_wxPropagateOnce swig_types[95]
2562#define SWIGTYPE_p_wxPropagationDisabler swig_types[96]
2563#define SWIGTYPE_p_wxPyApp swig_types[97]
2564#define SWIGTYPE_p_wxPyCommandEvent swig_types[98]
2565#define SWIGTYPE_p_wxPyDropTarget swig_types[99]
2566#define SWIGTYPE_p_wxPyEvent swig_types[100]
2567#define SWIGTYPE_p_wxPyFileSystemHandler swig_types[101]
2568#define SWIGTYPE_p_wxPyImageHandler swig_types[102]
2569#define SWIGTYPE_p_wxPyInputStream swig_types[103]
2570#define SWIGTYPE_p_wxPySizer swig_types[104]
2571#define SWIGTYPE_p_wxPyValidator swig_types[105]
2572#define SWIGTYPE_p_wxQuantize swig_types[106]
2573#define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[107]
2574#define SWIGTYPE_p_wxRealPoint swig_types[108]
2575#define SWIGTYPE_p_wxRect swig_types[109]
2576#define SWIGTYPE_p_wxRect2D swig_types[110]
2577#define SWIGTYPE_p_wxRegion swig_types[111]
2578#define SWIGTYPE_p_wxScrollEvent swig_types[112]
2579#define SWIGTYPE_p_wxScrollWinEvent swig_types[113]
2580#define SWIGTYPE_p_wxSetCursorEvent swig_types[114]
2581#define SWIGTYPE_p_wxShowEvent swig_types[115]
2582#define SWIGTYPE_p_wxSize swig_types[116]
2583#define SWIGTYPE_p_wxSizeEvent swig_types[117]
2584#define SWIGTYPE_p_wxSizer swig_types[118]
2585#define SWIGTYPE_p_wxSizerItem swig_types[119]
2586#define SWIGTYPE_p_wxStaticBox swig_types[120]
2587#define SWIGTYPE_p_wxStaticBoxSizer swig_types[121]
2588#define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[122]
2589#define SWIGTYPE_p_wxSysColourChangedEvent swig_types[123]
580080c5
RD
2590#define SWIGTYPE_p_wxTGAHandler swig_types[124]
2591#define SWIGTYPE_p_wxTIFFHandler swig_types[125]
2592#define SWIGTYPE_p_wxToolTip swig_types[126]
2593#define SWIGTYPE_p_wxUpdateUIEvent swig_types[127]
2594#define SWIGTYPE_p_wxValidator swig_types[128]
2595#define SWIGTYPE_p_wxVisualAttributes swig_types[129]
2596#define SWIGTYPE_p_wxWindow swig_types[130]
2597#define SWIGTYPE_p_wxWindowCreateEvent swig_types[131]
2598#define SWIGTYPE_p_wxWindowDestroyEvent swig_types[132]
2599#define SWIGTYPE_p_wxXPMHandler swig_types[133]
2600#define SWIGTYPE_p_wxZipFSHandler swig_types[134]
2601static swig_type_info *swig_types[136];
2602static swig_module_info swig_module = {swig_types, 135, 0, 0, 0, 0};
32fe5131
RD
2603#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2604#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
d55e5bfc
RD
2605
2606/* -------- TYPES TABLE (END) -------- */
2607
1bd55598
RD
2608#if (PY_VERSION_HEX <= 0x02000000)
2609# if !defined(SWIG_PYTHON_CLASSIC)
2610# error "This python version requires to use swig with the '-classic' option"
2611# endif
2612#endif
2613#if (PY_VERSION_HEX <= 0x02020000)
2614# error "This python version requires to use swig with the '-nomodern' option"
2615#endif
2616#if (PY_VERSION_HEX <= 0x02020000)
2617# error "This python version requires to use swig with the '-nomodernargs' option"
2618#endif
2619#ifndef METH_O
2620# error "This python version requires to use swig with the '-nofastunpack' option"
2621#endif
d55e5bfc
RD
2622
2623/*-----------------------------------------------
5b5c9bc7 2624 @(target):= _core_.so
d55e5bfc 2625 ------------------------------------------------*/
5b5c9bc7 2626#define SWIG_init init_core_
d55e5bfc 2627
5b5c9bc7 2628#define SWIG_name "_core_"
d55e5bfc 2629
1bd55598
RD
2630#define SWIGVERSION 0x010329
2631
2632
2633#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2634#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2635
2636
2637#include <stdexcept>
2638
2639
2640namespace swig {
2641 class PyObject_ptr {
2642 protected:
2643 PyObject *_obj;
2644
2645 public:
2646 PyObject_ptr() :_obj(0)
2647 {
2648 }
2649
2650 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2651 {
2652 Py_XINCREF(_obj);
2653 }
2654
2655 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2656 {
2657 if (initial_ref) Py_XINCREF(_obj);
2658 }
2659
2660 PyObject_ptr & operator=(const PyObject_ptr& item)
2661 {
2662 Py_XINCREF(item._obj);
2663 Py_XDECREF(_obj);
2664 _obj = item._obj;
2665 return *this;
2666 }
2667
2668 ~PyObject_ptr()
2669 {
2670 Py_XDECREF(_obj);
2671 }
2672
2673 operator PyObject *() const
2674 {
2675 return _obj;
2676 }
2677
2678 PyObject *operator->() const
2679 {
2680 return _obj;
2681 }
2682 };
2683}
2684
2685
2686namespace swig {
2687 struct PyObject_var : PyObject_ptr {
2688 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2689
2690 PyObject_var & operator = (PyObject* obj)
2691 {
2692 Py_XDECREF(_obj);
2693 _obj = obj;
2694 return *this;
2695 }
2696 };
2697}
2698
2699
d55e5bfc
RD
2700#include "wx/wxPython/wxPython_int.h"
2701#include "wx/wxPython/pyclasses.h"
2131d850 2702#include "wx/wxPython/twoitem.h"
d55e5bfc
RD
2703
2704
2705#ifndef wxPyUSE_EXPORT
2706// Helper functions for dealing with SWIG objects and such. These are
2707// located here so they know about the SWIG types and functions declared
2708// in the wrapper code.
2709
2710#include <wx/hashmap.h>
b1fcee84 2711WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
d55e5bfc
RD
2712
2713
2714// Maintains a hashmap of className to swig_type_info pointers. Given the
2715// name of a class either looks up the type info in the cache, or scans the
2716// SWIG tables for it.
2717extern PyObject* wxPyPtrTypeMap;
2718static
2719swig_type_info* wxPyFindSwigType(const wxChar* className) {
2720
2721 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2722
2723 if (typeInfoCache == NULL)
2724 typeInfoCache = new wxPyTypeInfoHashMap;
2725
2726 wxString name(className);
2727 swig_type_info* swigType = (*typeInfoCache)[name];
2728
2729 if (! swigType) {
2730 // it wasn't in the cache, so look it up from SWIG
2731 name.Append(wxT(" *"));
36ed4f51 2732 swigType = SWIG_TypeQuery(name.mb_str());
d55e5bfc
RD
2733
2734 // if it still wasn't found, try looking for a mapped name
2735 if (!swigType) {
2736 PyObject* item;
2737 name = className;
2738
2739 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2740 (char*)(const char*)name.mbc_str())) != NULL) {
2741 name = wxString(PyString_AsString(item), *wxConvCurrent);
2742 name.Append(wxT(" *"));
36ed4f51 2743 swigType = SWIG_TypeQuery(name.mb_str());
d55e5bfc
RD
2744 }
2745 }
2746 if (swigType) {
2747 // and add it to the map if found
2748 (*typeInfoCache)[className] = swigType;
2749 }
2750 }
2751 return swigType;
2752}
2753
2754
2755// Check if a class name is a type known to SWIG
2756bool wxPyCheckSwigType(const wxChar* className) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 return swigType != NULL;
2760}
2761
2762
2763// Given a pointer to a C++ object and a class name, construct a Python proxy
2764// object for it.
2765PyObject* wxPyConstructObject(void* ptr,
2766 const wxChar* className,
2767 int setThisOwn) {
2768
2769 swig_type_info* swigType = wxPyFindSwigType(className);
2770 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2771
2772 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2773}
2774
2775
2776// Extract a pointer to the wrapped C++ object from a Python proxy object.
2777// Ensures that the proxy object is of the specified (or derived) type. If
2778// not able to perform the conversion then a Python exception is set and the
2779// error should be handled properly in the caller. Returns True on success.
2780bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2781 const wxChar* className) {
2782
2783 swig_type_info* swigType = wxPyFindSwigType(className);
b411df4a 2784 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
d55e5bfc
RD
2785
2786 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2787}
2788
2789
b1fcee84 2790
d55e5bfc
RD
2791// Make a SWIGified pointer object suitable for a .this attribute
2792PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2793
2794 PyObject* robj = NULL;
2795
2796 swig_type_info* swigType = wxPyFindSwigType(className);
7e08d4ef 2797 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
d55e5bfc 2798
1bd55598 2799 robj = PySwigObject_New(ptr, swigType, 0);
d55e5bfc
RD
2800 return robj;
2801}
2802
b1fcee84 2803
943e8dfd
RD
2804// Python's PyInstance_Check does not return True for instances of new-style
2805// classes. This should get close enough for both new and old classes but I
2806// should re-evaluate the need for doing instance checks...
2807bool wxPyInstance_Check(PyObject* obj) {
2808 return PyObject_HasAttrString(obj, "__class__") != 0;
2809}
2810
2811
943e8dfd
RD
2812// This one checks if the object is an instance of a SWIG proxy class (it has
2813// a .this attribute, and the .this attribute is a PySwigObject.)
2814bool wxPySwigInstance_Check(PyObject* obj) {
2815 static PyObject* this_str = NULL;
2816 if (this_str == NULL)
2817 this_str = PyString_FromString("this");
2818
2819 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2820 if (this_attr) {
2821 bool retval = (PySwigObject_Check(this_attr) != 0);
2822 Py_DECREF(this_attr);
2823 return retval;
2824 }
2825
2826 PyErr_Clear();
2827 return false;
2828}
d55e5bfc
RD
2829
2830
2831// Export a C API in a struct. Other modules will be able to load this from
2832// the wx._core_ module and will then have safe access to these functions,
2833// even if they are located in another shared library.
2834static wxPyCoreAPI API = {
2835
d55e5bfc
RD
2836 wxPyCheckSwigType,
2837 wxPyConstructObject,
2838 wxPyConvertSwigPtr,
2839 wxPyMakeSwigPtr,
2840
2841 wxPyBeginAllowThreads,
2842 wxPyEndAllowThreads,
2843 wxPyBeginBlockThreads,
2844 wxPyEndBlockThreads,
2845
2846 wxPy_ConvertList,
2847
2848 wxString_in_helper,
2849 Py2wxString,
2850 wx2PyString,
2851
2852 byte_LIST_helper,
2853 int_LIST_helper,
2854 long_LIST_helper,
2855 string_LIST_helper,
2856 wxPoint_LIST_helper,
2857 wxBitmap_LIST_helper,
2858 wxString_LIST_helper,
2859 wxAcceleratorEntry_LIST_helper,
2860
2861 wxSize_helper,
2862 wxPoint_helper,
2863 wxRealPoint_helper,
2864 wxRect_helper,
2865 wxColour_helper,
2866 wxPoint2D_helper,
2867
2868 wxPySimple_typecheck,
2869 wxColour_typecheck,
2870
2871 wxPyCBH_setCallbackInfo,
2872 wxPyCBH_findCallback,
2873 wxPyCBH_callCallback,
2874 wxPyCBH_callCallbackObj,
2875 wxPyCBH_delete,
2876
2877 wxPyMake_wxObject,
2878 wxPyMake_wxSizer,
2879 wxPyPtrTypeMap_Add,
2880 wxPy2int_seq_helper,
2881 wxPy4int_seq_helper,
2882 wxArrayString2PyList_helper,
2883 wxArrayInt2PyList_helper,
2884
2885 wxPyClientData_dtor,
2886 wxPyUserData_dtor,
2887 wxPyOORClientData_dtor,
2888
2889 wxPyCBInputStream_create,
e2950dbb
RD
2890 wxPyCBInputStream_copy,
2891
d55e5bfc 2892 wxPyInstance_Check,
0439c23b
RD
2893 wxPySwigInstance_Check,
2894
b39fe951 2895 wxPyCheckForApp,
d55e5bfc 2896
b39fe951 2897 wxArrayDouble2PyList_helper,
70d7cb34
RD
2898 wxPoint2D_LIST_helper,
2899 wxRect2D_helper,
2900
d55e5bfc
RD
2901};
2902
2903#endif
2904
2905
fef4c27a
RD
2906#if !WXWIN_COMPATIBILITY_2_4
2907 #define wxHIDE_READONLY 0
2908#endif
2909
2910
1bd55598
RD
2911 #define SWIG_From_long PyInt_FromLong
2912
2913
2914SWIGINTERNINLINE PyObject *
2915SWIG_From_int (int value)
2916{
2917 return SWIG_From_long (value);
2918}
36ed4f51 2919
d55e5bfc 2920 static const wxString wxPyEmptyString(wxEmptyString);
1bd55598 2921SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
d55e5bfc
RD
2922 return self->GetClassInfo()->GetClassName();
2923 }
1bd55598 2924SWIGINTERN void wxObject_Destroy(wxObject *self){
d55e5bfc
RD
2925 delete self;
2926 }
2927
2928#ifndef __WXMAC__
2929#define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2930#endif
2931
2932
2933#include <limits.h>
1bd55598
RD
2934#ifndef LLONG_MIN
2935# define LLONG_MIN LONG_LONG_MIN
2936#endif
2937#ifndef LLONG_MAX
2938# define LLONG_MAX LONG_LONG_MAX
2939#endif
2940#ifndef ULLONG_MAX
2941# define ULLONG_MAX ULONG_LONG_MAX
2942#endif
d55e5bfc
RD
2943
2944
36ed4f51 2945SWIGINTERN int
1bd55598 2946SWIG_AsVal_long (PyObject* obj, long* val)
d55e5bfc 2947{
c370783e
RD
2948 if (PyNumber_Check(obj)) {
2949 if (val) *val = PyInt_AsLong(obj);
1bd55598 2950 return SWIG_OK;
c370783e 2951 }
1bd55598 2952 return SWIG_TypeError;
d55e5bfc
RD
2953}
2954
2955
36ed4f51 2956SWIGINTERN int
1bd55598
RD
2957SWIG_AsVal_int (PyObject * obj, int *val)
2958{
c370783e 2959 long v;
1bd55598
RD
2960 int res = SWIG_AsVal_long (obj, &v);
2961 if (SWIG_IsOK(res)) {
2962 if ((v < INT_MIN || v > INT_MAX)) {
2963 return SWIG_OverflowError;
c370783e 2964 } else {
1bd55598 2965 if (val) *val = static_cast< int >(v);
c370783e 2966 }
1bd55598
RD
2967 }
2968 return res;
d55e5bfc
RD
2969}
2970
e9d6f3a4
RD
2971SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2972 wxSize temp, *obj = &temp;
2973 if ( other == Py_None ) return false;
2974 if ( ! wxSize_helper(other, &obj) ) {
2975 PyErr_Clear();
2976 return false;
2977 }
2978 return self->operator==(*obj);
2979 }
2980SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2981 wxSize temp, *obj = &temp;
2982 if ( other == Py_None ) return true;
2983 if ( ! wxSize_helper(other, &obj)) {
2984 PyErr_Clear();
2985 return true;
2986 }
2987 return self->operator!=(*obj);
2988 }
1eeb270e
RD
2989
2990#include <float.h>
2991
d55e5bfc 2992
36ed4f51 2993SWIGINTERN int
1bd55598 2994SWIG_AsVal_double (PyObject *obj, double* val)
d55e5bfc 2995{
c370783e
RD
2996 if (PyNumber_Check(obj)) {
2997 if (val) *val = PyFloat_AsDouble(obj);
1bd55598 2998 return SWIG_OK;
c370783e 2999 }
1bd55598 3000 return SWIG_TypeError;
d55e5bfc
RD
3001}
3002
36ed4f51 3003
1eeb270e
RD
3004SWIGINTERN int
3005SWIG_AsVal_float (PyObject * obj, float *val)
3006{
3007 double v;
3008 int res = SWIG_AsVal_double (obj, &v);
3009 if (SWIG_IsOK(res)) {
3010 if ((v < -FLT_MAX || v > FLT_MAX)) {
3011 return SWIG_OverflowError;
3012 } else {
3013 if (val) *val = static_cast< float >(v);
3014 }
3015 }
3016 return res;
3017}
3018
3019SWIGINTERN PyObject *wxSize_Get(wxSize *self){
70d7cb34 3020 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
1eeb270e
RD
3021 PyObject* tup = PyTuple_New(2);
3022 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3023 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
70d7cb34 3024 //wxPyEndBlockThreads(blocked);
1eeb270e
RD
3025 return tup;
3026 }
3027
1bd55598 3028 #define SWIG_From_double PyFloat_FromDouble
36ed4f51 3029
e9d6f3a4
RD
3030SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3031 wxRealPoint temp, *obj = &temp;
3032 if ( other == Py_None ) return false;
3033 if ( ! wxRealPoint_helper(other, &obj) ) {
3034 PyErr_Clear();
3035 return false;
3036 }
3037 return self->operator==(*obj);
3038 }
3039SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3040 wxRealPoint temp, *obj = &temp;
3041 if ( other == Py_None ) return true;
3042 if ( ! wxRealPoint_helper(other, &obj)) {
3043 PyErr_Clear();
3044 return true;
3045 }
3046 return self->operator!=(*obj);
3047 }
1bd55598 3048SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
d55e5bfc
RD
3049 self->x = x;
3050 self->y = y;
3051 }
1bd55598 3052SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
70d7cb34 3053 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
d55e5bfc
RD
3054 PyObject* tup = PyTuple_New(2);
3055 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3056 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
70d7cb34 3057 //PyEndBlockThreads(blocked);
d55e5bfc
RD
3058 return tup;
3059 }
e9d6f3a4
RD
3060SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3061 wxPoint temp, *obj = &temp;
3062 if ( other == Py_None ) return false;
3063 if ( ! wxPoint_helper(other, &obj) ) {
3064 PyErr_Clear();
3065 return false;
3066 }
3067 return self->operator==(*obj);
3068 }
3069SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3070 wxPoint temp, *obj = &temp;
3071 if ( other == Py_None ) return true;
3072 if ( ! wxPoint_helper(other, &obj)) {
3073 PyErr_Clear();
3074 return true;
3075 }
3076 return self->operator!=(*obj);
3077 }
1bd55598 3078SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
d55e5bfc
RD
3079 self->x = x;
3080 self->y = y;
3081 }
1bd55598 3082SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
70d7cb34 3083 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
d55e5bfc
RD
3084 PyObject* tup = PyTuple_New(2);
3085 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3086 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
70d7cb34 3087 //wxPyEndBlockThreads(blocked);
d55e5bfc
RD
3088 return tup;
3089 }
e9d6f3a4
RD
3090SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3091 wxRect temp, *obj = &temp;
3092 if ( other == Py_None ) return false;
3093 if ( ! wxRect_helper(other, &obj) ) {
3094 PyErr_Clear();
3095 return false;
3096 }
3097 return self->operator==(*obj);
3098 }
3099SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3100 wxRect temp, *obj = &temp;
3101 if ( other == Py_None ) return true;
3102 if ( ! wxRect_helper(other, &obj)) {
3103 PyErr_Clear();
3104 return true;
3105 }
3106 return self->operator!=(*obj);
3107 }
1bd55598 3108SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
d55e5bfc
RD
3109 self->x = x;
3110 self->y = y;
3111 self->width = width;
3112 self->height = height;
3113 }
1bd55598 3114SWIGINTERN PyObject *wxRect_Get(wxRect *self){
70d7cb34 3115 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
d55e5bfc
RD
3116 PyObject* tup = PyTuple_New(4);
3117 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3118 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3119 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3120 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
70d7cb34 3121 //wxPyEndBlockThreads(blocked);
d55e5bfc
RD
3122 return tup;
3123 }
3124
3125 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3126 wxRegion reg1(*r1);
3127 wxRegion reg2(*r2);
3128 wxRect dest(0,0,0,0);
3129 PyObject* obj;
3130
3131 reg1.Intersect(reg2);
3132 dest = reg1.GetBox();
3133
3134 if (dest != wxRect(0,0,0,0)) {
70d7cb34 3135 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
d55e5bfc 3136 wxRect* newRect = new wxRect(dest);
b411df4a 3137 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
70d7cb34 3138 //wxPyEndBlockThreads(blocked);
d55e5bfc
RD
3139 return obj;
3140 }
3141 Py_INCREF(Py_None);
3142 return Py_None;
3143 }
3144
e9d6f3a4
RD
3145SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3146 wxPoint2D temp, *obj = &temp;
3147 if ( other == Py_None ) return false;
3148 if ( ! wxPoint2D_helper(other, &obj) ) {
3149 PyErr_Clear();
3150 return false;
3151 }
3152 return self->operator==(*obj);
3153 }
3154SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3155 wxPoint2D temp, *obj = &temp;
3156 if ( other == Py_None ) return true;
3157 if ( ! wxPoint2D_helper(other, &obj)) {
3158 PyErr_Clear();
3159 return true;
3160 }
3161 return self->operator!=(*obj);
3162 }
1bd55598 3163SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
d55e5bfc
RD
3164 self->m_x = x;
3165 self->m_y = y;
3166 }
1bd55598 3167SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
70d7cb34 3168 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
d55e5bfc
RD
3169 PyObject* tup = PyTuple_New(2);
3170 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3171 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
70d7cb34
RD
3172 //wxPyEndBlockThreads(blocked);
3173 return tup;
3174 }
3175SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3176 wxRect2D temp, *obj = &temp;
3177 if ( other == Py_None ) return false;
3178 if ( ! wxRect2D_helper(other, &obj) ) {
3179 PyErr_Clear();
3180 return false;
3181 }
3182 return self->operator==(*obj);
3183 }
3184SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3185 wxRect2D temp, *obj = &temp;
3186 if ( other == Py_None ) return true;
3187 if ( ! wxRect2D_helper(other, &obj)) {
3188 PyErr_Clear();
3189 return true;
3190 }
3191 return self->operator!=(*obj);
3192 }
3193SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3194 self->m_x = x;
3195 self->m_y = y;
3196 self->m_width = width;
3197 self->m_height = height;
3198 }
3199SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3200 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3201 PyObject* tup = PyTuple_New(4);
3202 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3203 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3204 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3205 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3206 //wxPyEndBlockThreads(blocked);
d55e5bfc
RD
3207 return tup;
3208 }
3209
3210#include "wx/wxPython/pyistream.h"
3211
1bd55598 3212SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
d55e5bfc
RD
3213 wxInputStream* wxis = wxPyCBInputStream::create(p);
3214 if (wxis)
3215 return new wxPyInputStream(wxis);
3216 else
3217 return NULL;
3218 }
3219
1bd55598
RD
3220SWIGINTERN swig_type_info*
3221SWIG_pchar_descriptor()
3222{
3223 static int init = 0;
3224 static swig_type_info* info = 0;
3225 if (!init) {
3226 info = SWIG_TypeQuery("_p_char");
3227 init = 1;
3228 }
3229 return info;
d55e5bfc
RD
3230}
3231
3232
1bd55598
RD
3233SWIGINTERNINLINE PyObject *
3234SWIG_FromCharPtrAndSize(const char* carray, size_t size)
d55e5bfc 3235{
1bd55598
RD
3236 if (carray) {
3237 if (size > INT_MAX) {
3238 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3239 return pchar_descriptor ?
3240 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3241 } else {
3242 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3243 }
3244 } else {
3245 return SWIG_Py_Void();
3246 }
d55e5bfc
RD
3247}
3248
3249
1bd55598
RD
3250SWIGINTERNINLINE PyObject *
3251SWIG_From_char (char c)
3252{
3253 return SWIG_FromCharPtrAndSize(&c,1);
3254}
3255
3256
3257SWIGINTERNINLINE PyObject*
3258SWIG_From_unsigned_SS_long (unsigned long value)
3259{
3260 return (value > LONG_MAX) ?
3261 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3262}
3263
3264
3265SWIGINTERNINLINE PyObject *
3266SWIG_From_size_t (size_t value)
3267{
3268 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3269}
3270
3271
3272SWIGINTERN int
3273SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3274{
3275 if (PyString_Check(obj)) {
4f89b6b7 3276 char *cstr; Py_ssize_t len;
1bd55598
RD
3277 PyString_AsStringAndSize(obj, &cstr, &len);
3278 if (cptr) {
3279 if (alloc) {
3280 /*
3281 In python the user should not be able to modify the inner
3282 string representation. To warranty that, if you define
3283 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3284 buffer is always returned.
3285
3286 The default behavior is just to return the pointer value,
3287 so, be careful.
3288 */
3289#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3290 if (*alloc != SWIG_OLDOBJ)
3291#else
3292 if (*alloc == SWIG_NEWOBJ)
3293#endif
3294 {
3295 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3296 *alloc = SWIG_NEWOBJ;
3297 }
3298 else {
3299 *cptr = cstr;
3300 *alloc = SWIG_OLDOBJ;
c370783e 3301 }
1bd55598
RD
3302 } else {
3303 *cptr = PyString_AsString(obj);
3304 }
3305 }
3306 if (psize) *psize = len + 1;
3307 return SWIG_OK;
3308 } else {
3309 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3310 if (pchar_descriptor) {
3311 void* vptr = 0;
3312 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3313 if (cptr) *cptr = (char *) vptr;
3314 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3315 if (alloc) *alloc = SWIG_OLDOBJ;
3316 return SWIG_OK;
c370783e 3317 }
c370783e 3318 }
d55e5bfc 3319 }
1bd55598 3320 return SWIG_TypeError;
d55e5bfc
RD
3321}
3322
3323
36ed4f51 3324SWIGINTERN int
1bd55598 3325SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
d55e5bfc 3326{
1bd55598
RD
3327 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3328 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3329 if (SWIG_IsOK(res)) {
3330 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
c370783e
RD
3331 if (csize <= size) {
3332 if (val) {
1bd55598
RD
3333 if (csize) memcpy(val, cptr, csize*sizeof(char));
3334 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
c370783e 3335 }
1bd55598
RD
3336 if (alloc == SWIG_NEWOBJ) {
3337 delete[] cptr;
3338 res = SWIG_DelNewMask(res);
3339 }
3340 return res;
d55e5bfc 3341 }
1bd55598 3342 if (alloc == SWIG_NEWOBJ) delete[] cptr;
d55e5bfc 3343 }
1bd55598 3344 return SWIG_TypeError;
d55e5bfc
RD
3345}
3346
3347
36ed4f51 3348SWIGINTERN int
1bd55598
RD
3349SWIG_AsVal_char (PyObject * obj, char *val)
3350{
3351 int res = SWIG_AsCharArray(obj, val, 1);
3352 if (!SWIG_IsOK(res)) {
3353 long v;
3354 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3355 if (SWIG_IsOK(res)) {
3356 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3357 if (val) *val = static_cast< char >(v);
3358 } else {
3359 res = SWIG_OverflowError;
3360 }
3361 }
d55e5bfc 3362 }
1bd55598 3363 return res;
d55e5bfc
RD
3364}
3365
1bd55598 3366SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
d55e5bfc
RD
3367 // We use only strings for the streams, not unicode
3368 PyObject* str = PyObject_Str(obj);
3369 if (! str) {
3370 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3371 return;
3372 }
3373 self->Write(PyString_AS_STRING(str),
3374 PyString_GET_SIZE(str));
3375 Py_DECREF(str);
3376 }
3377
3378#include "wx/wxPython/pyistream.h"
3379
3380
3381class wxPyFileSystemHandler : public wxFileSystemHandler
3382{
3383public:
3384 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3385
3386 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3387 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3388 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3389 DEC_PYCALLBACK_STRING__pure(FindNext);
3390
3391 wxString GetProtocol(const wxString& location) {
3392 return wxFileSystemHandler::GetProtocol(location);
3393 }
3394
3395 wxString GetLeftLocation(const wxString& location) {
3396 return wxFileSystemHandler::GetLeftLocation(location);
3397 }
3398
3399 wxString GetAnchor(const wxString& location) {
3400 return wxFileSystemHandler::GetAnchor(location);
3401 }
3402
3403 wxString GetRightLocation(const wxString& location) {
3404 return wxFileSystemHandler::GetRightLocation(location);
3405 }
3406
3407 wxString GetMimeTypeFromExt(const wxString& location) {
3408 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3409 }
3410
3411 PYPRIVATE;
3412};
3413
3414
3415IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3416IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3417IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3418IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3419
3420
36ed4f51 3421SWIGINTERN int
1bd55598 3422SWIG_AsVal_bool (PyObject *obj, bool *val)
d55e5bfc 3423{
c370783e
RD
3424 if (obj == Py_True) {
3425 if (val) *val = true;
1bd55598
RD
3426 return SWIG_OK;
3427 } else if (obj == Py_False) {
c370783e 3428 if (val) *val = false;
1bd55598 3429 return SWIG_OK;
36ed4f51 3430 } else {
1bd55598
RD
3431 long v = 0;
3432 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3433 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3434 return res;
d55e5bfc
RD
3435 }
3436}
3437
1bd55598 3438SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
b411df4a
RD
3439 wxFileName fname = wxFileSystem::URLToFileName(url);
3440 return fname.GetFullPath();
3441 }
d55e5bfc
RD
3442
3443 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3444 wxImage& image,
3445 long type) {
3446 wxMemoryFSHandler::AddFile(filename, image, type);
3447 }
3448
3449 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3450 const wxBitmap& bitmap,
3451 long type) {
3452 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3453 }
3454
3455 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3456 PyObject* data) {
b411df4a
RD
3457 if (! PyString_Check(data)) {
3458 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3459 "Expected string object"));
3460 return;
3461 }
3462
5a446332 3463 wxPyBlock_t blocked = wxPyBeginBlockThreads();
b411df4a
RD
3464 void* ptr = (void*)PyString_AsString(data);
3465 size_t size = PyString_Size(data);
3466 wxPyEndBlockThreads(blocked);
3467
3468 wxMemoryFSHandler::AddFile(filename, ptr, size);
d55e5bfc
RD
3469 }
3470
3471
3472#include "wx/wxPython/pyistream.h"
3473
3474
36ed4f51 3475SWIGINTERN int
1bd55598 3476SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
d55e5bfc 3477{
c370783e
RD
3478 long v = 0;
3479 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1bd55598 3480 return SWIG_TypeError;
d55e5bfc 3481 }
c370783e
RD
3482 else if (val)
3483 *val = (unsigned long)v;
1bd55598 3484 return SWIG_OK;
d55e5bfc
RD
3485}
3486
3487
36ed4f51 3488SWIGINTERN int
1bd55598
RD
3489SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3490{
c370783e 3491 unsigned long v;
1bd55598
RD
3492 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3493 if (SWIG_IsOK(res)) {
3494 if ((v > UCHAR_MAX)) {
3495 return SWIG_OverflowError;
c370783e 3496 } else {
1bd55598 3497 if (val) *val = static_cast< unsigned char >(v);
c370783e 3498 }
1bd55598
RD
3499 }
3500 return res;
c370783e
RD
3501}
3502
3503
1bd55598
RD
3504SWIGINTERNINLINE PyObject *
3505SWIG_From_unsigned_SS_char (unsigned char value)
3506{
3507 return SWIG_From_unsigned_SS_long (value);
f1cbd8fa
RD
3508}
3509
1bd55598 3510SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
f1cbd8fa
RD
3511 wxImageHistogramEntry e = (*self)[key];
3512 return e.value;
3513 }
1bd55598 3514SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
f1cbd8fa
RD
3515 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3516 wxImageHistogramEntry e = (*self)[key];
3517 return e.value;
3518 }
1bd55598 3519SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
f1cbd8fa
RD
3520 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3521 colour.Green(),
3522 colour.Blue());
3523 wxImageHistogramEntry e = (*self)[key];
3524 return e.value;
3525 }
bb2ef2cc 3526
943e8dfd
RD
3527// Pull the nested class out to the top level for SWIG's sake
3528#define wxImage_RGBValue wxImage::RGBValue
3529#define wxImage_HSVValue wxImage::HSVValue
3530
1bd55598 3531SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
bb2ef2cc
RD
3532 if (width > 0 && height > 0)
3533 return new wxImage(width, height, clear);
3534 else
3535 return new wxImage;
d55e5bfc 3536 }
1bd55598 3537SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
bb2ef2cc 3538 return new wxImage(bitmap.ConvertToImage());
03e46024 3539 }
1bd55598 3540SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
bb2ef2cc
RD
3541 if (DATASIZE != width*height*3) {
3542 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3543 return NULL;
3544 }
3545
3546 // Copy the source data so the wxImage can clean it up later
3547 buffer copy = (buffer)malloc(DATASIZE);
3548 if (copy == NULL) {
3549 wxPyBLOCK_THREADS(PyErr_NoMemory());
3550 return NULL;
3551 }
3552 memcpy(copy, data, DATASIZE);
3553 return new wxImage(width, height, copy, false);
03e46024 3554 }
1bd55598 3555SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
bb2ef2cc
RD
3556 if (DATASIZE != width*height*3) {
3557 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3558 return NULL;
3559 }
3560 if (ALPHASIZE != width*height) {
3561 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3562 return NULL;
3563 }
3564
3565 // Copy the source data so the wxImage can clean it up later
3566 buffer dcopy = (buffer)malloc(DATASIZE);
3567 if (dcopy == NULL) {
3568 wxPyBLOCK_THREADS(PyErr_NoMemory());
3569 return NULL;
3570 }
3571 memcpy(dcopy, data, DATASIZE);
03e46024 3572
bb2ef2cc
RD
3573 buffer acopy = (buffer)malloc(ALPHASIZE);
3574 if (acopy == NULL) {
3575 wxPyBLOCK_THREADS(PyErr_NoMemory());
3576 return NULL;
3577 }
3578 memcpy(acopy, alpha, ALPHASIZE);
3579
3580 return new wxImage(width, height, dcopy, acopy, false);
3581 }
1bd55598 3582SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
d55e5bfc
RD
3583 wxSize size(self->GetWidth(), self->GetHeight());
3584 return size;
3585 }
1bd55598 3586SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
bb2ef2cc 3587 buffer data = self->GetData();
d55e5bfc
RD
3588 int len = self->GetWidth() * self->GetHeight() * 3;
3589 PyObject* rv;
3590 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3591 return rv;
3592 }
1bd55598 3593SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
bb2ef2cc
RD
3594 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3595 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3596 return;
3597 }
3598 buffer copy = (buffer)malloc(DATASIZE);
3599 if (copy == NULL) {
3600 wxPyBLOCK_THREADS(PyErr_NoMemory());
3601 return;
3602 }
3603 memcpy(copy, data, DATASIZE);
3604 self->SetData(copy, false);
3605 // wxImage takes ownership of copy...
d55e5bfc 3606 }
1bd55598 3607SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
bb2ef2cc 3608 buffer data = self->GetData();
d55e5bfc
RD
3609 int len = self->GetWidth() * self->GetHeight() * 3;
3610 PyObject* rv;
3611 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3612 return rv;
3613 }
1bd55598 3614SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
bb2ef2cc
RD
3615 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3616 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3617 return;
d55e5bfc 3618 }
bb2ef2cc 3619 self->SetData(data, true);
d55e5bfc 3620 }
1bd55598 3621SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
bb2ef2cc 3622 buffer data = self->GetAlpha();
d55e5bfc
RD
3623 if (! data) {
3624 RETURN_NONE();
3625 } else {
3626 int len = self->GetWidth() * self->GetHeight();
3627 PyObject* rv;
3628 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3629 return rv;
3630 }
3631 }
1bd55598 3632SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
bb2ef2cc
RD
3633 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3634 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3635 return;
d55e5bfc 3636 }
bb2ef2cc
RD
3637 buffer acopy = (buffer)malloc(ALPHASIZE);
3638 if (acopy == NULL) {
3639 wxPyBLOCK_THREADS(PyErr_NoMemory());
3640 return;
3641 }
3642 memcpy(acopy, alpha, ALPHASIZE);
3643 self->SetAlpha(acopy, false);
3644 // wxImage takes ownership of acopy...
d55e5bfc 3645 }
1bd55598 3646SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
bb2ef2cc 3647 buffer data = self->GetAlpha();
d55e5bfc
RD
3648 int len = self->GetWidth() * self->GetHeight();
3649 PyObject* rv;
3650 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3651 return rv;
3652 }
1bd55598 3653SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
bb2ef2cc
RD
3654 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3655 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3656 return;
d55e5bfc 3657 }
bb2ef2cc 3658 self->SetAlpha(alpha, true);
d55e5bfc 3659 }
1bd55598
RD
3660SWIGINTERN PyObject *wxImage_GetHandlers(){
3661 wxList& list = wxImage::GetHandlers();
3662 return wxPy_ConvertList(&list);
3663 }
3664SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
44bf767a 3665 wxBitmap bitmap(*self, depth);
d55e5bfc
RD
3666 return bitmap;
3667 }
1bd55598 3668SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
d55e5bfc
RD
3669 wxImage mono = self->ConvertToMono( red, green, blue );
3670 wxBitmap bitmap( mono, 1 );
3671 return bitmap;
3672 }
fc46b7f3
RD
3673
3674 wxImage* _ImageFromBuffer(int width, int height,
3675 buffer data, int DATASIZE,
3676 buffer alpha=NULL, int ALPHASIZE=0)
3677 {
3678 if (DATASIZE != width*height*3) {
3679 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3680 return NULL;
3681 }
3682 if (alpha != NULL) {
3683 if (ALPHASIZE != width*height) {
3684 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3685 return NULL;
3686 }
3687 return new wxImage(width, height, data, alpha, true);
3688 }
3689 return new wxImage(width, height, data, true);
3690 }
3691
68350608 3692 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
d55e5bfc
RD
3693 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3694 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3695 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3696 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
68350608
RD
3697 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
d55e5bfc 3699 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
24d7cbea 3700 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
68350608
RD
3701 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3702 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3703 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3704 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
7fbf8399
RD
3705 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3706 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
c0de73ae 3707
580080c5
RD
3708#include <wx/imagtga.h>
3709
3710
c0de73ae
RD
3711#include <wx/quantize.h>
3712
1bd55598 3713SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
c0de73ae
RD
3714 return wxQuantize::Quantize(src, dest,
3715 //NULL, // palette
3716 desiredNoColours,
3717 NULL, // eightBitData
3718 flags);
3719 }
1bd55598 3720SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
d55e5bfc
RD
3721 if (PyCallable_Check(func)) {
3722 self->Connect(id, lastId, eventType,
3723 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3724 new wxPyCallback(func));
3725 }
3726 else if (func == Py_None) {
3727 self->Disconnect(id, lastId, eventType,
3728 (wxObjectEventFunction)
3729 &wxPyCallback::EventThunker);
3730 }
3731 else {
3732 wxPyBLOCK_THREADS(
3733 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3734 }
3735 }
1bd55598 3736SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
d55e5bfc
RD
3737 return self->Disconnect(id, lastId, eventType,
3738 (wxObjectEventFunction)
3739 &wxPyCallback::EventThunker);
3740 }
1bd55598 3741SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
d55e5bfc 3742 if (_self && _self != Py_None) {
36ed4f51 3743 self->SetClientObject(new wxPyOORClientData(_self, incref));
d55e5bfc
RD
3744 }
3745 else {
3746 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3747 if (data) {
3748 self->SetClientObject(NULL); // This will delete it too
3749 }
3750 }
3751 }
c370783e 3752
943e8dfd
RD
3753#if ! wxUSE_HOTKEY
3754#define wxEVT_HOTKEY -9999
3755#endif
3756
1bd55598
RD
3757SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3758 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3759 if (data) {
3760 Py_INCREF(data->m_obj);
3761 return data->m_obj;
3762 } else {
3763 Py_INCREF(Py_None);
3764 return Py_None;
3765 }
3766 }
3767SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3768 wxPyClientData* data = new wxPyClientData(clientData);
3769 self->SetClientObject(data);
3770 }
3771SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
d55e5bfc 3772 #if wxUSE_UNICODE
bb4524c4 3773 return self->GetUnicodeKey();
d55e5bfc
RD
3774 #else
3775 return 0;
3776 #endif
3777 }
b850e7f3
RD
3778SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3779 #if wxUSE_UNICODE
3780 self->m_uniChar = uniChar;
3781 #endif
3782 }
d55e5bfc 3783
1bd55598
RD
3784SWIGINTERNINLINE PyObject *
3785SWIG_From_unsigned_SS_int (unsigned int value)
3786{
3787 return SWIG_From_unsigned_SS_long (value);
3788}
d55e5bfc
RD
3789
3790
36ed4f51 3791SWIGINTERN int
1bd55598
RD
3792SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3793{
c370783e 3794 unsigned long v;
1bd55598
RD
3795 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3796 if (SWIG_IsOK(res)) {
3797 if ((v > UINT_MAX)) {
3798 return SWIG_OverflowError;
3799 } else {
3800 if (val) *val = static_cast< unsigned int >(v);
c370783e 3801 }
1bd55598
RD
3802 }
3803 return res;
d55e5bfc
RD
3804}
3805
1bd55598 3806SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
d55e5bfc
RD
3807 self->m_size = size;
3808 }
1bd55598 3809SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
d55e5bfc
RD
3810 int count = self->GetNumberOfFiles();
3811 wxString* files = self->GetFiles();
5ba5649b 3812 wxPyBlock_t blocked = wxPyBeginBlockThreads();
d55e5bfc
RD
3813 PyObject* list = PyList_New(count);
3814
3815 if (!list) {
3816 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
5ba5649b 3817 wxPyEndBlockThreads(blocked);
d55e5bfc
RD
3818 return NULL;
3819 }
3820
3821 for (int i=0; i<count; i++) {
3822 PyList_SetItem(list, i, wx2PyString(files[i]));
3823 }
5ba5649b 3824 wxPyEndBlockThreads(blocked);
d55e5bfc
RD
3825 return list;
3826 }
3827
3828
1bd55598 3829SWIGINTERN wxPyApp *new_wxPyApp(){
d55e5bfc
RD
3830 wxPythonApp = new wxPyApp();
3831 return wxPythonApp;
3832 }
1bd55598 3833SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
33d6fd3b 3834SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
fc46b7f3
RD
3835 return wxPyTestDisplayAvailable();
3836 }
d55e5bfc
RD
3837
3838 void wxApp_CleanUp() {
3839 __wxPyCleanup();
3840 }
3841
3842
a5ee0656 3843 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
d55e5bfc
RD
3844
3845
5cbf236d
RD
3846
3847
1bd55598
RD
3848
3849SWIGINTERNINLINE PyObject *
3850SWIG_FromCharPtr(const char *cptr)
5cbf236d 3851{
1bd55598 3852 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
5cbf236d
RD
3853}
3854
3855
32fe5131 3856#if 0 // #ifdef __WXMAC__
b411df4a
RD
3857
3858// A dummy class that raises an exception if used...
3859class wxEventLoop
3860{
3861public:
3862 wxEventLoop() { wxPyRaiseNotImplemented(); }
3863 int Run() { return 0; }
3864 void Exit(int rc = 0) {}
3865 bool Pending() const { return false; }
3866 bool Dispatch() { return false; }
3867 bool IsRunning() const { return false; }
3868 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3869 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3870};
3871
3872#else
3873
3874#include <wx/evtloop.h>
3875
3876#endif
3877
3878
d55e5bfc
RD
3879
3880 static const wxString wxPyPanelNameStr(wxPanelNameStr);
1bd55598
RD
3881SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3882SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3883SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
d55e5bfc
RD
3884 wxWindowList& list = self->GetChildren();
3885 return wxPy_ConvertList(&list);
3886 }
704eda0c 3887SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
1bd55598 3888SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
d55e5bfc
RD
3889 #if wxUSE_HOTKEY
3890 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3891 #else
b411df4a 3892 return false;
d55e5bfc
RD
3893 #endif
3894 }
1bd55598 3895SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
d55e5bfc
RD
3896
3897
3898
b411df4a 3899 return false;
d55e5bfc
RD
3900
3901 }
1bd55598 3902SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
d55e5bfc
RD
3903 return wxPyGetWinHandle(self);
3904 }
1bd55598 3905SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
629e65c2
RD
3906 self->AssociateHandle((WXWidget)handle);
3907 }
1bd55598 3908SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
d55e5bfc
RD
3909
3910wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3911 return wxWindow::FindWindowById(id, parent);
3912}
3913
3914wxWindow* wxFindWindowByName( const wxString& name,
3915 const wxWindow *parent = NULL ) {
3916 return wxWindow::FindWindowByName(name, parent);
3917}
3918
3919wxWindow* wxFindWindowByLabel( const wxString& label,
3920 const wxWindow *parent = NULL ) {
3921 return wxWindow::FindWindowByLabel(label, parent);
3922}
3923
3924
3925#ifdef __WXMSW__
3926#include <wx/msw/private.h> // to get wxGetWindowId
3927#endif
3928
3929
3930 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3931#ifdef __WXMSW__
3932 WXHWND hWnd = (WXHWND)_hWnd;
3933 long id = wxGetWindowId(hWnd);
3934 wxWindow* win = new wxWindow;
943e8dfd
RD
3935 if (parent)
3936 parent->AddChild(win);
d55e5bfc
RD
3937 win->SetEventHandler(win);
3938 win->SetHWND(hWnd);
3939 win->SetId(id);
3940 win->SubclassWin(hWnd);
3941 win->AdoptAttributesFromHWND();
3942 win->SetupColours();
3943 return win;
3944#else
3945 wxPyRaiseNotImplemented();
3946 return NULL;
3947#endif
3948 }
3949
3950
3215336e
RD
3951 PyObject* GetTopLevelWindows() {
3952 return wxPy_ConvertList(&wxTopLevelWindows);
3953 }
3954
3955
d55e5bfc
RD
3956IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3957IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3958IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3959
3960IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3961
1bd55598
RD
3962
3963SWIGINTERNINLINE int
3964SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3965{
3966 unsigned long v;
3967 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3968 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3969 return res;
3970}
3971
3972SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3973SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
d55e5bfc
RD
3974 wxMenuItemList& list = self->GetMenuItems();
3975 return wxPy_ConvertList(&list);
3976 }
1bd55598
RD
3977SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3978SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3979SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3980SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3981SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3982SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3983SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3984SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3985SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3986SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3987SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3988SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3989SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3990SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3991SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
d55e5bfc 3992 static const wxString wxPyControlNameStr(wxControlNameStr);
1bd55598 3993SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
d55e5bfc
RD
3994 if (clientData) {
3995 wxPyClientData* data = new wxPyClientData(clientData);
3996 return self->Append(item, data);
3997 } else
3998 return self->Append(item);
3999 }
d359a380 4000SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
d55e5bfc
RD
4001 if (clientData) {
4002 wxPyClientData* data = new wxPyClientData(clientData);
4003 return self->Insert(item, pos, data);
4004 } else
4005 return self->Insert(item, pos);
4006 }
d359a380 4007SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
d55e5bfc
RD
4008 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4009 if (data) {
4010 Py_INCREF(data->m_obj);
4011 return data->m_obj;
4012 } else {
4013 Py_INCREF(Py_None);
4014 return Py_None;
4015 }
4016 }
d359a380 4017SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
d55e5bfc
RD
4018 wxPyClientData* data = new wxPyClientData(clientData);
4019 self->SetClientObject(n, data);
4020 }
4021
4022
1bd55598 4023SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
bfddbb17
RD
4024 wxPyUserData* data = NULL;
4025 if ( userData ) {
5a446332 4026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
bfddbb17
RD
4027 data = new wxPyUserData(userData);
4028 wxPyEndBlockThreads(blocked);
4029 }
4030 return new wxSizerItem(window, proportion, flag, border, data);
4031 }
1bd55598 4032SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
bfddbb17
RD
4033 wxPyUserData* data = NULL;
4034 if ( userData ) {
5a446332 4035 wxPyBlock_t blocked = wxPyBeginBlockThreads();
bfddbb17
RD
4036 data = new wxPyUserData(userData);
4037 wxPyEndBlockThreads(blocked);
4038 }
4039 return new wxSizerItem(width, height, proportion, flag, border, data);
4040 }
1bd55598 4041SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
bfddbb17
RD
4042 wxPyUserData* data = NULL;
4043 if ( userData ) {
5a446332 4044 wxPyBlock_t blocked = wxPyBeginBlockThreads();
bfddbb17
RD
4045 data = new wxPyUserData(userData);
4046 wxPyEndBlockThreads(blocked);
4047 }
4048 return new wxSizerItem(sizer, proportion, flag, border, data);
4049 }
d55e5bfc 4050
1bd55598
RD
4051SWIGINTERNINLINE PyObject *
4052SWIG_From_float (float value)
4053{
4054 return SWIG_From_double (value);
d55e5bfc
RD
4055}
4056
1bd55598 4057SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
d55e5bfc
RD
4058 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4059 if (data) {
4060 Py_INCREF(data->m_obj);
4061 return data->m_obj;
4062 } else {
4063 Py_INCREF(Py_None);
4064 return Py_None;
4065 }
4066 }
1bd55598 4067SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
32fe5131
RD
4068 wxPyUserData* data = NULL;
4069 if ( userData ) {
4070 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4071 data = new wxPyUserData(userData);
4072 wxPyEndBlockThreads(blocked);
4073 }
4074 self->SetUserData(data);
4075 }
d55e5bfc
RD
4076
4077// Figure out the type of the sizer item
4078
4079struct wxPySizerItemInfo {
4080 wxPySizerItemInfo()
b411df4a
RD
4081 : window(NULL), sizer(NULL), gotSize(false),
4082 size(wxDefaultSize), gotPos(false), pos(-1)
d55e5bfc 4083 {}
7fbf8399 4084
d55e5bfc
RD
4085 wxWindow* window;
4086 wxSizer* sizer;
4087 bool gotSize;
4088 wxSize size;
4089 bool gotPos;
4090 int pos;
4091};
7fbf8399 4092
d55e5bfc
RD
4093static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4094
4095 wxPySizerItemInfo info;
4096 wxSize size;
4097 wxSize* sizePtr = &size;
4098
4099 // Find out what the type of the item is
4100 // try wxWindow
4101 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4102 PyErr_Clear();
4103 info.window = NULL;
7fbf8399 4104
d55e5bfc
RD
4105 // try wxSizer
4106 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4107 PyErr_Clear();
4108 info.sizer = NULL;
7fbf8399 4109
d55e5bfc
RD
4110 // try wxSize or (w,h)
4111 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4112 info.size = *sizePtr;
b411df4a 4113 info.gotSize = true;
d55e5bfc
RD
4114 }
4115
4116 // or a single int
4117 if (checkIdx && PyInt_Check(item)) {
4118 info.pos = PyInt_AsLong(item);
b411df4a 4119 info.gotPos = true;
d55e5bfc
RD
4120 }
4121 }
4122 }
4123
4124 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4125 // no expected type, figure out what kind of error message to generate
4126 if ( !checkSize && !checkIdx )
943e8dfd 4127 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
d55e5bfc 4128 else if ( checkSize && !checkIdx )
943e8dfd 4129 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
d55e5bfc 4130 else if ( !checkSize && checkIdx)
943e8dfd 4131 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
d55e5bfc
RD
4132 else
4133 // can this one happen?
943e8dfd 4134 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
d55e5bfc
RD
4135 }
4136
4137 return info;
4138}
4139
1bd55598 4140SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
b0f7404b
RD
4141 if (!self->GetClientObject())
4142 self->SetClientObject(new wxPyOORClientData(_self));
d55e5bfc 4143 }
1bd55598 4144SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
7fbf8399 4145
d55e5bfc 4146 wxPyUserData* data = NULL;
5a446332 4147 wxPyBlock_t blocked = wxPyBeginBlockThreads();
b411df4a 4148 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
d55e5bfc
RD
4149 if ( userData && (info.window || info.sizer || info.gotSize) )
4150 data = new wxPyUserData(userData);
7e08d4ef
RD
4151 if ( info.sizer )
4152 PyObject_SetAttrString(item,"thisown",Py_False);
d55e5bfc 4153 wxPyEndBlockThreads(blocked);
7fbf8399 4154
d55e5bfc
RD
4155 // Now call the real Add method if a valid item type was found
4156 if ( info.window )
070c48b4 4157 return self->Add(info.window, proportion, flag, border, data);
d55e5bfc 4158 else if ( info.sizer )
070c48b4 4159 return self->Add(info.sizer, proportion, flag, border, data);
d55e5bfc 4160 else if (info.gotSize)
070c48b4
RD
4161 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4162 proportion, flag, border, data);
4163 else
4164 return NULL;
d55e5bfc 4165 }
1bd55598 4166SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
d55e5bfc
RD
4167
4168 wxPyUserData* data = NULL;
5a446332 4169 wxPyBlock_t blocked = wxPyBeginBlockThreads();
b411df4a 4170 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
d55e5bfc
RD
4171 if ( userData && (info.window || info.sizer || info.gotSize) )
4172 data = new wxPyUserData(userData);
7e08d4ef
RD
4173 if ( info.sizer )
4174 PyObject_SetAttrString(item,"thisown",Py_False);
d55e5bfc 4175 wxPyEndBlockThreads(blocked);
7fbf8399 4176
d55e5bfc
RD
4177 // Now call the real Insert method if a valid item type was found
4178 if ( info.window )
070c48b4 4179 return self->Insert(before, info.window, proportion, flag, border, data);
d55e5bfc 4180 else if ( info.sizer )
070c48b4 4181 return self->Insert(before, info.sizer, proportion, flag, border, data);
d55e5bfc 4182 else if (info.gotSize)
070c48b4
RD
4183 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4184 proportion, flag, border, data);
4185 else
4186 return NULL;
d55e5bfc 4187 }
1bd55598 4188SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
d55e5bfc
RD
4189
4190 wxPyUserData* data = NULL;
5a446332 4191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
b411df4a 4192 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
d55e5bfc
RD
4193 if ( userData && (info.window || info.sizer || info.gotSize) )
4194 data = new wxPyUserData(userData);
7e08d4ef
RD
4195 if ( info.sizer )
4196 PyObject_SetAttrString(item,"thisown",Py_False);
d55e5bfc 4197 wxPyEndBlockThreads(blocked);
7fbf8399 4198
d55e5bfc
RD
4199 // Now call the real Prepend method if a valid item type was found
4200 if ( info.window )
070c48b4 4201 return self->Prepend(info.window, proportion, flag, border, data);
d55e5bfc 4202 else if ( info.sizer )
070c48b4 4203 return self->Prepend(info.sizer, proportion, flag, border, data);
d55e5bfc 4204 else if (info.gotSize)
070c48b4
RD
4205 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4206 proportion, flag, border, data);
4207 else
4208 return NULL;
d55e5bfc 4209 }
1bd55598 4210SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
5a446332 4211 wxPyBlock_t blocked = wxPyBeginBlockThreads();
b411df4a 4212 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
d55e5bfc
RD
4213 wxPyEndBlockThreads(blocked);
4214 if ( info.window )
4215 return self->Remove(info.window);
4216 else if ( info.sizer )
4217 return self->Remove(info.sizer);
4218 else if ( info.gotPos )
4219 return self->Remove(info.pos);
7fbf8399 4220 else
b411df4a 4221 return false;
d55e5bfc 4222 }
1bd55598 4223SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
5a446332 4224 wxPyBlock_t blocked = wxPyBeginBlockThreads();
b411df4a 4225 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
1a6bba1e
RD
4226 wxPyEndBlockThreads(blocked);
4227 if ( info.window )
4228 return self->Detach(info.window);
4229 else if ( info.sizer )
4230 return self->Detach(info.sizer);
4231 else if ( info.gotPos )
4232 return self->Detach(info.pos);
7fbf8399 4233 else
b411df4a 4234 return false;
1a6bba1e 4235 }
1bd55598 4236SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
5a446332 4237 wxPyBlock_t blocked = wxPyBeginBlockThreads();
070c48b4
RD
4238 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4239 wxPyEndBlockThreads(blocked);
4240 if ( info.window )
4241 return self->GetItem(info.window);
4242 else if ( info.sizer )
4243 return self->GetItem(info.sizer);
4244 else if ( info.gotPos )
4245 return self->GetItem(info.pos);
4246 else
4247 return NULL;
4248 }
1bd55598 4249SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
5a446332 4250 wxPyBlock_t blocked = wxPyBeginBlockThreads();
b411df4a 4251 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
d55e5bfc
RD
4252 wxPyEndBlockThreads(blocked);
4253 if ( info.window )
4254 self->SetItemMinSize(info.window, size);
4255 else if ( info.sizer )
4256 self->SetItemMinSize(info.sizer, size);
4257 else if ( info.gotPos )
4258 self->SetItemMinSize(info.pos, size);
4259 }
1bd55598 4260SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
d55e5bfc
RD
4261 wxSizerItemList& list = self->GetChildren();
4262 return wxPy_ConvertList(&list);
4263 }
1bd55598 4264SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
5a446332 4265 wxPyBlock_t blocked = wxPyBeginBlockThreads();
b411df4a 4266 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
d6c14a4c 4267 wxPyEndBlockThreads(blocked);
d55e5bfc 4268 if ( info.window )
629e65c2 4269 return self->Show(info.window, show, recursive);
d55e5bfc 4270 else if ( info.sizer )
629e65c2 4271 return self->Show(info.sizer, show, recursive);
bfddbb17 4272 else if ( info.gotPos )
629e65c2 4273 return self->Show(info.pos, show);
b411df4a
RD
4274 else
4275 return false;
d55e5bfc 4276 }
1bd55598 4277SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
5a446332 4278 wxPyBlock_t blocked = wxPyBeginBlockThreads();
b411df4a 4279 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
d6c14a4c 4280 wxPyEndBlockThreads(blocked);
7fbf8399 4281 if ( info.window )
d55e5bfc 4282 return self->IsShown(info.window);
7fbf8399 4283 else if ( info.sizer )
d55e5bfc 4284 return self->IsShown(info.sizer);
bfddbb17
RD
4285 else if ( info.gotPos )
4286 return self->IsShown(info.pos);
d55e5bfc 4287 else
b411df4a 4288 return false;
d55e5bfc
RD
4289 }
4290
7fbf8399 4291// See pyclasses.h
d55e5bfc
RD
4292IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4293IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4294IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4295
4296
4297
4298
4299bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4300{
4301 if (source == Py_None) {
4302 **obj = wxGBPosition(-1,-1);
b411df4a 4303 return true;
d55e5bfc
RD
4304 }
4305 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4306}
4307
4308bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4309{
4310 if (source == Py_None) {
4311 **obj = wxGBSpan(-1,-1);
b411df4a 4312 return true;
d55e5bfc
RD
4313 }
4314 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4315}
4316
4317
e9d6f3a4
RD
4318SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4319 wxGBPosition temp, *obj = &temp;
4320 if ( other == Py_None ) return false;
4321 if ( ! wxGBPosition_helper(other, &obj) ) {
4322 PyErr_Clear();
4323 return false;
4324 }
4325 return self->operator==(*obj);
4326 }
4327SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4328 wxGBPosition temp, *obj = &temp;
4329 if ( other == Py_None ) return true;
4330 if ( ! wxGBPosition_helper(other, &obj)) {
4331 PyErr_Clear();
4332 return true;
4333 }
4334 return self->operator!=(*obj);
4335 }
1bd55598 4336SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
d55e5bfc
RD
4337 self->SetRow(row);
4338 self->SetCol(col);
4339 }
1bd55598 4340SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
5a446332 4341 wxPyBlock_t blocked = wxPyBeginBlockThreads();
d55e5bfc
RD
4342 PyObject* tup = PyTuple_New(2);
4343 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4344 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4345 wxPyEndBlockThreads(blocked);
4346 return tup;
4347 }
e9d6f3a4
RD
4348SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4349 wxGBSpan temp, *obj = &temp;
4350 if ( other == Py_None ) return false;
4351 if ( ! wxGBSpan_helper(other, &obj) ) {
4352 PyErr_Clear();
4353 return false;
4354 }
4355 return self->operator==(*obj);
4356 }
4357SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4358 wxGBSpan temp, *obj = &temp;
4359 if ( other == Py_None ) return true;
4360 if ( ! wxGBSpan_helper(other, &obj)) {
4361 PyErr_Clear();
4362 return true;
4363 }
4364 return self->operator!=(*obj);
4365 }
1bd55598 4366SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
d55e5bfc
RD
4367 self->SetRowspan(rowspan);
4368 self->SetColspan(colspan);
4369 }
1bd55598 4370SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
5a446332 4371 wxPyBlock_t blocked = wxPyBeginBlockThreads();
d55e5bfc
RD
4372 PyObject* tup = PyTuple_New(2);
4373 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4374 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4375 wxPyEndBlockThreads(blocked);
4376 return tup;
4377 }
1bd55598 4378SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
bfddbb17
RD
4379 wxPyUserData* data = NULL;
4380 if ( userData ) {
5a446332 4381 wxPyBlock_t blocked = wxPyBeginBlockThreads();
bfddbb17
RD
4382 data = new wxPyUserData(userData);
4383 wxPyEndBlockThreads(blocked);
4384 }
4385 return new wxGBSizerItem(window, pos, span, flag, border, data);
4386 }
1bd55598 4387SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
bfddbb17
RD
4388 wxPyUserData* data = NULL;
4389 if ( userData ) {
5a446332 4390 wxPyBlock_t blocked = wxPyBeginBlockThreads();
bfddbb17
RD
4391 data = new wxPyUserData(userData);
4392 wxPyEndBlockThreads(blocked);
4393 }
4394 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4395 }
1bd55598 4396SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
bfddbb17
RD
4397 wxPyUserData* data = NULL;
4398 if ( userData ) {
5a446332 4399 wxPyBlock_t blocked = wxPyBeginBlockThreads();
bfddbb17
RD
4400 data = new wxPyUserData(userData);
4401 wxPyEndBlockThreads(blocked);
4402 }
4403 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4404 }
1bd55598 4405SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
bfddbb17
RD
4406 int row, col;
4407 self->GetEndPos(row, col);
4408 return wxGBPosition(row, col);
4409 }
1bd55598 4410SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
d55e5bfc
RD
4411
4412 wxPyUserData* data = NULL;
5a446332 4413 wxPyBlock_t blocked = wxPyBeginBlockThreads();
b411df4a 4414 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
d55e5bfc
RD
4415 if ( userData && (info.window || info.sizer || info.gotSize) )
4416 data = new wxPyUserData(userData);
7e08d4ef
RD
4417 if ( info.sizer )
4418 PyObject_SetAttrString(item,"thisown",Py_False);
d55e5bfc
RD
4419 wxPyEndBlockThreads(blocked);
4420
4421 // Now call the real Add method if a valid item type was found
4422 if ( info.window )
070c48b4 4423 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
d55e5bfc 4424 else if ( info.sizer )
070c48b4 4425 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
d55e5bfc 4426 else if (info.gotSize)
070c48b4
RD
4427 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4428 pos, span, flag, border, data);
4429 return NULL;
d55e5bfc
RD
4430 }
4431
4432
4433#ifdef __cplusplus
4434extern "C" {
4435#endif
1bd55598
RD
4436SWIGINTERN int EmptyString_set(PyObject *) {
4437 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4438 return 1;
d55e5bfc
RD
4439}
4440
4441
1bd55598
RD
4442SWIGINTERN PyObject *EmptyString_get(void) {
4443 PyObject *pyobj = 0;
4444
4445 {
d55e5bfc 4446#if wxUSE_UNICODE
1bd55598 4447 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
d55e5bfc 4448#else
1bd55598 4449 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
d55e5bfc 4450#endif
1bd55598
RD
4451 }
4452 return pyobj;
d55e5bfc
RD
4453}
4454
4455
1bd55598
RD
4456SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4457 PyObject *resultobj = 0;
4458 wxObject *arg1 = (wxObject *) 0 ;
4459 wxString result;
4460 void *argp1 = 0 ;
4461 int res1 = 0 ;
4462 PyObject *swig_obj[1] ;
4463
4464 if (!args) SWIG_fail;
4465 swig_obj[0] = args;
4466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4467 if (!SWIG_IsOK(res1)) {
4468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4469 }
4470 arg1 = reinterpret_cast< wxObject * >(argp1);
4471 {
4472 PyThreadState* __tstate = wxPyBeginAllowThreads();
4473 result = wxObject_GetClassName(arg1);
4474 wxPyEndAllowThreads(__tstate);
4475 if (PyErr_Occurred()) SWIG_fail;
4476 }
4477 {
d55e5bfc 4478#if wxUSE_UNICODE
1bd55598 4479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
d55e5bfc 4480#else
1bd55598 4481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
d55e5bfc 4482#endif
1bd55598
RD
4483 }
4484 return resultobj;
4485fail:
4486 return NULL;
d55e5bfc
RD
4487}
4488
4489
1bd55598
RD
4490SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4491 PyObject *resultobj = 0;
4492 wxObject *arg1 = (wxObject *) 0 ;
4493 void *argp1 = 0 ;
4494 int res1 = 0 ;
4495 PyObject *swig_obj[1] ;
4496
4497 if (!args) SWIG_fail;
4498 swig_obj[0] = args;
4499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4500 if (!SWIG_IsOK(res1)) {
4501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4502 }
4503 arg1 = reinterpret_cast< wxObject * >(argp1);
4504 {
4505 PyThreadState* __tstate = wxPyBeginAllowThreads();
4506 wxObject_Destroy(arg1);
4507 wxPyEndAllowThreads(__tstate);
4508 if (PyErr_Occurred()) SWIG_fail;
4509 }
4510 resultobj = SWIG_Py_Void();
4511 return resultobj;
4512fail:
4513 return NULL;
d55e5bfc
RD
4514}
4515
4516
8f514ab4
RD
4517SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4518 PyObject *resultobj = 0;
4519 wxObject *arg1 = (wxObject *) 0 ;
4520 wxObject *arg2 = 0 ;
4521 bool result;
4522 void *argp1 = 0 ;
4523 int res1 = 0 ;
4524 void *argp2 = 0 ;
4525 int res2 = 0 ;
4526 PyObject * obj0 = 0 ;
4527 PyObject * obj1 = 0 ;
4528 char * kwnames[] = {
4529 (char *) "self",(char *) "p", NULL
4530 };
4531
4532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4534 if (!SWIG_IsOK(res1)) {
4535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4536 }
4537 arg1 = reinterpret_cast< wxObject * >(argp1);
4538 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4539 if (!SWIG_IsOK(res2)) {
4540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4541 }
4542 if (!argp2) {
4543 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4544 }
4545 arg2 = reinterpret_cast< wxObject * >(argp2);
4546 {
4547 PyThreadState* __tstate = wxPyBeginAllowThreads();
4548 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4549 wxPyEndAllowThreads(__tstate);
4550 if (PyErr_Occurred()) SWIG_fail;
4551 }
4552 {
4553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4554 }
4555 return resultobj;
4556fail:
4557 return NULL;
4558}
4559
4560
1bd55598
RD
4561SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4562 PyObject *obj;
4563 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4564 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4565 return SWIG_Py_Void();
d55e5bfc
RD
4566}
4567
1bd55598
RD
4568SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4569 PyObject *resultobj = 0;
4570 wxSize *arg1 = (wxSize *) 0 ;
4571 int arg2 ;
4572 void *argp1 = 0 ;
4573 int res1 = 0 ;
4574 int val2 ;
4575 int ecode2 = 0 ;
4576 PyObject *swig_obj[2] ;
4577
4578 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4580 if (!SWIG_IsOK(res1)) {
4581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4582 }
4583 arg1 = reinterpret_cast< wxSize * >(argp1);
4584 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4585 if (!SWIG_IsOK(ecode2)) {
4586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4587 }
4588 arg2 = static_cast< int >(val2);
4589 if (arg1) (arg1)->x = arg2;
4590
4591 resultobj = SWIG_Py_Void();
4592 return resultobj;
4593fail:
4594 return NULL;
d55e5bfc
RD
4595}
4596
4597
1bd55598
RD
4598SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4599 PyObject *resultobj = 0;
4600 wxSize *arg1 = (wxSize *) 0 ;
4601 int result;
4602 void *argp1 = 0 ;
4603 int res1 = 0 ;
4604 PyObject *swig_obj[1] ;
4605
4606 if (!args) SWIG_fail;
4607 swig_obj[0] = args;
4608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4609 if (!SWIG_IsOK(res1)) {
4610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4611 }
4612 arg1 = reinterpret_cast< wxSize * >(argp1);
4613 result = (int) ((arg1)->x);
4614 resultobj = SWIG_From_int(static_cast< int >(result));
4615 return resultobj;
4616fail:
4617 return NULL;
4618}
4619
4620
4621SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4622 PyObject *resultobj = 0;
4623 wxSize *arg1 = (wxSize *) 0 ;
4624 int arg2 ;
4625 void *argp1 = 0 ;
4626 int res1 = 0 ;
4627 int val2 ;
4628 int ecode2 = 0 ;
4629 PyObject *swig_obj[2] ;
4630
4631 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4633 if (!SWIG_IsOK(res1)) {
4634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4635 }
4636 arg1 = reinterpret_cast< wxSize * >(argp1);
4637 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4638 if (!SWIG_IsOK(ecode2)) {
4639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4640 }
4641 arg2 = static_cast< int >(val2);
4642 if (arg1) (arg1)->y = arg2;
4643
4644 resultobj = SWIG_Py_Void();
4645 return resultobj;
4646fail:
4647 return NULL;
d55e5bfc
RD
4648}
4649
4650
1bd55598
RD
4651SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4652 PyObject *resultobj = 0;
4653 wxSize *arg1 = (wxSize *) 0 ;
4654 int result;
4655 void *argp1 = 0 ;
4656 int res1 = 0 ;
4657 PyObject *swig_obj[1] ;
4658
4659 if (!args) SWIG_fail;
4660 swig_obj[0] = args;
4661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4662 if (!SWIG_IsOK(res1)) {
4663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4664 }
4665 arg1 = reinterpret_cast< wxSize * >(argp1);
4666 result = (int) ((arg1)->y);
4667 resultobj = SWIG_From_int(static_cast< int >(result));
4668 return resultobj;
4669fail:
4670 return NULL;
4671}
4672
4673
4674SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4675 PyObject *resultobj = 0;
4676 int arg1 = (int) 0 ;
4677 int arg2 = (int) 0 ;
4678 wxSize *result = 0 ;
4679 int val1 ;
4680 int ecode1 = 0 ;
4681 int val2 ;
4682 int ecode2 = 0 ;
4683 PyObject * obj0 = 0 ;
4684 PyObject * obj1 = 0 ;
4685 char * kwnames[] = {
4686 (char *) "w",(char *) "h", NULL
4687 };
4688
4689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4690 if (obj0) {
4691 ecode1 = SWIG_AsVal_int(obj0, &val1);
4692 if (!SWIG_IsOK(ecode1)) {
4693 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4694 }
4695 arg1 = static_cast< int >(val1);
4696 }
4697 if (obj1) {
4698 ecode2 = SWIG_AsVal_int(obj1, &val2);
4699 if (!SWIG_IsOK(ecode2)) {
4700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4701 }
4702 arg2 = static_cast< int >(val2);
4703 }
4704 {
1bd55598 4705 result = (wxSize *)new wxSize(arg1,arg2);
1bd55598
RD
4706 if (PyErr_Occurred()) SWIG_fail;
4707 }
4708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4709 return resultobj;
4710fail:
4711 return NULL;
d55e5bfc
RD
4712}
4713
4714
1bd55598
RD
4715SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4716 PyObject *resultobj = 0;
4717 wxSize *arg1 = (wxSize *) 0 ;
4718 void *argp1 = 0 ;
4719 int res1 = 0 ;
4720 PyObject *swig_obj[1] ;
4721
4722 if (!args) SWIG_fail;
4723 swig_obj[0] = args;
4724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4725 if (!SWIG_IsOK(res1)) {
4726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4727 }
4728 arg1 = reinterpret_cast< wxSize * >(argp1);
4729 {
1bd55598 4730 delete arg1;
d55e5bfc 4731
1bd55598
RD
4732 if (PyErr_Occurred()) SWIG_fail;
4733 }
4734 resultobj = SWIG_Py_Void();
4735 return resultobj;
4736fail:
4737 return NULL;
4738}
4739
4740
4741SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4742 PyObject *resultobj = 0;
4743 wxSize *arg1 = (wxSize *) 0 ;
e9d6f3a4 4744 PyObject *arg2 = (PyObject *) 0 ;
1bd55598
RD
4745 bool result;
4746 void *argp1 = 0 ;
4747 int res1 = 0 ;
1bd55598
RD
4748 PyObject * obj0 = 0 ;
4749 PyObject * obj1 = 0 ;
4750 char * kwnames[] = {
e9d6f3a4 4751 (char *) "self",(char *) "other", NULL
1bd55598
RD
4752 };
4753
4754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4756 if (!SWIG_IsOK(res1)) {
4757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4758 }
4759 arg1 = reinterpret_cast< wxSize * >(argp1);
e9d6f3a4 4760 arg2 = obj1;
1bd55598 4761 {
e9d6f3a4 4762 result = (bool)wxSize___eq__(arg1,arg2);
1bd55598
RD
4763 if (PyErr_Occurred()) SWIG_fail;
4764 }
4765 {
4766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4767 }
4768 return resultobj;
4769fail:
4770 return NULL;
4771}
4772
4773
4774SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4775 PyObject *resultobj = 0;
4776 wxSize *arg1 = (wxSize *) 0 ;
e9d6f3a4 4777 PyObject *arg2 = (PyObject *) 0 ;
1bd55598
RD
4778 bool result;
4779 void *argp1 = 0 ;
4780 int res1 = 0 ;
1bd55598
RD
4781 PyObject * obj0 = 0 ;
4782 PyObject * obj1 = 0 ;
4783 char * kwnames[] = {
e9d6f3a4 4784 (char *) "self",(char *) "other", NULL
1bd55598
RD
4785 };
4786
4787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4789 if (!SWIG_IsOK(res1)) {
4790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4791 }
4792 arg1 = reinterpret_cast< wxSize * >(argp1);
e9d6f3a4 4793 arg2 = obj1;
1bd55598 4794 {
e9d6f3a4 4795 result = (bool)wxSize___ne__(arg1,arg2);
1bd55598
RD
4796 if (PyErr_Occurred()) SWIG_fail;
4797 }
4798 {
4799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4800 }
4801 return resultobj;
4802fail:
4803 return NULL;
4804}
4805
4806
4807SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4808 PyObject *resultobj = 0;
4809 wxSize *arg1 = (wxSize *) 0 ;
4810 wxSize *arg2 = 0 ;
4811 wxSize result;
4812 void *argp1 = 0 ;
4813 int res1 = 0 ;
4814 wxSize temp2 ;
4815 PyObject * obj0 = 0 ;
4816 PyObject * obj1 = 0 ;
4817 char * kwnames[] = {
4818 (char *) "self",(char *) "sz", NULL
4819 };
4820
4821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4823 if (!SWIG_IsOK(res1)) {
4824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4825 }
4826 arg1 = reinterpret_cast< wxSize * >(argp1);
4827 {
4828 arg2 = &temp2;
4829 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4830 }
4831 {
1bd55598 4832 result = (arg1)->operator +((wxSize const &)*arg2);
1bd55598
RD
4833 if (PyErr_Occurred()) SWIG_fail;
4834 }
4835 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4836 return resultobj;
4837fail:
4838 return NULL;
4839}
4840
4841
4842SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4843 PyObject *resultobj = 0;
4844 wxSize *arg1 = (wxSize *) 0 ;
4845 wxSize *arg2 = 0 ;
4846 wxSize result;
4847 void *argp1 = 0 ;
4848 int res1 = 0 ;
4849 wxSize temp2 ;
4850 PyObject * obj0 = 0 ;
4851 PyObject * obj1 = 0 ;
4852 char * kwnames[] = {
4853 (char *) "self",(char *) "sz", NULL
4854 };
4855
4856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4858 if (!SWIG_IsOK(res1)) {
4859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4860 }
4861 arg1 = reinterpret_cast< wxSize * >(argp1);
4862 {
4863 arg2 = &temp2;
4864 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4865 }
4866 {
1bd55598 4867 result = (arg1)->operator -((wxSize const &)*arg2);
1bd55598
RD
4868 if (PyErr_Occurred()) SWIG_fail;
4869 }
4870 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4871 return resultobj;
4872fail:
4873 return NULL;
4874}
4875
4876
4877SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4878 PyObject *resultobj = 0;
4879 wxSize *arg1 = (wxSize *) 0 ;
4880 wxSize *arg2 = 0 ;
4881 void *argp1 = 0 ;
4882 int res1 = 0 ;
4883 wxSize temp2 ;
4884 PyObject * obj0 = 0 ;
4885 PyObject * obj1 = 0 ;
4886 char * kwnames[] = {
4887 (char *) "self",(char *) "sz", NULL
4888 };
4889
4890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4892 if (!SWIG_IsOK(res1)) {
4893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4894 }
4895 arg1 = reinterpret_cast< wxSize * >(argp1);
4896 {
4897 arg2 = &temp2;
4898 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4899 }
4900 {
1bd55598 4901 (arg1)->IncTo((wxSize const &)*arg2);
1bd55598
RD
4902 if (PyErr_Occurred()) SWIG_fail;
4903 }
4904 resultobj = SWIG_Py_Void();
4905 return resultobj;
4906fail:
4907 return NULL;
4908}
4909
4910
4911SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4912 PyObject *resultobj = 0;
4913 wxSize *arg1 = (wxSize *) 0 ;
4914 wxSize *arg2 = 0 ;
4915 void *argp1 = 0 ;
4916 int res1 = 0 ;
4917 wxSize temp2 ;
4918 PyObject * obj0 = 0 ;
4919 PyObject * obj1 = 0 ;
4920 char * kwnames[] = {
4921 (char *) "self",(char *) "sz", NULL
4922 };
4923
4924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4926 if (!SWIG_IsOK(res1)) {
4927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4928 }
4929 arg1 = reinterpret_cast< wxSize * >(argp1);
4930 {
4931 arg2 = &temp2;
4932 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4933 }
4934 {
1bd55598 4935 (arg1)->DecTo((wxSize const &)*arg2);
1bd55598
RD
4936 if (PyErr_Occurred()) SWIG_fail;
4937 }
4938 resultobj = SWIG_Py_Void();
4939 return resultobj;
4940fail:
4941 return NULL;
4942}
4943
4944
f5263701
RD
4945SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4946 PyObject *resultobj = 0;
4947 wxSize *arg1 = (wxSize *) 0 ;
4948 int arg2 ;
4949 int arg3 ;
4950 void *argp1 = 0 ;
4951 int res1 = 0 ;
4952 int val2 ;
4953 int ecode2 = 0 ;
4954 int val3 ;
4955 int ecode3 = 0 ;
4956 PyObject * obj0 = 0 ;
4957 PyObject * obj1 = 0 ;
4958 PyObject * obj2 = 0 ;
4959 char * kwnames[] = {
4960 (char *) "self",(char *) "dx",(char *) "dy", NULL
4961 };
4962
4963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4965 if (!SWIG_IsOK(res1)) {
4966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4967 }
4968 arg1 = reinterpret_cast< wxSize * >(argp1);
4969 ecode2 = SWIG_AsVal_int(obj1, &val2);
4970 if (!SWIG_IsOK(ecode2)) {
4971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4972 }
4973 arg2 = static_cast< int >(val2);
4974 ecode3 = SWIG_AsVal_int(obj2, &val3);
4975 if (!SWIG_IsOK(ecode3)) {
4976 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4977 }
4978 arg3 = static_cast< int >(val3);
4979 {
f5263701 4980 (arg1)->IncBy(arg2,arg3);
f5263701
RD
4981 if (PyErr_Occurred()) SWIG_fail;
4982 }
4983 resultobj = SWIG_Py_Void();
4984 return resultobj;
4985fail:
4986 return NULL;
4987}
4988
4989
4990SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4991 PyObject *resultobj = 0;
4992 wxSize *arg1 = (wxSize *) 0 ;
4993 int arg2 ;
4994 int arg3 ;
4995 void *argp1 = 0 ;
4996 int res1 = 0 ;
4997 int val2 ;
4998 int ecode2 = 0 ;
4999 int val3 ;
5000 int ecode3 = 0 ;
5001 PyObject * obj0 = 0 ;
5002 PyObject * obj1 = 0 ;
5003 PyObject * obj2 = 0 ;
5004 char * kwnames[] = {
5005 (char *) "self",(char *) "dx",(char *) "dy", NULL
5006 };
5007
5008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5010 if (!SWIG_IsOK(res1)) {
5011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5012 }
5013 arg1 = reinterpret_cast< wxSize * >(argp1);
5014 ecode2 = SWIG_AsVal_int(obj1, &val2);
5015 if (!SWIG_IsOK(ecode2)) {
5016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5017 }
5018 arg2 = static_cast< int >(val2);
5019 ecode3 = SWIG_AsVal_int(obj2, &val3);
5020 if (!SWIG_IsOK(ecode3)) {
5021 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5022 }
5023 arg3 = static_cast< int >(val3);
5024 {
f5263701 5025 (arg1)->DecBy(arg2,arg3);
f5263701
RD
5026 if (PyErr_Occurred()) SWIG_fail;
5027 }
5028 resultobj = SWIG_Py_Void();
5029 return resultobj;
5030fail:
5031 return NULL;
5032}
5033
5034
1eeb270e
RD
5035SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5036 PyObject *resultobj = 0;
5037 wxSize *arg1 = (wxSize *) 0 ;
5038 float arg2 ;
5039 float arg3 ;
5040 void *argp1 = 0 ;
5041 int res1 = 0 ;
5042 float val2 ;
5043 int ecode2 = 0 ;
5044 float val3 ;
5045 int ecode3 = 0 ;
5046 PyObject * obj0 = 0 ;
5047 PyObject * obj1 = 0 ;
5048 PyObject * obj2 = 0 ;
5049 char * kwnames[] = {
5050 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5051 };
5052
5053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5055 if (!SWIG_IsOK(res1)) {
5056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5057 }
5058 arg1 = reinterpret_cast< wxSize * >(argp1);
5059 ecode2 = SWIG_AsVal_float(obj1, &val2);
5060 if (!SWIG_IsOK(ecode2)) {
5061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5062 }
5063 arg2 = static_cast< float >(val2);
5064 ecode3 = SWIG_AsVal_float(obj2, &val3);
5065 if (!SWIG_IsOK(ecode3)) {
5066 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5067 }
5068 arg3 = static_cast< float >(val3);
5069 {
1eeb270e 5070 (arg1)->Scale(arg2,arg3);
1eeb270e
RD
5071 if (PyErr_Occurred()) SWIG_fail;
5072 }
5073 resultobj = SWIG_Py_Void();
5074 return resultobj;
5075fail:
5076 return NULL;
5077}
5078
5079
1bd55598
RD
5080SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5081 PyObject *resultobj = 0;
5082 wxSize *arg1 = (wxSize *) 0 ;
5083 int arg2 ;
5084 int arg3 ;
5085 void *argp1 = 0 ;
5086 int res1 = 0 ;
5087 int val2 ;
5088 int ecode2 = 0 ;
5089 int val3 ;
5090 int ecode3 = 0 ;
5091 PyObject * obj0 = 0 ;
5092 PyObject * obj1 = 0 ;
5093 PyObject * obj2 = 0 ;
5094 char * kwnames[] = {
5095 (char *) "self",(char *) "w",(char *) "h", NULL
5096 };
5097
5098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5100 if (!SWIG_IsOK(res1)) {
5101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5102 }
5103 arg1 = reinterpret_cast< wxSize * >(argp1);
5104 ecode2 = SWIG_AsVal_int(obj1, &val2);
5105 if (!SWIG_IsOK(ecode2)) {
5106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5107 }
5108 arg2 = static_cast< int >(val2);
5109 ecode3 = SWIG_AsVal_int(obj2, &val3);
5110 if (!SWIG_IsOK(ecode3)) {
5111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5112 }
5113 arg3 = static_cast< int >(val3);
5114 {
1bd55598 5115 (arg1)->Set(arg2,arg3);
1bd55598
RD
5116 if (PyErr_Occurred()) SWIG_fail;
5117 }
5118 resultobj = SWIG_Py_Void();
5119 return resultobj;
5120fail:
5121 return NULL;
5122}
5123
5124
5125SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5126 PyObject *resultobj = 0;
5127 wxSize *arg1 = (wxSize *) 0 ;
5128 int arg2 ;
5129 void *argp1 = 0 ;
5130 int res1 = 0 ;
5131 int val2 ;
5132 int ecode2 = 0 ;
5133 PyObject * obj0 = 0 ;
5134 PyObject * obj1 = 0 ;
5135 char * kwnames[] = {
5136 (char *) "self",(char *) "w", NULL
5137 };
5138
5139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5141 if (!SWIG_IsOK(res1)) {
5142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5143 }
5144 arg1 = reinterpret_cast< wxSize * >(argp1);
5145 ecode2 = SWIG_AsVal_int(obj1, &val2);
5146 if (!SWIG_IsOK(ecode2)) {
5147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5148 }
5149 arg2 = static_cast< int >(val2);
5150 {
1bd55598 5151 (arg1)->SetWidth(arg2);
1bd55598
RD
5152 if (PyErr_Occurred()) SWIG_fail;
5153 }
5154 resultobj = SWIG_Py_Void();
5155 return resultobj;
5156fail:
5157 return NULL;
5158}
5159
5160
5161SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5162 PyObject *resultobj = 0;
5163 wxSize *arg1 = (wxSize *) 0 ;
5164 int arg2 ;
5165 void *argp1 = 0 ;
5166 int res1 = 0 ;
5167 int val2 ;
5168 int ecode2 = 0 ;
5169 PyObject * obj0 = 0 ;
5170 PyObject * obj1 = 0 ;
5171 char * kwnames[] = {
5172 (char *) "self",(char *) "h", NULL
5173 };
5174
5175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5177 if (!SWIG_IsOK(res1)) {
5178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5179 }
5180 arg1 = reinterpret_cast< wxSize * >(argp1);
5181 ecode2 = SWIG_AsVal_int(obj1, &val2);
5182 if (!SWIG_IsOK(ecode2)) {
5183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5184 }
5185 arg2 = static_cast< int >(val2);
5186 {
1bd55598 5187 (arg1)->SetHeight(arg2);
1bd55598
RD
5188 if (PyErr_Occurred()) SWIG_fail;
5189 }
5190 resultobj = SWIG_Py_Void();
5191 return resultobj;
5192fail:
5193 return NULL;
d55e5bfc
RD
5194}
5195
5196
1bd55598
RD
5197SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5198 PyObject *resultobj = 0;
5199 wxSize *arg1 = (wxSize *) 0 ;
5200 int result;
5201 void *argp1 = 0 ;
5202 int res1 = 0 ;
5203 PyObject *swig_obj[1] ;
5204
5205 if (!args) SWIG_fail;
5206 swig_obj[0] = args;
5207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5208 if (!SWIG_IsOK(res1)) {
5209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5210 }
5211 arg1 = reinterpret_cast< wxSize * >(argp1);
5212 {
1bd55598 5213 result = (int)((wxSize const *)arg1)->GetWidth();
1bd55598
RD
5214 if (PyErr_Occurred()) SWIG_fail;
5215 }
5216 resultobj = SWIG_From_int(static_cast< int >(result));
5217 return resultobj;
5218fail:
5219 return NULL;
d55e5bfc
RD
5220}
5221
5222
1bd55598
RD
5223SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5224 PyObject *resultobj = 0;
5225 wxSize *arg1 = (wxSize *) 0 ;
5226 int result;
5227 void *argp1 = 0 ;
5228 int res1 = 0 ;
5229 PyObject *swig_obj[1] ;
5230
5231 if (!args) SWIG_fail;
5232 swig_obj[0] = args;
5233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5234 if (!SWIG_IsOK(res1)) {
5235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5236 }
5237 arg1 = reinterpret_cast< wxSize * >(argp1);
5238 {
1bd55598 5239 result = (int)((wxSize const *)arg1)->GetHeight();
1bd55598
RD
5240 if (PyErr_Occurred()) SWIG_fail;
5241 }
5242 resultobj = SWIG_From_int(static_cast< int >(result));
5243 return resultobj;
5244fail:
5245 return NULL;
d55e5bfc
RD
5246}
5247
5248
1bd55598
RD
5249SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5250 PyObject *resultobj = 0;
5251 wxSize *arg1 = (wxSize *) 0 ;
5252 bool result;
5253 void *argp1 = 0 ;
5254 int res1 = 0 ;
5255 PyObject *swig_obj[1] ;
5256
5257 if (!args) SWIG_fail;
5258 swig_obj[0] = args;
5259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5260 if (!SWIG_IsOK(res1)) {
5261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5262 }
5263 arg1 = reinterpret_cast< wxSize * >(argp1);
5264 {
1bd55598 5265 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
1bd55598
RD
5266 if (PyErr_Occurred()) SWIG_fail;
5267 }
5268 {
5269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5270 }
5271 return resultobj;
5272fail:
5273 return NULL;
5274}
5275
5276
5277SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5278 PyObject *resultobj = 0;
5279 wxSize *arg1 = (wxSize *) 0 ;
5280 wxSize *arg2 = 0 ;
5281 void *argp1 = 0 ;
5282 int res1 = 0 ;
5283 wxSize temp2 ;
5284 PyObject * obj0 = 0 ;
5285 PyObject * obj1 = 0 ;
5286 char * kwnames[] = {
5287 (char *) "self",(char *) "size", NULL
5288 };
5289
5290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5292 if (!SWIG_IsOK(res1)) {
5293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5294 }
5295 arg1 = reinterpret_cast< wxSize * >(argp1);
5296 {
5297 arg2 = &temp2;
5298 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5299 }
5300 {
1bd55598 5301 (arg1)->SetDefaults((wxSize const &)*arg2);
1bd55598
RD
5302 if (PyErr_Occurred()) SWIG_fail;
5303 }
5304 resultobj = SWIG_Py_Void();
5305 return resultobj;
5306fail:
5307 return NULL;
d55e5bfc
RD
5308}
5309
5310
1bd55598
RD
5311SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5312 PyObject *resultobj = 0;
5313 wxSize *arg1 = (wxSize *) 0 ;
5314 PyObject *result = 0 ;
5315 void *argp1 = 0 ;
5316 int res1 = 0 ;
5317 PyObject *swig_obj[1] ;
5318
5319 if (!args) SWIG_fail;
5320 swig_obj[0] = args;
5321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5322 if (!SWIG_IsOK(res1)) {
5323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5324 }
5325 arg1 = reinterpret_cast< wxSize * >(argp1);
5326 {
1bd55598 5327 result = (PyObject *)wxSize_Get(arg1);
1bd55598
RD
5328 if (PyErr_Occurred()) SWIG_fail;
5329 }
5330 resultobj = result;
5331 return resultobj;
5332fail:
5333 return NULL;
d55e5bfc
RD
5334}
5335
5336
1bd55598
RD
5337SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5338 PyObject *obj;
5339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5340 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5341 return SWIG_Py_Void();
d55e5bfc
RD
5342}
5343
1bd55598
RD
5344SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5345 return SWIG_Python_InitShadowInstance(args);
5346}
d55e5bfc 5347
1bd55598
RD
5348SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5349 PyObject *resultobj = 0;
5350 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5351 double arg2 ;
5352 void *argp1 = 0 ;
5353 int res1 = 0 ;
5354 double val2 ;
5355 int ecode2 = 0 ;
5356 PyObject *swig_obj[2] ;
5357
5358 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5360 if (!SWIG_IsOK(res1)) {
5361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5362 }
5363 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5364 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5365 if (!SWIG_IsOK(ecode2)) {
5366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5367 }
5368 arg2 = static_cast< double >(val2);
5369 if (arg1) (arg1)->x = arg2;
5370
5371 resultobj = SWIG_Py_Void();
5372 return resultobj;
5373fail:
5374 return NULL;
d55e5bfc
RD
5375}
5376
5377
1bd55598
RD
5378SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5379 PyObject *resultobj = 0;
5380 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5381 double result;
5382 void *argp1 = 0 ;
5383 int res1 = 0 ;
5384 PyObject *swig_obj[1] ;
5385
5386 if (!args) SWIG_fail;
5387 swig_obj[0] = args;
5388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5389 if (!SWIG_IsOK(res1)) {
5390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5391 }
5392 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5393 result = (double) ((arg1)->x);
5394 resultobj = SWIG_From_double(static_cast< double >(result));
5395 return resultobj;
5396fail:
5397 return NULL;
5398}
5399
5400
5401SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5402 PyObject *resultobj = 0;
5403 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5404 double arg2 ;
5405 void *argp1 = 0 ;
5406 int res1 = 0 ;
5407 double val2 ;
5408 int ecode2 = 0 ;
5409 PyObject *swig_obj[2] ;
5410
5411 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5413 if (!SWIG_IsOK(res1)) {
5414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5415 }
5416 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5417 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5418 if (!SWIG_IsOK(ecode2)) {
5419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5420 }
5421 arg2 = static_cast< double >(val2);
5422 if (arg1) (arg1)->y = arg2;
5423
5424 resultobj = SWIG_Py_Void();
5425 return resultobj;
5426fail:
5427 return NULL;
d55e5bfc
RD
5428}
5429
5430
1bd55598
RD
5431SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5432 PyObject *resultobj = 0;
5433 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5434 double result;
5435 void *argp1 = 0 ;
5436 int res1 = 0 ;
5437 PyObject *swig_obj[1] ;
5438
5439 if (!args) SWIG_fail;
5440 swig_obj[0] = args;
5441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5442 if (!SWIG_IsOK(res1)) {
5443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5444 }
5445 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5446 result = (double) ((arg1)->y);
5447 resultobj = SWIG_From_double(static_cast< double >(result));
5448 return resultobj;
5449fail:
5450 return NULL;
5451}
5452
5453
5454SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5455 PyObject *resultobj = 0;
5456 double arg1 = (double) 0.0 ;
5457 double arg2 = (double) 0.0 ;
5458 wxRealPoint *result = 0 ;
5459 double val1 ;
5460 int ecode1 = 0 ;
5461 double val2 ;
5462 int ecode2 = 0 ;
5463 PyObject * obj0 = 0 ;
5464 PyObject * obj1 = 0 ;
5465 char * kwnames[] = {
5466 (char *) "x",(char *) "y", NULL
5467 };
5468
5469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5470 if (obj0) {
5471 ecode1 = SWIG_AsVal_double(obj0, &val1);
5472 if (!SWIG_IsOK(ecode1)) {
5473 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5474 }
5475 arg1 = static_cast< double >(val1);
5476 }
5477 if (obj1) {
5478 ecode2 = SWIG_AsVal_double(obj1, &val2);
5479 if (!SWIG_IsOK(ecode2)) {
5480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5481 }
5482 arg2 = static_cast< double >(val2);
5483 }
5484 {
1bd55598 5485 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
1bd55598
RD
5486 if (PyErr_Occurred()) SWIG_fail;
5487 }
5488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5489 return resultobj;
5490fail:
5491 return NULL;
d55e5bfc
RD
5492}
5493
5494
1bd55598
RD
5495SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5496 PyObject *resultobj = 0;
5497 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5498 void *argp1 = 0 ;
5499 int res1 = 0 ;
5500 PyObject *swig_obj[1] ;
5501
5502 if (!args) SWIG_fail;
5503 swig_obj[0] = args;
5504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5505 if (!SWIG_IsOK(res1)) {
5506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5507 }
5508 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5509 {
1bd55598 5510 delete arg1;
d55e5bfc 5511
1bd55598
RD
5512 if (PyErr_Occurred()) SWIG_fail;
5513 }
5514 resultobj = SWIG_Py_Void();
5515 return resultobj;
5516fail:
5517 return NULL;
5518}
5519
5520
5521SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5522 PyObject *resultobj = 0;
5523 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
e9d6f3a4 5524 PyObject *arg2 = (PyObject *) 0 ;
1bd55598
RD
5525 bool result;
5526 void *argp1 = 0 ;
5527 int res1 = 0 ;
1bd55598
RD
5528 PyObject * obj0 = 0 ;
5529 PyObject * obj1 = 0 ;
5530 char * kwnames[] = {
e9d6f3a4 5531 (char *) "self",(char *) "other", NULL
1bd55598
RD
5532 };
5533
5534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5536 if (!SWIG_IsOK(res1)) {
5537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5538 }
5539 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
e9d6f3a4 5540 arg2 = obj1;
1bd55598 5541 {
e9d6f3a4 5542 result = (bool)wxRealPoint___eq__(arg1,arg2);
1bd55598
RD
5543 if (PyErr_Occurred()) SWIG_fail;
5544 }
5545 {
5546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5547 }
5548 return resultobj;
5549fail:
5550 return NULL;
5551}
5552
5553
5554SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5555 PyObject *resultobj = 0;
5556 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
e9d6f3a4 5557 PyObject *arg2 = (PyObject *) 0 ;
1bd55598
RD
5558 bool result;
5559 void *argp1 = 0 ;
5560 int res1 = 0 ;
1bd55598
RD
5561 PyObject * obj0 = 0 ;
5562 PyObject * obj1 = 0 ;
5563 char * kwnames[] = {
e9d6f3a4 5564 (char *) "self",(char *) "other", NULL
1bd55598
RD
5565 };
5566
5567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5569 if (!SWIG_IsOK(res1)) {
5570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5571 }
5572 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
e9d6f3a4 5573 arg2 = obj1;
1bd55598 5574 {
e9d6f3a4 5575 result = (bool)wxRealPoint___ne__(arg1,arg2);
1bd55598
RD
5576 if (PyErr_Occurred()) SWIG_fail;
5577 }
5578 {
5579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5580 }
5581 return resultobj;
5582fail:
5583 return NULL;
5584}
5585
5586
5587SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5588 PyObject *resultobj = 0;
5589 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5590 wxRealPoint *arg2 = 0 ;
5591 wxRealPoint result;
5592 void *argp1 = 0 ;
5593 int res1 = 0 ;
5594 wxRealPoint temp2 ;
5595 PyObject * obj0 = 0 ;
5596 PyObject * obj1 = 0 ;
5597 char * kwnames[] = {
5598 (char *) "self",(char *) "pt", NULL
5599 };
5600
5601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5603 if (!SWIG_IsOK(res1)) {
5604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5605 }
5606 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5607 {
5608 arg2 = &temp2;
5609 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5610 }
5611 {
1bd55598 5612 result = (arg1)->operator +((wxRealPoint const &)*arg2);
1bd55598
RD
5613 if (PyErr_Occurred()) SWIG_fail;
5614 }
5615 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5616 return resultobj;
5617fail:
5618 return NULL;
5619}
5620
5621
5622SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5623 PyObject *resultobj = 0;
5624 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5625 wxRealPoint *arg2 = 0 ;
5626 wxRealPoint result;
5627 void *argp1 = 0 ;
5628 int res1 = 0 ;
5629 wxRealPoint temp2 ;
5630 PyObject * obj0 = 0 ;
5631 PyObject * obj1 = 0 ;
5632 char * kwnames[] = {
5633 (char *) "self",(char *) "pt", NULL
5634 };
5635
5636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5638 if (!SWIG_IsOK(res1)) {
5639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5640 }
5641 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5642 {
5643 arg2 = &temp2;
5644 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5645 }
5646 {
1bd55598 5647 result = (arg1)->operator -((wxRealPoint const &)*arg2);
1bd55598
RD
5648 if (PyErr_Occurred()) SWIG_fail;
5649 }
5650 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5651 return resultobj;
5652fail:
5653 return NULL;
5654}
5655
5656
5657SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5658 PyObject *resultobj = 0;
5659 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5660 double arg2 ;
5661 double arg3 ;
5662 void *argp1 = 0 ;
5663 int res1 = 0 ;
5664 double val2 ;
5665 int ecode2 = 0 ;
5666 double val3 ;
5667 int ecode3 = 0 ;
5668 PyObject * obj0 = 0 ;
5669 PyObject * obj1 = 0 ;
5670 PyObject * obj2 = 0 ;
5671 char * kwnames[] = {
5672 (char *) "self",(char *) "x",(char *) "y", NULL
5673 };
5674
5675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5677 if (!SWIG_IsOK(res1)) {
5678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5679 }
5680 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5681 ecode2 = SWIG_AsVal_double(obj1, &val2);
5682 if (!SWIG_IsOK(ecode2)) {
5683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5684 }
5685 arg2 = static_cast< double >(val2);
5686 ecode3 = SWIG_AsVal_double(obj2, &val3);
5687 if (!SWIG_IsOK(ecode3)) {
5688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5689 }
5690 arg3 = static_cast< double >(val3);
5691 {
1bd55598 5692 wxRealPoint_Set(arg1,arg2,arg3);
1bd55598
RD
5693 if (PyErr_Occurred()) SWIG_fail;
5694 }
5695 resultobj = SWIG_Py_Void();
5696 return resultobj;
5697fail:
5698 return NULL;
d55e5bfc
RD
5699}
5700
5701
1bd55598
RD
5702SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5703 PyObject *resultobj = 0;
5704 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5705 PyObject *result = 0 ;
5706 void *argp1 = 0 ;
5707 int res1 = 0 ;
5708 PyObject *swig_obj[1] ;
5709
5710 if (!args) SWIG_fail;
5711 swig_obj[0] = args;
5712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5713 if (!SWIG_IsOK(res1)) {
5714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5715 }
5716 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5717 {
1bd55598 5718 result = (PyObject *)wxRealPoint_Get(arg1);
1bd55598
RD
5719 if (PyErr_Occurred()) SWIG_fail;
5720 }
5721 resultobj = result;
5722 return resultobj;
5723fail:
5724 return NULL;
d55e5bfc
RD
5725}
5726
5727
1bd55598
RD
5728SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5729 PyObject *obj;
5730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5731 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5732 return SWIG_Py_Void();
d55e5bfc
RD
5733}
5734
1bd55598
RD
5735SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5736 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
5737}
5738
1bd55598
RD
5739SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5740 PyObject *resultobj = 0;
5741 wxPoint *arg1 = (wxPoint *) 0 ;
5742 int arg2 ;
5743 void *argp1 = 0 ;
5744 int res1 = 0 ;
5745 int val2 ;
5746 int ecode2 = 0 ;
5747 PyObject *swig_obj[2] ;
5748
5749 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5751 if (!SWIG_IsOK(res1)) {
5752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5753 }
5754 arg1 = reinterpret_cast< wxPoint * >(argp1);
5755 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5756 if (!SWIG_IsOK(ecode2)) {
5757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5758 }
5759 arg2 = static_cast< int >(val2);
5760 if (arg1) (arg1)->x = arg2;
5761
5762 resultobj = SWIG_Py_Void();
5763 return resultobj;
5764fail:
5765 return NULL;
d55e5bfc
RD
5766}
5767
5768
1bd55598
RD
5769SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5770 PyObject *resultobj = 0;
5771 wxPoint *arg1 = (wxPoint *) 0 ;
5772 int result;
5773 void *argp1 = 0 ;
5774 int res1 = 0 ;
5775 PyObject *swig_obj[1] ;
5776
5777 if (!args) SWIG_fail;
5778 swig_obj[0] = args;
5779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5780 if (!SWIG_IsOK(res1)) {
5781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5782 }
5783 arg1 = reinterpret_cast< wxPoint * >(argp1);
5784 result = (int) ((arg1)->x);
5785 resultobj = SWIG_From_int(static_cast< int >(result));
5786 return resultobj;
5787fail:
5788 return NULL;
5789}
5790
5791
5792SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5793 PyObject *resultobj = 0;
5794 wxPoint *arg1 = (wxPoint *) 0 ;
5795 int arg2 ;
5796 void *argp1 = 0 ;
5797 int res1 = 0 ;
5798 int val2 ;
5799 int ecode2 = 0 ;
5800 PyObject *swig_obj[2] ;
5801
5802 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5804 if (!SWIG_IsOK(res1)) {
5805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5806 }
5807 arg1 = reinterpret_cast< wxPoint * >(argp1);
5808 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5809 if (!SWIG_IsOK(ecode2)) {
5810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5811 }
5812 arg2 = static_cast< int >(val2);
5813 if (arg1) (arg1)->y = arg2;
5814
5815 resultobj = SWIG_Py_Void();
5816 return resultobj;
5817fail:
5818 return NULL;
d55e5bfc
RD
5819}
5820
5821
1bd55598
RD
5822SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5823 PyObject *resultobj = 0;
5824 wxPoint *arg1 = (wxPoint *) 0 ;
5825 int result;
5826 void *argp1 = 0 ;
5827 int res1 = 0 ;
5828 PyObject *swig_obj[1] ;
5829
5830 if (!args) SWIG_fail;
5831 swig_obj[0] = args;
5832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5833 if (!SWIG_IsOK(res1)) {
5834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5835 }
5836 arg1 = reinterpret_cast< wxPoint * >(argp1);
5837 result = (int) ((arg1)->y);
5838 resultobj = SWIG_From_int(static_cast< int >(result));
5839 return resultobj;
5840fail:
5841 return NULL;
5842}
5843
5844
5845SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5846 PyObject *resultobj = 0;
5847 int arg1 = (int) 0 ;
5848 int arg2 = (int) 0 ;
5849 wxPoint *result = 0 ;
5850 int val1 ;
5851 int ecode1 = 0 ;
5852 int val2 ;
5853 int ecode2 = 0 ;
5854 PyObject * obj0 = 0 ;
5855 PyObject * obj1 = 0 ;
5856 char * kwnames[] = {
5857 (char *) "x",(char *) "y", NULL
5858 };
5859
5860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5861 if (obj0) {
5862 ecode1 = SWIG_AsVal_int(obj0, &val1);
5863 if (!SWIG_IsOK(ecode1)) {
5864 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5865 }
5866 arg1 = static_cast< int >(val1);
5867 }
5868 if (obj1) {
5869 ecode2 = SWIG_AsVal_int(obj1, &val2);
5870 if (!SWIG_IsOK(ecode2)) {
5871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5872 }
5873 arg2 = static_cast< int >(val2);
5874 }
5875 {
1bd55598 5876 result = (wxPoint *)new wxPoint(arg1,arg2);
1bd55598
RD
5877 if (PyErr_Occurred()) SWIG_fail;
5878 }
5879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5880 return resultobj;
5881fail:
5882 return NULL;
d55e5bfc
RD
5883}
5884
5885
1bd55598
RD
5886SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5887 PyObject *resultobj = 0;
5888 wxPoint *arg1 = (wxPoint *) 0 ;
5889 void *argp1 = 0 ;
5890 int res1 = 0 ;
5891 PyObject *swig_obj[1] ;
5892
5893 if (!args) SWIG_fail;
5894 swig_obj[0] = args;
5895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5896 if (!SWIG_IsOK(res1)) {
5897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5898 }
5899 arg1 = reinterpret_cast< wxPoint * >(argp1);
5900 {
1bd55598 5901 delete arg1;
d55e5bfc 5902
1bd55598
RD
5903 if (PyErr_Occurred()) SWIG_fail;
5904 }
5905 resultobj = SWIG_Py_Void();
5906 return resultobj;
5907fail:
5908 return NULL;
5909}
5910
5911
5912SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5913 PyObject *resultobj = 0;
5914 wxPoint *arg1 = (wxPoint *) 0 ;
e9d6f3a4 5915 PyObject *arg2 = (PyObject *) 0 ;
1bd55598
RD
5916 bool result;
5917 void *argp1 = 0 ;
5918 int res1 = 0 ;
1bd55598
RD
5919 PyObject * obj0 = 0 ;
5920 PyObject * obj1 = 0 ;
5921 char * kwnames[] = {
e9d6f3a4 5922 (char *) "self",(char *) "other", NULL
1bd55598
RD
5923 };
5924
5925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5927 if (!SWIG_IsOK(res1)) {
5928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5929 }
5930 arg1 = reinterpret_cast< wxPoint * >(argp1);
e9d6f3a4 5931 arg2 = obj1;
1bd55598 5932 {
e9d6f3a4 5933 result = (bool)wxPoint___eq__(arg1,arg2);
1bd55598
RD
5934 if (PyErr_Occurred()) SWIG_fail;
5935 }
5936 {
5937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5938 }
5939 return resultobj;
5940fail:
5941 return NULL;
5942}
5943
5944
5945SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5946 PyObject *resultobj = 0;
5947 wxPoint *arg1 = (wxPoint *) 0 ;
e9d6f3a4 5948 PyObject *arg2 = (PyObject *) 0 ;
1bd55598
RD
5949 bool result;
5950 void *argp1 = 0 ;
5951 int res1 = 0 ;
1bd55598
RD
5952 PyObject * obj0 = 0 ;
5953 PyObject * obj1 = 0 ;
5954 char * kwnames[] = {
e9d6f3a4 5955 (char *) "self",(char *) "other", NULL
1bd55598
RD
5956 };
5957
5958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5960 if (!SWIG_IsOK(res1)) {
5961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5962 }
5963 arg1 = reinterpret_cast< wxPoint * >(argp1);
e9d6f3a4 5964 arg2 = obj1;
1bd55598 5965 {
e9d6f3a4 5966 result = (bool)wxPoint___ne__(arg1,arg2);
1bd55598
RD
5967 if (PyErr_Occurred()) SWIG_fail;
5968 }
5969 {
5970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5971 }
5972 return resultobj;
5973fail:
5974 return NULL;
5975}
5976
5977
5978SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5979 PyObject *resultobj = 0;
5980 wxPoint *arg1 = (wxPoint *) 0 ;
5981 wxPoint *arg2 = 0 ;
5982 wxPoint result;
5983 void *argp1 = 0 ;
5984 int res1 = 0 ;
5985 wxPoint temp2 ;
5986 PyObject * obj0 = 0 ;
5987 PyObject * obj1 = 0 ;
5988 char * kwnames[] = {
5989 (char *) "self",(char *) "pt", NULL
5990 };
5991
5992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5994 if (!SWIG_IsOK(res1)) {
5995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5996 }
5997 arg1 = reinterpret_cast< wxPoint * >(argp1);
5998 {
5999 arg2 = &temp2;
6000 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6001 }
6002 {
1bd55598 6003 result = (arg1)->operator +((wxPoint const &)*arg2);
1bd55598
RD
6004 if (PyErr_Occurred()) SWIG_fail;
6005 }
6006 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6007 return resultobj;
6008fail:
6009 return NULL;
6010}
6011
6012
6013SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6014 PyObject *resultobj = 0;
6015 wxPoint *arg1 = (wxPoint *) 0 ;
6016 wxPoint *arg2 = 0 ;
6017 wxPoint result;
6018 void *argp1 = 0 ;
6019 int res1 = 0 ;
6020 wxPoint temp2 ;
6021 PyObject * obj0 = 0 ;
6022 PyObject * obj1 = 0 ;
6023 char * kwnames[] = {
6024 (char *) "self",(char *) "pt", NULL
6025 };
6026
6027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6029 if (!SWIG_IsOK(res1)) {
6030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6031 }
6032 arg1 = reinterpret_cast< wxPoint * >(argp1);
6033 {
6034 arg2 = &temp2;
6035 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6036 }
6037 {
1bd55598 6038 result = (arg1)->operator -((wxPoint const &)*arg2);
1bd55598
RD
6039 if (PyErr_Occurred()) SWIG_fail;
6040 }
6041 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6042 return resultobj;
6043fail:
6044 return NULL;
6045}
6046
6047
6048SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6049 PyObject *resultobj = 0;
6050 wxPoint *arg1 = (wxPoint *) 0 ;
6051 wxPoint *arg2 = 0 ;
6052 wxPoint *result = 0 ;
6053 void *argp1 = 0 ;
6054 int res1 = 0 ;
6055 wxPoint temp2 ;
6056 PyObject * obj0 = 0 ;
6057 PyObject * obj1 = 0 ;
6058 char * kwnames[] = {
6059 (char *) "self",(char *) "pt", NULL
6060 };
6061
6062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6064 if (!SWIG_IsOK(res1)) {
6065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6066 }
6067 arg1 = reinterpret_cast< wxPoint * >(argp1);
6068 {
6069 arg2 = &temp2;
6070 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6071 }
6072 {
36ed4f51 6073 {
1bd55598
RD
6074 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6075 result = (wxPoint *) &_result_ref;
36ed4f51 6076 }
1bd55598
RD
6077 if (PyErr_Occurred()) SWIG_fail;
6078 }
6079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6080 return resultobj;
6081fail:
6082 return NULL;
6083}
6084
6085
6086SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6087 PyObject *resultobj = 0;
6088 wxPoint *arg1 = (wxPoint *) 0 ;
6089 wxPoint *arg2 = 0 ;
6090 wxPoint *result = 0 ;
6091 void *argp1 = 0 ;
6092 int res1 = 0 ;
6093 wxPoint temp2 ;
6094 PyObject * obj0 = 0 ;
6095 PyObject * obj1 = 0 ;
6096 char * kwnames[] = {
6097 (char *) "self",(char *) "pt", NULL
6098 };
6099
6100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6102 if (!SWIG_IsOK(res1)) {
6103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6104 }
6105 arg1 = reinterpret_cast< wxPoint * >(argp1);
6106 {
6107 arg2 = &temp2;
6108 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6109 }
6110 {
36ed4f51 6111 {
1bd55598
RD
6112 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6113 result = (wxPoint *) &_result_ref;
36ed4f51 6114 }
1bd55598
RD
6115 if (PyErr_Occurred()) SWIG_fail;
6116 }
6117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6118 return resultobj;
6119fail:
6120 return NULL;
6121}
6122
6123
6124SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6125 PyObject *resultobj = 0;
6126 wxPoint *arg1 = (wxPoint *) 0 ;
6127 long arg2 ;
6128 long arg3 ;
6129 void *argp1 = 0 ;
6130 int res1 = 0 ;
6131 long val2 ;
6132 int ecode2 = 0 ;
6133 long val3 ;
6134 int ecode3 = 0 ;
6135 PyObject * obj0 = 0 ;
6136 PyObject * obj1 = 0 ;
6137 PyObject * obj2 = 0 ;
6138 char * kwnames[] = {
6139 (char *) "self",(char *) "x",(char *) "y", NULL
6140 };
6141
6142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6144 if (!SWIG_IsOK(res1)) {
6145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6146 }
6147 arg1 = reinterpret_cast< wxPoint * >(argp1);
6148 ecode2 = SWIG_AsVal_long(obj1, &val2);
6149 if (!SWIG_IsOK(ecode2)) {
6150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6151 }
6152 arg2 = static_cast< long >(val2);
6153 ecode3 = SWIG_AsVal_long(obj2, &val3);
6154 if (!SWIG_IsOK(ecode3)) {
6155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6156 }
6157 arg3 = static_cast< long >(val3);
6158 {
1bd55598 6159 wxPoint_Set(arg1,arg2,arg3);
1bd55598
RD
6160 if (PyErr_Occurred()) SWIG_fail;
6161 }
6162 resultobj = SWIG_Py_Void();
6163 return resultobj;
6164fail:
6165 return NULL;
d55e5bfc
RD
6166}
6167
6168
1bd55598
RD
6169SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6170 PyObject *resultobj = 0;
6171 wxPoint *arg1 = (wxPoint *) 0 ;
6172 PyObject *result = 0 ;
6173 void *argp1 = 0 ;
6174 int res1 = 0 ;
6175 PyObject *swig_obj[1] ;
6176
6177 if (!args) SWIG_fail;
6178 swig_obj[0] = args;
6179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6180 if (!SWIG_IsOK(res1)) {
6181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6182 }
6183 arg1 = reinterpret_cast< wxPoint * >(argp1);
6184 {
1bd55598 6185 result = (PyObject *)wxPoint_Get(arg1);
1bd55598
RD
6186 if (PyErr_Occurred()) SWIG_fail;
6187 }
6188 resultobj = result;
6189 return resultobj;
6190fail:
6191 return NULL;
6192}
6193
6194
6195SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6196 PyObject *obj;
6197 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6198 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6199 return SWIG_Py_Void();
6200}
6201
6202SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6203 return SWIG_Python_InitShadowInstance(args);
6204}
6205
6206SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj = 0;
6208 int arg1 = (int) 0 ;
6209 int arg2 = (int) 0 ;
6210 int arg3 = (int) 0 ;
6211 int arg4 = (int) 0 ;
6212 wxRect *result = 0 ;
6213 int val1 ;
6214 int ecode1 = 0 ;
6215 int val2 ;
6216 int ecode2 = 0 ;
6217 int val3 ;
6218 int ecode3 = 0 ;
6219 int val4 ;
6220 int ecode4 = 0 ;
6221 PyObject * obj0 = 0 ;
6222 PyObject * obj1 = 0 ;
6223 PyObject * obj2 = 0 ;
6224 PyObject * obj3 = 0 ;
6225 char * kwnames[] = {
6226 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6227 };
6228
6229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6230 if (obj0) {
6231 ecode1 = SWIG_AsVal_int(obj0, &val1);
6232 if (!SWIG_IsOK(ecode1)) {
6233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6234 }
6235 arg1 = static_cast< int >(val1);
6236 }
6237 if (obj1) {
6238 ecode2 = SWIG_AsVal_int(obj1, &val2);
6239 if (!SWIG_IsOK(ecode2)) {
6240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6241 }
6242 arg2 = static_cast< int >(val2);
6243 }
6244 if (obj2) {
6245 ecode3 = SWIG_AsVal_int(obj2, &val3);
6246 if (!SWIG_IsOK(ecode3)) {
6247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6248 }
6249 arg3 = static_cast< int >(val3);
6250 }
6251 if (obj3) {
6252 ecode4 = SWIG_AsVal_int(obj3, &val4);
6253 if (!SWIG_IsOK(ecode4)) {
6254 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6255 }
6256 arg4 = static_cast< int >(val4);
6257 }
6258 {
1bd55598 6259 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
1bd55598
RD
6260 if (PyErr_Occurred()) SWIG_fail;
6261 }
6262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6263 return resultobj;
6264fail:
6265 return NULL;
6266}
6267
6268
6269SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6270 PyObject *resultobj = 0;
6271 wxPoint *arg1 = 0 ;
6272 wxPoint *arg2 = 0 ;
6273 wxRect *result = 0 ;
6274 wxPoint temp1 ;
6275 wxPoint temp2 ;
6276 PyObject * obj0 = 0 ;
6277 PyObject * obj1 = 0 ;
6278 char * kwnames[] = {
6279 (char *) "topLeft",(char *) "bottomRight", NULL
6280 };
6281
6282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6283 {
6284 arg1 = &temp1;
6285 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6286 }
6287 {
6288 arg2 = &temp2;
6289 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6290 }
6291 {
1bd55598 6292 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
1bd55598
RD
6293 if (PyErr_Occurred()) SWIG_fail;
6294 }
6295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6296 return resultobj;
6297fail:
6298 return NULL;
6299}
6300
6301
6302SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6303 PyObject *resultobj = 0;
6304 wxPoint *arg1 = 0 ;
6305 wxSize *arg2 = 0 ;
6306 wxRect *result = 0 ;
6307 wxPoint temp1 ;
6308 wxSize temp2 ;
6309 PyObject * obj0 = 0 ;
6310 PyObject * obj1 = 0 ;
6311 char * kwnames[] = {
6312 (char *) "pos",(char *) "size", NULL
6313 };
6314
6315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6316 {
6317 arg1 = &temp1;
6318 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6319 }
6320 {
6321 arg2 = &temp2;
6322 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6323 }
6324 {
1bd55598 6325 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
1bd55598
RD
6326 if (PyErr_Occurred()) SWIG_fail;
6327 }
6328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6329 return resultobj;
6330fail:
6331 return NULL;
d55e5bfc
RD
6332}
6333
6334
1bd55598
RD
6335SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6336 PyObject *resultobj = 0;
6337 wxSize *arg1 = 0 ;
6338 wxRect *result = 0 ;
6339 wxSize temp1 ;
6340 PyObject * obj0 = 0 ;
6341 char * kwnames[] = {
6342 (char *) "size", NULL
6343 };
6344
6345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6346 {
6347 arg1 = &temp1;
6348 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6349 }
6350 {
1bd55598 6351 result = (wxRect *)new wxRect((wxSize const &)*arg1);
1bd55598
RD
6352 if (PyErr_Occurred()) SWIG_fail;
6353 }
6354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6355 return resultobj;
6356fail:
6357 return NULL;
d55e5bfc
RD
6358}
6359
6360
1bd55598
RD
6361SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6362 PyObject *resultobj = 0;
6363 wxRect *arg1 = (wxRect *) 0 ;
6364 void *argp1 = 0 ;
6365 int res1 = 0 ;
6366 PyObject *swig_obj[1] ;
6367
6368 if (!args) SWIG_fail;
6369 swig_obj[0] = args;
6370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6371 if (!SWIG_IsOK(res1)) {
6372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6373 }
6374 arg1 = reinterpret_cast< wxRect * >(argp1);
6375 {
1bd55598 6376 delete arg1;
d55e5bfc 6377
1bd55598
RD
6378 if (PyErr_Occurred()) SWIG_fail;
6379 }
6380 resultobj = SWIG_Py_Void();
6381 return resultobj;
6382fail:
6383 return NULL;
d55e5bfc
RD
6384}
6385
6386
1bd55598
RD
6387SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6388 PyObject *resultobj = 0;
6389 wxRect *arg1 = (wxRect *) 0 ;
6390 int result;
6391 void *argp1 = 0 ;
6392 int res1 = 0 ;
6393 PyObject *swig_obj[1] ;
6394
6395 if (!args) SWIG_fail;
6396 swig_obj[0] = args;
6397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6398 if (!SWIG_IsOK(res1)) {
6399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6400 }
6401 arg1 = reinterpret_cast< wxRect * >(argp1);
6402 {
1bd55598 6403 result = (int)((wxRect const *)arg1)->GetX();
1bd55598
RD
6404 if (PyErr_Occurred()) SWIG_fail;
6405 }
6406 resultobj = SWIG_From_int(static_cast< int >(result));
6407 return resultobj;
6408fail:
6409 return NULL;
6410}
6411
6412
6413SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6414 PyObject *resultobj = 0;
6415 wxRect *arg1 = (wxRect *) 0 ;
6416 int arg2 ;
6417 void *argp1 = 0 ;
6418 int res1 = 0 ;
6419 int val2 ;
6420 int ecode2 = 0 ;
6421 PyObject * obj0 = 0 ;
6422 PyObject * obj1 = 0 ;
6423 char * kwnames[] = {
6424 (char *) "self",(char *) "x", NULL
6425 };
6426
6427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6429 if (!SWIG_IsOK(res1)) {
6430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6431 }
6432 arg1 = reinterpret_cast< wxRect * >(argp1);
6433 ecode2 = SWIG_AsVal_int(obj1, &val2);
6434 if (!SWIG_IsOK(ecode2)) {
6435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6436 }
6437 arg2 = static_cast< int >(val2);
6438 {
1bd55598 6439 (arg1)->SetX(arg2);
1bd55598
RD
6440 if (PyErr_Occurred()) SWIG_fail;
6441 }
6442 resultobj = SWIG_Py_Void();
6443 return resultobj;
6444fail:
6445 return NULL;
d55e5bfc
RD
6446}
6447
6448
1bd55598
RD
6449SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6450 PyObject *resultobj = 0;
6451 wxRect *arg1 = (wxRect *) 0 ;
6452 int result;
6453 void *argp1 = 0 ;
6454 int res1 = 0 ;
6455 PyObject *swig_obj[1] ;
6456
6457 if (!args) SWIG_fail;
6458 swig_obj[0] = args;
6459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6460 if (!SWIG_IsOK(res1)) {
6461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6462 }
6463 arg1 = reinterpret_cast< wxRect * >(argp1);
6464 {
1bd55598 6465 result = (int)(arg1)->GetY();
1bd55598
RD
6466 if (PyErr_Occurred()) SWIG_fail;
6467 }
6468 resultobj = SWIG_From_int(static_cast< int >(result));
6469 return resultobj;
6470fail:
6471 return NULL;
6472}
6473
6474
6475SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6476 PyObject *resultobj = 0;
6477 wxRect *arg1 = (wxRect *) 0 ;
6478 int arg2 ;
6479 void *argp1 = 0 ;
6480 int res1 = 0 ;
6481 int val2 ;
6482 int ecode2 = 0 ;
6483 PyObject * obj0 = 0 ;
6484 PyObject * obj1 = 0 ;
6485 char * kwnames[] = {
6486 (char *) "self",(char *) "y", NULL
6487 };
6488
6489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6491 if (!SWIG_IsOK(res1)) {
6492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6493 }
6494 arg1 = reinterpret_cast< wxRect * >(argp1);
6495 ecode2 = SWIG_AsVal_int(obj1, &val2);
6496 if (!SWIG_IsOK(ecode2)) {
6497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6498 }
6499 arg2 = static_cast< int >(val2);
6500 {
1bd55598 6501 (arg1)->SetY(arg2);
1bd55598
RD
6502 if (PyErr_Occurred()) SWIG_fail;
6503 }
6504 resultobj = SWIG_Py_Void();
6505 return resultobj;
6506fail:
6507 return NULL;
d55e5bfc
RD
6508}
6509
6510
1bd55598
RD
6511SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6512 PyObject *resultobj = 0;
6513 wxRect *arg1 = (wxRect *) 0 ;
6514 int result;
6515 void *argp1 = 0 ;
6516 int res1 = 0 ;
6517 PyObject *swig_obj[1] ;
6518
6519 if (!args) SWIG_fail;
6520 swig_obj[0] = args;
6521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6522 if (!SWIG_IsOK(res1)) {
6523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6524 }
6525 arg1 = reinterpret_cast< wxRect * >(argp1);
6526 {
1bd55598 6527 result = (int)((wxRect const *)arg1)->GetWidth();
1bd55598
RD
6528 if (PyErr_Occurred()) SWIG_fail;
6529 }
6530 resultobj = SWIG_From_int(static_cast< int >(result));
6531 return resultobj;
6532fail:
6533 return NULL;
6534}
6535
6536
6537SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6538 PyObject *resultobj = 0;
6539 wxRect *arg1 = (wxRect *) 0 ;
6540 int arg2 ;
6541 void *argp1 = 0 ;
6542 int res1 = 0 ;
6543 int val2 ;
6544 int ecode2 = 0 ;
6545 PyObject * obj0 = 0 ;
6546 PyObject * obj1 = 0 ;
6547 char * kwnames[] = {
6548 (char *) "self",(char *) "w", NULL
6549 };
6550
6551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6553 if (!SWIG_IsOK(res1)) {
6554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6555 }
6556 arg1 = reinterpret_cast< wxRect * >(argp1);
6557 ecode2 = SWIG_AsVal_int(obj1, &val2);
6558 if (!SWIG_IsOK(ecode2)) {
6559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6560 }
6561 arg2 = static_cast< int >(val2);
6562 {
1bd55598 6563 (arg1)->SetWidth(arg2);
1bd55598
RD
6564 if (PyErr_Occurred()) SWIG_fail;
6565 }
6566 resultobj = SWIG_Py_Void();
6567 return resultobj;
6568fail:
6569 return NULL;
d55e5bfc
RD
6570}
6571
6572
1bd55598
RD
6573SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6574 PyObject *resultobj = 0;
6575 wxRect *arg1 = (wxRect *) 0 ;
6576 int result;
6577 void *argp1 = 0 ;
6578 int res1 = 0 ;
6579 PyObject *swig_obj[1] ;
6580
6581 if (!args) SWIG_fail;
6582 swig_obj[0] = args;
6583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6584 if (!SWIG_IsOK(res1)) {
6585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6586 }
6587 arg1 = reinterpret_cast< wxRect * >(argp1);
6588 {
1bd55598 6589 result = (int)((wxRect const *)arg1)->GetHeight();
1bd55598
RD
6590 if (PyErr_Occurred()) SWIG_fail;
6591 }
6592 resultobj = SWIG_From_int(static_cast< int >(result));
6593 return resultobj;
6594fail:
6595 return NULL;
6596}
6597
6598
6599SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6600 PyObject *resultobj = 0;
6601 wxRect *arg1 = (wxRect *) 0 ;
6602 int arg2 ;
6603 void *argp1 = 0 ;
6604 int res1 = 0 ;
6605 int val2 ;
6606 int ecode2 = 0 ;
6607 PyObject * obj0 = 0 ;
6608 PyObject * obj1 = 0 ;
6609 char * kwnames[] = {
6610 (char *) "self",(char *) "h", NULL
6611 };
6612
6613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6615 if (!SWIG_IsOK(res1)) {
6616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6617 }
6618 arg1 = reinterpret_cast< wxRect * >(argp1);
6619 ecode2 = SWIG_AsVal_int(obj1, &val2);
6620 if (!SWIG_IsOK(ecode2)) {
6621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6622 }
6623 arg2 = static_cast< int >(val2);
6624 {
1bd55598 6625 (arg1)->SetHeight(arg2);
1bd55598
RD
6626 if (PyErr_Occurred()) SWIG_fail;
6627 }
6628 resultobj = SWIG_Py_Void();
6629 return resultobj;
6630fail:
6631 return NULL;
d55e5bfc
RD
6632}
6633
6634
1bd55598
RD
6635SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6636 PyObject *resultobj = 0;
6637 wxRect *arg1 = (wxRect *) 0 ;
6638 wxPoint result;
6639 void *argp1 = 0 ;
6640 int res1 = 0 ;
6641 PyObject *swig_obj[1] ;
6642
6643 if (!args) SWIG_fail;
6644 swig_obj[0] = args;
6645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6646 if (!SWIG_IsOK(res1)) {
6647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6648 }
6649 arg1 = reinterpret_cast< wxRect * >(argp1);
6650 {
1bd55598 6651 result = ((wxRect const *)arg1)->GetPosition();
1bd55598
RD
6652 if (PyErr_Occurred()) SWIG_fail;
6653 }
6654 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6655 return resultobj;
6656fail:
6657 return NULL;
6658}
6659
6660
6661SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6662 PyObject *resultobj = 0;
6663 wxRect *arg1 = (wxRect *) 0 ;
6664 wxPoint *arg2 = 0 ;
6665 void *argp1 = 0 ;
6666 int res1 = 0 ;
6667 wxPoint temp2 ;
6668 PyObject * obj0 = 0 ;
6669 PyObject * obj1 = 0 ;
6670 char * kwnames[] = {
6671 (char *) "self",(char *) "p", NULL
6672 };
6673
6674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6676 if (!SWIG_IsOK(res1)) {
6677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6678 }
6679 arg1 = reinterpret_cast< wxRect * >(argp1);
6680 {
6681 arg2 = &temp2;
6682 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6683 }
6684 {
1bd55598 6685 (arg1)->SetPosition((wxPoint const &)*arg2);
1bd55598
RD
6686 if (PyErr_Occurred()) SWIG_fail;
6687 }
6688 resultobj = SWIG_Py_Void();
6689 return resultobj;
6690fail:
6691 return NULL;
d55e5bfc
RD
6692}
6693
6694
1bd55598
RD
6695SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6696 PyObject *resultobj = 0;
6697 wxRect *arg1 = (wxRect *) 0 ;
6698 wxSize result;
6699 void *argp1 = 0 ;
6700 int res1 = 0 ;
6701 PyObject *swig_obj[1] ;
6702
6703 if (!args) SWIG_fail;
6704 swig_obj[0] = args;
6705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6706 if (!SWIG_IsOK(res1)) {
6707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6708 }
6709 arg1 = reinterpret_cast< wxRect * >(argp1);
6710 {
1bd55598 6711 result = ((wxRect const *)arg1)->GetSize();
1bd55598
RD
6712 if (PyErr_Occurred()) SWIG_fail;
6713 }
6714 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6715 return resultobj;
6716fail:
6717 return NULL;
6718}
6719
6720
6721SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6722 PyObject *resultobj = 0;
6723 wxRect *arg1 = (wxRect *) 0 ;
6724 wxSize *arg2 = 0 ;
6725 void *argp1 = 0 ;
6726 int res1 = 0 ;
6727 wxSize temp2 ;
6728 PyObject * obj0 = 0 ;
6729 PyObject * obj1 = 0 ;
6730 char * kwnames[] = {
6731 (char *) "self",(char *) "s", NULL
6732 };
6733
6734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6736 if (!SWIG_IsOK(res1)) {
6737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6738 }
6739 arg1 = reinterpret_cast< wxRect * >(argp1);
6740 {
6741 arg2 = &temp2;
6742 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6743 }
6744 {
1bd55598 6745 (arg1)->SetSize((wxSize const &)*arg2);
1bd55598
RD
6746 if (PyErr_Occurred()) SWIG_fail;
6747 }
6748 resultobj = SWIG_Py_Void();
6749 return resultobj;
6750fail:
6751 return NULL;
d55e5bfc
RD
6752}
6753
6754
1bd55598
RD
6755SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6756 PyObject *resultobj = 0;
6757 wxRect *arg1 = (wxRect *) 0 ;
6758 bool result;
6759 void *argp1 = 0 ;
6760 int res1 = 0 ;
6761 PyObject *swig_obj[1] ;
6762
6763 if (!args) SWIG_fail;
6764 swig_obj[0] = args;
6765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6766 if (!SWIG_IsOK(res1)) {
6767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6768 }
6769 arg1 = reinterpret_cast< wxRect * >(argp1);
6770 {
1bd55598 6771 result = (bool)((wxRect const *)arg1)->IsEmpty();
1bd55598
RD
6772 if (PyErr_Occurred()) SWIG_fail;
6773 }
6774 {
6775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6776 }
6777 return resultobj;
6778fail:
6779 return NULL;
d55e5bfc
RD
6780}
6781
6782
1bd55598
RD
6783SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6784 PyObject *resultobj = 0;
6785 wxRect *arg1 = (wxRect *) 0 ;
6786 wxPoint result;
6787 void *argp1 = 0 ;
6788 int res1 = 0 ;
6789 PyObject *swig_obj[1] ;
6790
6791 if (!args) SWIG_fail;
6792 swig_obj[0] = args;
6793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6794 if (!SWIG_IsOK(res1)) {
6795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6796 }
6797 arg1 = reinterpret_cast< wxRect * >(argp1);
6798 {
1bd55598 6799 result = ((wxRect const *)arg1)->GetTopLeft();
1bd55598
RD
6800 if (PyErr_Occurred()) SWIG_fail;
6801 }
6802 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6803 return resultobj;
6804fail:
6805 return NULL;
6806}
6807
6808
6809SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6810 PyObject *resultobj = 0;
6811 wxRect *arg1 = (wxRect *) 0 ;
6812 wxPoint *arg2 = 0 ;
6813 void *argp1 = 0 ;
6814 int res1 = 0 ;
6815 wxPoint temp2 ;
6816 PyObject * obj0 = 0 ;
6817 PyObject * obj1 = 0 ;
6818 char * kwnames[] = {
6819 (char *) "self",(char *) "p", NULL
6820 };
6821
6822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6824 if (!SWIG_IsOK(res1)) {
6825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6826 }
6827 arg1 = reinterpret_cast< wxRect * >(argp1);
6828 {
6829 arg2 = &temp2;
6830 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6831 }
6832 {
1bd55598 6833 (arg1)->SetTopLeft((wxPoint const &)*arg2);
1bd55598
RD
6834 if (PyErr_Occurred()) SWIG_fail;
6835 }
6836 resultobj = SWIG_Py_Void();
6837 return resultobj;
6838fail:
6839 return NULL;
d55e5bfc
RD
6840}
6841
6842
1bd55598
RD
6843SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6844 PyObject *resultobj = 0;
6845 wxRect *arg1 = (wxRect *) 0 ;
6846 wxPoint result;
6847 void *argp1 = 0 ;
6848 int res1 = 0 ;
6849 PyObject *swig_obj[1] ;
6850
6851 if (!args) SWIG_fail;
6852 swig_obj[0] = args;
6853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6854 if (!SWIG_IsOK(res1)) {
6855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6856 }
6857 arg1 = reinterpret_cast< wxRect * >(argp1);
6858 {
1bd55598 6859 result = ((wxRect const *)arg1)->GetBottomRight();
1bd55598
RD
6860 if (PyErr_Occurred()) SWIG_fail;
6861 }
6862 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6863 return resultobj;
6864fail:
6865 return NULL;
6866}
6867
6868
6869SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6870 PyObject *resultobj = 0;
6871 wxRect *arg1 = (wxRect *) 0 ;
6872 wxPoint *arg2 = 0 ;
6873 void *argp1 = 0 ;
6874 int res1 = 0 ;
6875 wxPoint temp2 ;
6876 PyObject * obj0 = 0 ;
6877 PyObject * obj1 = 0 ;
6878 char * kwnames[] = {
6879 (char *) "self",(char *) "p", NULL
6880 };
6881
6882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6884 if (!SWIG_IsOK(res1)) {
6885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6886 }
6887 arg1 = reinterpret_cast< wxRect * >(argp1);
6888 {
6889 arg2 = &temp2;
6890 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6891 }
6892 {
1bd55598 6893 (arg1)->SetBottomRight((wxPoint const &)*arg2);
1bd55598
RD
6894 if (PyErr_Occurred()) SWIG_fail;
6895 }
6896 resultobj = SWIG_Py_Void();
6897 return resultobj;
6898fail:
6899 return NULL;
d55e5bfc
RD
6900}
6901
6902
5acb46e0
RD
6903SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6904 PyObject *resultobj = 0;
6905 wxRect *arg1 = (wxRect *) 0 ;
6906 wxPoint result;
6907 void *argp1 = 0 ;
6908 int res1 = 0 ;
6909 PyObject *swig_obj[1] ;
6910
6911 if (!args) SWIG_fail;
6912 swig_obj[0] = args;
6913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6914 if (!SWIG_IsOK(res1)) {
6915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6916 }
6917 arg1 = reinterpret_cast< wxRect * >(argp1);
6918 {
5acb46e0 6919 result = ((wxRect const *)arg1)->GetTopRight();
5acb46e0
RD
6920 if (PyErr_Occurred()) SWIG_fail;
6921 }
6922 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6923 return resultobj;
6924fail:
6925 return NULL;
6926}
6927
6928
6929SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6930 PyObject *resultobj = 0;
6931 wxRect *arg1 = (wxRect *) 0 ;
6932 wxPoint *arg2 = 0 ;
6933 void *argp1 = 0 ;
6934 int res1 = 0 ;
6935 wxPoint temp2 ;
6936 PyObject * obj0 = 0 ;
6937 PyObject * obj1 = 0 ;
6938 char * kwnames[] = {
6939 (char *) "self",(char *) "p", NULL
6940 };
6941
6942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6944 if (!SWIG_IsOK(res1)) {
6945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6946 }
6947 arg1 = reinterpret_cast< wxRect * >(argp1);
6948 {
6949 arg2 = &temp2;
6950 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6951 }
6952 {
5acb46e0 6953 (arg1)->SetTopRight((wxPoint const &)*arg2);
5acb46e0
RD
6954 if (PyErr_Occurred()) SWIG_fail;
6955 }
6956 resultobj = SWIG_Py_Void();
6957 return resultobj;
6958fail:
6959 return NULL;
6960}
6961
6962
6963SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6964 PyObject *resultobj = 0;
6965 wxRect *arg1 = (wxRect *) 0 ;
6966 wxPoint result;
6967 void *argp1 = 0 ;
6968 int res1 = 0 ;
6969 PyObject *swig_obj[1] ;
6970
6971 if (!args) SWIG_fail;
6972 swig_obj[0] = args;
6973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6974 if (!SWIG_IsOK(res1)) {
6975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6976 }
6977 arg1 = reinterpret_cast< wxRect * >(argp1);
6978 {
5acb46e0 6979 result = ((wxRect const *)arg1)->GetBottomLeft();
5acb46e0
RD
6980 if (PyErr_Occurred()) SWIG_fail;
6981 }
6982 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6983 return resultobj;
6984fail:
6985 return NULL;
6986}
6987
6988
6989SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6990 PyObject *resultobj = 0;
6991 wxRect *arg1 = (wxRect *) 0 ;
6992 wxPoint *arg2 = 0 ;
6993 void *argp1 = 0 ;
6994 int res1 = 0 ;
6995 wxPoint temp2 ;
6996 PyObject * obj0 = 0 ;
6997 PyObject * obj1 = 0 ;
6998 char * kwnames[] = {
6999 (char *) "self",(char *) "p", NULL
7000 };
7001
7002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7004 if (!SWIG_IsOK(res1)) {
7005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7006 }
7007 arg1 = reinterpret_cast< wxRect * >(argp1);
7008 {
7009 arg2 = &temp2;
7010 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7011 }
7012 {
5acb46e0 7013 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
5acb46e0
RD
7014 if (PyErr_Occurred()) SWIG_fail;
7015 }
7016 resultobj = SWIG_Py_Void();
7017 return resultobj;
7018fail:
7019 return NULL;
7020}
7021
7022
1bd55598
RD
7023SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7024 PyObject *resultobj = 0;
7025 wxRect *arg1 = (wxRect *) 0 ;
7026 int result;
7027 void *argp1 = 0 ;
7028 int res1 = 0 ;
7029 PyObject *swig_obj[1] ;
7030
7031 if (!args) SWIG_fail;
7032 swig_obj[0] = args;
7033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7034 if (!SWIG_IsOK(res1)) {
7035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7036 }
7037 arg1 = reinterpret_cast< wxRect * >(argp1);
7038 {
1bd55598 7039 result = (int)((wxRect const *)arg1)->GetLeft();
1bd55598
RD
7040 if (PyErr_Occurred()) SWIG_fail;
7041 }
7042 resultobj = SWIG_From_int(static_cast< int >(result));
7043 return resultobj;
7044fail:
7045 return NULL;
d55e5bfc
RD
7046}
7047
7048
1bd55598
RD
7049SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7050 PyObject *resultobj = 0;
7051 wxRect *arg1 = (wxRect *) 0 ;
7052 int result;
7053 void *argp1 = 0 ;
7054 int res1 = 0 ;
7055 PyObject *swig_obj[1] ;
7056
7057 if (!args) SWIG_fail;
7058 swig_obj[0] = args;
7059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7060 if (!SWIG_IsOK(res1)) {
7061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7062 }
7063 arg1 = reinterpret_cast< wxRect * >(argp1);
7064 {
1bd55598 7065 result = (int)((wxRect const *)arg1)->GetTop();
1bd55598
RD
7066 if (PyErr_Occurred()) SWIG_fail;
7067 }
7068 resultobj = SWIG_From_int(static_cast< int >(result));
7069 return resultobj;
7070fail:
7071 return NULL;
d55e5bfc
RD
7072}
7073
7074
1bd55598
RD
7075SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7076 PyObject *resultobj = 0;
7077 wxRect *arg1 = (wxRect *) 0 ;
7078 int result;
7079 void *argp1 = 0 ;
7080 int res1 = 0 ;
7081 PyObject *swig_obj[1] ;
7082
7083 if (!args) SWIG_fail;
7084 swig_obj[0] = args;
7085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7086 if (!SWIG_IsOK(res1)) {
7087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7088 }
7089 arg1 = reinterpret_cast< wxRect * >(argp1);
7090 {
1bd55598 7091 result = (int)((wxRect const *)arg1)->GetBottom();
1bd55598
RD
7092 if (PyErr_Occurred()) SWIG_fail;
7093 }
7094 resultobj = SWIG_From_int(static_cast< int >(result));
7095 return resultobj;
7096fail:
7097 return NULL;
d55e5bfc
RD
7098}
7099
7100
1bd55598
RD
7101SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7102 PyObject *resultobj = 0;
7103 wxRect *arg1 = (wxRect *) 0 ;
7104 int result;
7105 void *argp1 = 0 ;
7106 int res1 = 0 ;
7107 PyObject *swig_obj[1] ;
7108
7109 if (!args) SWIG_fail;
7110 swig_obj[0] = args;
7111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7112 if (!SWIG_IsOK(res1)) {
7113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7114 }
7115 arg1 = reinterpret_cast< wxRect * >(argp1);
7116 {
1bd55598 7117 result = (int)((wxRect const *)arg1)->GetRight();
1bd55598
RD
7118 if (PyErr_Occurred()) SWIG_fail;
7119 }
7120 resultobj = SWIG_From_int(static_cast< int >(result));
7121 return resultobj;
7122fail:
7123 return NULL;
7124}
7125
7126
7127SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7128 PyObject *resultobj = 0;
7129 wxRect *arg1 = (wxRect *) 0 ;
7130 int arg2 ;
7131 void *argp1 = 0 ;
7132 int res1 = 0 ;
7133 int val2 ;
7134 int ecode2 = 0 ;
7135 PyObject * obj0 = 0 ;
7136 PyObject * obj1 = 0 ;
7137 char * kwnames[] = {
7138 (char *) "self",(char *) "left", NULL
7139 };
7140
7141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7143 if (!SWIG_IsOK(res1)) {
7144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7145 }
7146 arg1 = reinterpret_cast< wxRect * >(argp1);
7147 ecode2 = SWIG_AsVal_int(obj1, &val2);
7148 if (!SWIG_IsOK(ecode2)) {
7149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7150 }
7151 arg2 = static_cast< int >(val2);
7152 {
1bd55598 7153 (arg1)->SetLeft(arg2);
1bd55598
RD
7154 if (PyErr_Occurred()) SWIG_fail;
7155 }
7156 resultobj = SWIG_Py_Void();
7157 return resultobj;
7158fail:
7159 return NULL;
7160}
7161
7162
7163SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7164 PyObject *resultobj = 0;
7165 wxRect *arg1 = (wxRect *) 0 ;
7166 int arg2 ;
7167 void *argp1 = 0 ;
7168 int res1 = 0 ;
7169 int val2 ;
7170 int ecode2 = 0 ;
7171 PyObject * obj0 = 0 ;
7172 PyObject * obj1 = 0 ;
7173 char * kwnames[] = {
7174 (char *) "self",(char *) "right", NULL
7175 };
7176
7177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7179 if (!SWIG_IsOK(res1)) {
7180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7181 }
7182 arg1 = reinterpret_cast< wxRect * >(argp1);
7183 ecode2 = SWIG_AsVal_int(obj1, &val2);
7184 if (!SWIG_IsOK(ecode2)) {
7185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7186 }
7187 arg2 = static_cast< int >(val2);
7188 {
1bd55598 7189 (arg1)->SetRight(arg2);
1bd55598
RD
7190 if (PyErr_Occurred()) SWIG_fail;
7191 }
7192 resultobj = SWIG_Py_Void();
7193 return resultobj;
7194fail:
7195 return NULL;
7196}
7197
7198
7199SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7200 PyObject *resultobj = 0;
7201 wxRect *arg1 = (wxRect *) 0 ;
7202 int arg2 ;
7203 void *argp1 = 0 ;
7204 int res1 = 0 ;
7205 int val2 ;
7206 int ecode2 = 0 ;
7207 PyObject * obj0 = 0 ;
7208 PyObject * obj1 = 0 ;
7209 char * kwnames[] = {
7210 (char *) "self",(char *) "top", NULL
7211 };
7212
7213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7215 if (!SWIG_IsOK(res1)) {
7216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7217 }
7218 arg1 = reinterpret_cast< wxRect * >(argp1);
7219 ecode2 = SWIG_AsVal_int(obj1, &val2);
7220 if (!SWIG_IsOK(ecode2)) {
7221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7222 }
7223 arg2 = static_cast< int >(val2);
7224 {
1bd55598 7225 (arg1)->SetTop(arg2);
1bd55598
RD
7226 if (PyErr_Occurred()) SWIG_fail;
7227 }
7228 resultobj = SWIG_Py_Void();
7229 return resultobj;
7230fail:
7231 return NULL;
7232}
7233
7234
7235SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7236 PyObject *resultobj = 0;
7237 wxRect *arg1 = (wxRect *) 0 ;
7238 int arg2 ;
7239 void *argp1 = 0 ;
7240 int res1 = 0 ;
7241 int val2 ;
7242 int ecode2 = 0 ;
7243 PyObject * obj0 = 0 ;
7244 PyObject * obj1 = 0 ;
7245 char * kwnames[] = {
7246 (char *) "self",(char *) "bottom", NULL
7247 };
7248
7249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7251 if (!SWIG_IsOK(res1)) {
7252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7253 }
7254 arg1 = reinterpret_cast< wxRect * >(argp1);
7255 ecode2 = SWIG_AsVal_int(obj1, &val2);
7256 if (!SWIG_IsOK(ecode2)) {
7257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7258 }
7259 arg2 = static_cast< int >(val2);
7260 {
1bd55598 7261 (arg1)->SetBottom(arg2);
1bd55598
RD
7262 if (PyErr_Occurred()) SWIG_fail;
7263 }
7264 resultobj = SWIG_Py_Void();
7265 return resultobj;
7266fail:
7267 return NULL;
7268}
7269
7270
7271SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7272 PyObject *resultobj = 0;
7273 wxRect *arg1 = (wxRect *) 0 ;
7274 int arg2 ;
7275 int arg3 ;
7276 wxRect *result = 0 ;
7277 void *argp1 = 0 ;
7278 int res1 = 0 ;
7279 int val2 ;
7280 int ecode2 = 0 ;
7281 int val3 ;
7282 int ecode3 = 0 ;
7283 PyObject * obj0 = 0 ;
7284 PyObject * obj1 = 0 ;
7285 PyObject * obj2 = 0 ;
7286 char * kwnames[] = {
7287 (char *) "self",(char *) "dx",(char *) "dy", NULL
7288 };
7289
7290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7292 if (!SWIG_IsOK(res1)) {
7293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7294 }
7295 arg1 = reinterpret_cast< wxRect * >(argp1);
7296 ecode2 = SWIG_AsVal_int(obj1, &val2);
7297 if (!SWIG_IsOK(ecode2)) {
7298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7299 }
7300 arg2 = static_cast< int >(val2);
7301 ecode3 = SWIG_AsVal_int(obj2, &val3);
7302 if (!SWIG_IsOK(ecode3)) {
7303 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7304 }
7305 arg3 = static_cast< int >(val3);
7306 {
d55e5bfc 7307 {
1bd55598
RD
7308 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7309 result = (wxRect *) &_result_ref;
d55e5bfc 7310 }
1bd55598
RD
7311 if (PyErr_Occurred()) SWIG_fail;
7312 }
7313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7314 return resultobj;
7315fail:
7316 return NULL;
7317}
7318
7319
7320SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7321 PyObject *resultobj = 0;
7322 wxRect *arg1 = (wxRect *) 0 ;
7323 int arg2 ;
7324 int arg3 ;
7325 wxRect *result = 0 ;
7326 void *argp1 = 0 ;
7327 int res1 = 0 ;
7328 int val2 ;
7329 int ecode2 = 0 ;
7330 int val3 ;
7331 int ecode3 = 0 ;
7332 PyObject * obj0 = 0 ;
7333 PyObject * obj1 = 0 ;
7334 PyObject * obj2 = 0 ;
7335 char * kwnames[] = {
7336 (char *) "self",(char *) "dx",(char *) "dy", NULL
7337 };
7338
7339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7341 if (!SWIG_IsOK(res1)) {
7342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7343 }
7344 arg1 = reinterpret_cast< wxRect * >(argp1);
7345 ecode2 = SWIG_AsVal_int(obj1, &val2);
7346 if (!SWIG_IsOK(ecode2)) {
7347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7348 }
7349 arg2 = static_cast< int >(val2);
7350 ecode3 = SWIG_AsVal_int(obj2, &val3);
7351 if (!SWIG_IsOK(ecode3)) {
7352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7353 }
7354 arg3 = static_cast< int >(val3);
7355 {
d55e5bfc 7356 {
1bd55598
RD
7357 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7358 result = (wxRect *) &_result_ref;
d55e5bfc 7359 }
1bd55598
RD
7360 if (PyErr_Occurred()) SWIG_fail;
7361 }
7362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7363 return resultobj;
7364fail:
7365 return NULL;
7366}
7367
7368
7369SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7370 PyObject *resultobj = 0;
7371 wxRect *arg1 = (wxRect *) 0 ;
7372 int arg2 ;
7373 int arg3 ;
7374 void *argp1 = 0 ;
7375 int res1 = 0 ;
7376 int val2 ;
7377 int ecode2 = 0 ;
7378 int val3 ;
7379 int ecode3 = 0 ;
7380 PyObject * obj0 = 0 ;
7381 PyObject * obj1 = 0 ;
7382 PyObject * obj2 = 0 ;
7383 char * kwnames[] = {
7384 (char *) "self",(char *) "dx",(char *) "dy", NULL
7385 };
7386
7387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7389 if (!SWIG_IsOK(res1)) {
7390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7391 }
7392 arg1 = reinterpret_cast< wxRect * >(argp1);
7393 ecode2 = SWIG_AsVal_int(obj1, &val2);
7394 if (!SWIG_IsOK(ecode2)) {
7395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7396 }
7397 arg2 = static_cast< int >(val2);
7398 ecode3 = SWIG_AsVal_int(obj2, &val3);
7399 if (!SWIG_IsOK(ecode3)) {
7400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7401 }
7402 arg3 = static_cast< int >(val3);
7403 {
1bd55598 7404 (arg1)->Offset(arg2,arg3);
1bd55598
RD
7405 if (PyErr_Occurred()) SWIG_fail;
7406 }
7407 resultobj = SWIG_Py_Void();
7408 return resultobj;
7409fail:
7410 return NULL;
7411}
7412
7413
7414SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7415 PyObject *resultobj = 0;
7416 wxRect *arg1 = (wxRect *) 0 ;
7417 wxPoint *arg2 = 0 ;
7418 void *argp1 = 0 ;
7419 int res1 = 0 ;
7420 wxPoint temp2 ;
7421 PyObject * obj0 = 0 ;
7422 PyObject * obj1 = 0 ;
7423 char * kwnames[] = {
7424 (char *) "self",(char *) "pt", NULL
7425 };
7426
7427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7429 if (!SWIG_IsOK(res1)) {
7430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7431 }
7432 arg1 = reinterpret_cast< wxRect * >(argp1);
7433 {
7434 arg2 = &temp2;
7435 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7436 }
7437 {
1bd55598 7438 (arg1)->Offset((wxPoint const &)*arg2);
1bd55598
RD
7439 if (PyErr_Occurred()) SWIG_fail;
7440 }
7441 resultobj = SWIG_Py_Void();
7442 return resultobj;
7443fail:
7444 return NULL;
7445}
7446
7447
7448SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7449 PyObject *resultobj = 0;
7450 wxRect *arg1 = (wxRect *) 0 ;
7451 wxRect *arg2 = 0 ;
7452 wxRect result;
7453 void *argp1 = 0 ;
7454 int res1 = 0 ;
7455 wxRect temp2 ;
7456 PyObject * obj0 = 0 ;
7457 PyObject * obj1 = 0 ;
7458 char * kwnames[] = {
7459 (char *) "self",(char *) "rect", NULL
7460 };
7461
7462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7464 if (!SWIG_IsOK(res1)) {
7465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7466 }
7467 arg1 = reinterpret_cast< wxRect * >(argp1);
7468 {
7469 arg2 = &temp2;
7470 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7471 }
7472 {
1bd55598 7473 result = (arg1)->Intersect((wxRect const &)*arg2);
1bd55598
RD
7474 if (PyErr_Occurred()) SWIG_fail;
7475 }
7476 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7477 return resultobj;
7478fail:
7479 return NULL;
7480}
7481
7482
7483SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7484 PyObject *resultobj = 0;
7485 wxRect *arg1 = (wxRect *) 0 ;
7486 wxRect *arg2 = 0 ;
7487 wxRect result;
7488 void *argp1 = 0 ;
7489 int res1 = 0 ;
7490 wxRect temp2 ;
7491 PyObject * obj0 = 0 ;
7492 PyObject * obj1 = 0 ;
7493 char * kwnames[] = {
7494 (char *) "self",(char *) "rect", NULL
7495 };
7496
7497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7499 if (!SWIG_IsOK(res1)) {
7500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7501 }
7502 arg1 = reinterpret_cast< wxRect * >(argp1);
7503 {
7504 arg2 = &temp2;
7505 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7506 }
7507 {
1bd55598 7508 result = (arg1)->Union((wxRect const &)*arg2);
1bd55598
RD
7509 if (PyErr_Occurred()) SWIG_fail;
7510 }
7511 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7512 return resultobj;
7513fail:
7514 return NULL;
7515}
7516
7517
7518SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7519 PyObject *resultobj = 0;
7520 wxRect *arg1 = (wxRect *) 0 ;
7521 wxRect *arg2 = 0 ;
7522 wxRect result;
7523 void *argp1 = 0 ;
7524 int res1 = 0 ;
7525 wxRect temp2 ;
7526 PyObject * obj0 = 0 ;
7527 PyObject * obj1 = 0 ;
7528 char * kwnames[] = {
7529 (char *) "self",(char *) "rect", NULL
7530 };
7531
7532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7534 if (!SWIG_IsOK(res1)) {
7535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7536 }
7537 arg1 = reinterpret_cast< wxRect * >(argp1);
7538 {
7539 arg2 = &temp2;
7540 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7541 }
7542 {
1bd55598 7543 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
1bd55598
RD
7544 if (PyErr_Occurred()) SWIG_fail;
7545 }
7546 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7547 return resultobj;
7548fail:
7549 return NULL;
7550}
7551
7552
7553SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7554 PyObject *resultobj = 0;
7555 wxRect *arg1 = (wxRect *) 0 ;
7556 wxRect *arg2 = 0 ;
7557 wxRect *result = 0 ;
7558 void *argp1 = 0 ;
7559 int res1 = 0 ;
7560 wxRect temp2 ;
7561 PyObject * obj0 = 0 ;
7562 PyObject * obj1 = 0 ;
7563 char * kwnames[] = {
7564 (char *) "self",(char *) "rect", NULL
7565 };
7566
7567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7569 if (!SWIG_IsOK(res1)) {
7570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7571 }
7572 arg1 = reinterpret_cast< wxRect * >(argp1);
7573 {
7574 arg2 = &temp2;
7575 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7576 }
7577 {
d55e5bfc 7578 {
1bd55598
RD
7579 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7580 result = (wxRect *) &_result_ref;
d55e5bfc 7581 }
1bd55598
RD
7582 if (PyErr_Occurred()) SWIG_fail;
7583 }
7584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7585 return resultobj;
7586fail:
7587 return NULL;
7588}
7589
7590
7591SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7592 PyObject *resultobj = 0;
7593 wxRect *arg1 = (wxRect *) 0 ;
e9d6f3a4 7594 PyObject *arg2 = (PyObject *) 0 ;
1bd55598
RD
7595 bool result;
7596 void *argp1 = 0 ;
7597 int res1 = 0 ;
1bd55598
RD
7598 PyObject * obj0 = 0 ;
7599 PyObject * obj1 = 0 ;
7600 char * kwnames[] = {
e9d6f3a4 7601 (char *) "self",(char *) "other", NULL
1bd55598
RD
7602 };
7603
7604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7606 if (!SWIG_IsOK(res1)) {
e9d6f3a4 7607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
1bd55598
RD
7608 }
7609 arg1 = reinterpret_cast< wxRect * >(argp1);
e9d6f3a4 7610 arg2 = obj1;
1bd55598 7611 {
e9d6f3a4 7612 result = (bool)wxRect___eq__(arg1,arg2);
1bd55598
RD
7613 if (PyErr_Occurred()) SWIG_fail;
7614 }
7615 {
7616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7617 }
7618 return resultobj;
7619fail:
7620 return NULL;
7621}
7622
7623
7624SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7625 PyObject *resultobj = 0;
7626 wxRect *arg1 = (wxRect *) 0 ;
e9d6f3a4 7627 PyObject *arg2 = (PyObject *) 0 ;
1bd55598
RD
7628 bool result;
7629 void *argp1 = 0 ;
7630 int res1 = 0 ;
1bd55598
RD
7631 PyObject * obj0 = 0 ;
7632 PyObject * obj1 = 0 ;
7633 char * kwnames[] = {
e9d6f3a4 7634 (char *) "self",(char *) "other", NULL
1bd55598
RD
7635 };
7636
7637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7639 if (!SWIG_IsOK(res1)) {
e9d6f3a4 7640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
1bd55598
RD
7641 }
7642 arg1 = reinterpret_cast< wxRect * >(argp1);
e9d6f3a4 7643 arg2 = obj1;
1bd55598 7644 {
e9d6f3a4 7645 result = (bool)wxRect___ne__(arg1,arg2);
1bd55598
RD
7646 if (PyErr_Occurred()) SWIG_fail;
7647 }
7648 {
7649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7650 }
7651 return resultobj;
7652fail:
7653 return NULL;
7654}
7655
7656
33d6fd3b 7657SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
1bd55598
RD
7658 PyObject *resultobj = 0;
7659 wxRect *arg1 = (wxRect *) 0 ;
7660 int arg2 ;
7661 int arg3 ;
7662 bool result;
7663 void *argp1 = 0 ;
7664 int res1 = 0 ;
7665 int val2 ;
7666 int ecode2 = 0 ;
7667 int val3 ;
7668 int ecode3 = 0 ;
7669 PyObject * obj0 = 0 ;
7670 PyObject * obj1 = 0 ;
7671 PyObject * obj2 = 0 ;
7672 char * kwnames[] = {
7673 (char *) "self",(char *) "x",(char *) "y", NULL
7674 };
7675
33d6fd3b 7676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
1bd55598
RD
7677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7678 if (!SWIG_IsOK(res1)) {
33d6fd3b 7679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
1bd55598
RD
7680 }
7681 arg1 = reinterpret_cast< wxRect * >(argp1);
7682 ecode2 = SWIG_AsVal_int(obj1, &val2);
7683 if (!SWIG_IsOK(ecode2)) {
33d6fd3b 7684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
1bd55598
RD
7685 }
7686 arg2 = static_cast< int >(val2);
7687 ecode3 = SWIG_AsVal_int(obj2, &val3);
7688 if (!SWIG_IsOK(ecode3)) {
33d6fd3b 7689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
1bd55598
RD
7690 }
7691 arg3 = static_cast< int >(val3);
7692 {
33d6fd3b 7693 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
1bd55598
RD
7694 if (PyErr_Occurred()) SWIG_fail;
7695 }
7696 {
7697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7698 }
7699 return resultobj;
7700fail:
7701 return NULL;
7702}
7703
7704
33d6fd3b 7705SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
1bd55598
RD
7706 PyObject *resultobj = 0;
7707 wxRect *arg1 = (wxRect *) 0 ;
7708 wxPoint *arg2 = 0 ;
7709 bool result;
7710 void *argp1 = 0 ;
7711 int res1 = 0 ;
7712 wxPoint temp2 ;
7713 PyObject * obj0 = 0 ;
7714 PyObject * obj1 = 0 ;
7715 char * kwnames[] = {
7716 (char *) "self",(char *) "pt", NULL
7717 };
7718
33d6fd3b 7719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
1bd55598
RD
7720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7721 if (!SWIG_IsOK(res1)) {
33d6fd3b 7722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
1bd55598
RD
7723 }
7724 arg1 = reinterpret_cast< wxRect * >(argp1);
7725 {
7726 arg2 = &temp2;
7727 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7728 }
7729 {
33d6fd3b 7730 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
1bd55598
RD
7731 if (PyErr_Occurred()) SWIG_fail;
7732 }
7733 {
7734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7735 }
7736 return resultobj;
7737fail:
7738 return NULL;
7739}
7740
7741
33d6fd3b 7742SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
fc46b7f3
RD
7743 PyObject *resultobj = 0;
7744 wxRect *arg1 = (wxRect *) 0 ;
7745 wxRect *arg2 = 0 ;
7746 bool result;
7747 void *argp1 = 0 ;
7748 int res1 = 0 ;
7749 wxRect temp2 ;
7750 PyObject * obj0 = 0 ;
7751 PyObject * obj1 = 0 ;
7752 char * kwnames[] = {
7753 (char *) "self",(char *) "rect", NULL
7754 };
7755
33d6fd3b 7756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
fc46b7f3
RD
7757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7758 if (!SWIG_IsOK(res1)) {
33d6fd3b 7759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
fc46b7f3
RD
7760 }
7761 arg1 = reinterpret_cast< wxRect * >(argp1);
7762 {
7763 arg2 = &temp2;
7764 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7765 }
7766 {
33d6fd3b 7767 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
fc46b7f3
RD
7768 if (PyErr_Occurred()) SWIG_fail;
7769 }
7770 {
7771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7772 }
7773 return resultobj;
7774fail:
7775 return NULL;
7776}
7777
7778
1bd55598
RD
7779SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7780 PyObject *resultobj = 0;
7781 wxRect *arg1 = (wxRect *) 0 ;
7782 wxRect *arg2 = 0 ;
7783 bool result;
7784 void *argp1 = 0 ;
7785 int res1 = 0 ;
7786 wxRect temp2 ;
7787 PyObject * obj0 = 0 ;
7788 PyObject * obj1 = 0 ;
7789 char * kwnames[] = {
7790 (char *) "self",(char *) "rect", NULL
7791 };
7792
7793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7795 if (!SWIG_IsOK(res1)) {
7796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7797 }
7798 arg1 = reinterpret_cast< wxRect * >(argp1);
7799 {
7800 arg2 = &temp2;
7801 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7802 }
7803 {
1bd55598 7804 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
1bd55598
RD
7805 if (PyErr_Occurred()) SWIG_fail;
7806 }
7807 {
7808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7809 }
7810 return resultobj;
7811fail:
7812 return NULL;
7813}
7814
7815
7816SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7817 PyObject *resultobj = 0;
7818 wxRect *arg1 = (wxRect *) 0 ;
7819 wxRect *arg2 = 0 ;
7820 int arg3 = (int) wxBOTH ;
7821 wxRect result;
7822 void *argp1 = 0 ;
7823 int res1 = 0 ;
7824 wxRect temp2 ;
7825 int val3 ;
7826 int ecode3 = 0 ;
7827 PyObject * obj0 = 0 ;
7828 PyObject * obj1 = 0 ;
7829 PyObject * obj2 = 0 ;
7830 char * kwnames[] = {
7831 (char *) "self",(char *) "r",(char *) "dir", NULL
7832 };
7833
7834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7836 if (!SWIG_IsOK(res1)) {
7837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7838 }
7839 arg1 = reinterpret_cast< wxRect * >(argp1);
7840 {
7841 arg2 = &temp2;
7842 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7843 }
7844 if (obj2) {
7845 ecode3 = SWIG_AsVal_int(obj2, &val3);
7846 if (!SWIG_IsOK(ecode3)) {
7847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7848 }
7849 arg3 = static_cast< int >(val3);
7850 }
7851 {
1bd55598 7852 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
1bd55598
RD
7853 if (PyErr_Occurred()) SWIG_fail;
7854 }
7855 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7856 return resultobj;
7857fail:
7858 return NULL;
7859}
7860
7861
7862SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7863 PyObject *resultobj = 0;
7864 wxRect *arg1 = (wxRect *) 0 ;
7865 int arg2 ;
7866 void *argp1 = 0 ;
7867 int res1 = 0 ;
7868 int val2 ;
7869 int ecode2 = 0 ;
7870 PyObject *swig_obj[2] ;
7871
7872 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7874 if (!SWIG_IsOK(res1)) {
7875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7876 }
7877 arg1 = reinterpret_cast< wxRect * >(argp1);
7878 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7879 if (!SWIG_IsOK(ecode2)) {
7880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7881 }
7882 arg2 = static_cast< int >(val2);
7883 if (arg1) (arg1)->x = arg2;
7884
7885 resultobj = SWIG_Py_Void();
7886 return resultobj;
7887fail:
7888 return NULL;
d55e5bfc
RD
7889}
7890
7891
1bd55598
RD
7892SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7893 PyObject *resultobj = 0;
7894 wxRect *arg1 = (wxRect *) 0 ;
7895 int result;
7896 void *argp1 = 0 ;
7897 int res1 = 0 ;
7898 PyObject *swig_obj[1] ;
7899
7900 if (!args) SWIG_fail;
7901 swig_obj[0] = args;
7902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7903 if (!SWIG_IsOK(res1)) {
7904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7905 }
7906 arg1 = reinterpret_cast< wxRect * >(argp1);
7907 result = (int) ((arg1)->x);
7908 resultobj = SWIG_From_int(static_cast< int >(result));
7909 return resultobj;
7910fail:
7911 return NULL;
7912}
7913
7914
7915SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7916 PyObject *resultobj = 0;
7917 wxRect *arg1 = (wxRect *) 0 ;
7918 int arg2 ;
7919 void *argp1 = 0 ;
7920 int res1 = 0 ;
7921 int val2 ;
7922 int ecode2 = 0 ;
7923 PyObject *swig_obj[2] ;
7924
7925 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7927 if (!SWIG_IsOK(res1)) {
7928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7929 }
7930 arg1 = reinterpret_cast< wxRect * >(argp1);
7931 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7932 if (!SWIG_IsOK(ecode2)) {
7933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7934 }
7935 arg2 = static_cast< int >(val2);
7936 if (arg1) (arg1)->y = arg2;
7937
7938 resultobj = SWIG_Py_Void();
7939 return resultobj;
7940fail:
7941 return NULL;
d55e5bfc
RD
7942}
7943
7944
1bd55598
RD
7945SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7946 PyObject *resultobj = 0;
7947 wxRect *arg1 = (wxRect *) 0 ;
7948 int result;
7949 void *argp1 = 0 ;
7950 int res1 = 0 ;
7951 PyObject *swig_obj[1] ;
7952
7953 if (!args) SWIG_fail;
7954 swig_obj[0] = args;
7955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7956 if (!SWIG_IsOK(res1)) {
7957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7958 }
7959 arg1 = reinterpret_cast< wxRect * >(argp1);
7960 result = (int) ((arg1)->y);
7961 resultobj = SWIG_From_int(static_cast< int >(result));
7962 return resultobj;
7963fail:
7964 return NULL;
7965}
7966
7967
7968SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7969 PyObject *resultobj = 0;
7970 wxRect *arg1 = (wxRect *) 0 ;
7971 int arg2 ;
7972 void *argp1 = 0 ;
7973 int res1 = 0 ;
7974 int val2 ;
7975 int ecode2 = 0 ;
7976 PyObject *swig_obj[2] ;
7977
7978 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7980 if (!SWIG_IsOK(res1)) {
7981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7982 }
7983 arg1 = reinterpret_cast< wxRect * >(argp1);
7984 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7985 if (!SWIG_IsOK(ecode2)) {
7986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7987 }
7988 arg2 = static_cast< int >(val2);
7989 if (arg1) (arg1)->width = arg2;
7990
7991 resultobj = SWIG_Py_Void();
7992 return resultobj;
7993fail:
7994 return NULL;
d55e5bfc
RD
7995}
7996
7997
1bd55598
RD
7998SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7999 PyObject *resultobj = 0;
8000 wxRect *arg1 = (wxRect *) 0 ;
8001 int result;
8002 void *argp1 = 0 ;
8003 int res1 = 0 ;
8004 PyObject *swig_obj[1] ;
8005
8006 if (!args) SWIG_fail;
8007 swig_obj[0] = args;
8008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8009 if (!SWIG_IsOK(res1)) {
8010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8011 }
8012 arg1 = reinterpret_cast< wxRect * >(argp1);
8013 result = (int) ((arg1)->width);
8014 resultobj = SWIG_From_int(static_cast< int >(result));
8015 return resultobj;
8016fail:
8017 return NULL;
8018}
8019
8020
8021SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8022 PyObject *resultobj = 0;
8023 wxRect *arg1 = (wxRect *) 0 ;
8024 int arg2 ;
8025 void *argp1 = 0 ;
8026 int res1 = 0 ;
8027 int val2 ;
8028 int ecode2 = 0 ;
8029 PyObject *swig_obj[2] ;
8030
8031 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8033 if (!SWIG_IsOK(res1)) {
8034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8035 }
8036 arg1 = reinterpret_cast< wxRect * >(argp1);
8037 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8038 if (!SWIG_IsOK(ecode2)) {
8039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8040 }
8041 arg2 = static_cast< int >(val2);
8042 if (arg1) (arg1)->height = arg2;
8043
8044 resultobj = SWIG_Py_Void();
8045 return resultobj;
8046fail:
8047 return NULL;
d55e5bfc
RD
8048}
8049
8050
1bd55598
RD
8051SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8052 PyObject *resultobj = 0;
8053 wxRect *arg1 = (wxRect *) 0 ;
8054 int result;
8055 void *argp1 = 0 ;
8056 int res1 = 0 ;
8057 PyObject *swig_obj[1] ;
8058
8059 if (!args) SWIG_fail;
8060 swig_obj[0] = args;
8061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8062 if (!SWIG_IsOK(res1)) {
8063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8064 }
8065 arg1 = reinterpret_cast< wxRect * >(argp1);
8066 result = (int) ((arg1)->height);
8067 resultobj = SWIG_From_int(static_cast< int >(result));
8068 return resultobj;
8069fail:
8070 return NULL;
8071}
8072
8073
8074SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8075 PyObject *resultobj = 0;
8076 wxRect *arg1 = (wxRect *) 0 ;
8077 int arg2 = (int) 0 ;
8078 int arg3 = (int) 0 ;
8079 int arg4 = (int) 0 ;
8080 int arg5 = (int) 0 ;
8081 void *argp1 = 0 ;
8082 int res1 = 0 ;
8083 int val2 ;
8084 int ecode2 = 0 ;
8085 int val3 ;
8086 int ecode3 = 0 ;
8087 int val4 ;
8088 int ecode4 = 0 ;
8089 int val5 ;
8090 int ecode5 = 0 ;
8091 PyObject * obj0 = 0 ;
8092 PyObject * obj1 = 0 ;
8093 PyObject * obj2 = 0 ;
8094 PyObject * obj3 = 0 ;
8095 PyObject * obj4 = 0 ;
8096 char * kwnames[] = {
8097 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8098 };
8099
8100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8102 if (!SWIG_IsOK(res1)) {
8103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8104 }
8105 arg1 = reinterpret_cast< wxRect * >(argp1);
8106 if (obj1) {
8107 ecode2 = SWIG_AsVal_int(obj1, &val2);
8108 if (!SWIG_IsOK(ecode2)) {
8109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8110 }
8111 arg2 = static_cast< int >(val2);
8112 }
8113 if (obj2) {
8114 ecode3 = SWIG_AsVal_int(obj2, &val3);
8115 if (!SWIG_IsOK(ecode3)) {
8116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8117 }
8118 arg3 = static_cast< int >(val3);
8119 }
8120 if (obj3) {
8121 ecode4 = SWIG_AsVal_int(obj3, &val4);
8122 if (!SWIG_IsOK(ecode4)) {
8123 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8124 }
8125 arg4 = static_cast< int >(val4);
8126 }
8127 if (obj4) {
8128 ecode5 = SWIG_AsVal_int(obj4, &val5);
8129 if (!SWIG_IsOK(ecode5)) {
8130 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8131 }
8132 arg5 = static_cast< int >(val5);
8133 }
8134 {
1bd55598 8135 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
1bd55598
RD
8136 if (PyErr_Occurred()) SWIG_fail;
8137 }
8138 resultobj = SWIG_Py_Void();
8139 return resultobj;
8140fail:
8141 return NULL;
070c48b4
RD
8142}
8143
8144
1bd55598
RD
8145SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8146 PyObject *resultobj = 0;
8147 wxRect *arg1 = (wxRect *) 0 ;
8148 PyObject *result = 0 ;
8149 void *argp1 = 0 ;
8150 int res1 = 0 ;
8151 PyObject *swig_obj[1] ;
8152
8153 if (!args) SWIG_fail;
8154 swig_obj[0] = args;
8155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8156 if (!SWIG_IsOK(res1)) {
8157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8158 }
8159 arg1 = reinterpret_cast< wxRect * >(argp1);
8160 {
1bd55598 8161 result = (PyObject *)wxRect_Get(arg1);
1bd55598
RD
8162 if (PyErr_Occurred()) SWIG_fail;
8163 }
8164 resultobj = result;
8165 return resultobj;
8166fail:
8167 return NULL;
d55e5bfc
RD
8168}
8169
8170
1bd55598
RD
8171SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8172 PyObject *obj;
8173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8174 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8175 return SWIG_Py_Void();
d55e5bfc
RD
8176}
8177
1bd55598
RD
8178SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8179 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
8180}
8181
1bd55598
RD
8182SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8183 PyObject *resultobj = 0;
8184 wxRect *arg1 = (wxRect *) 0 ;
8185 wxRect *arg2 = (wxRect *) 0 ;
8186 PyObject *result = 0 ;
8187 void *argp1 = 0 ;
8188 int res1 = 0 ;
8189 void *argp2 = 0 ;
8190 int res2 = 0 ;
8191 PyObject * obj0 = 0 ;
8192 PyObject * obj1 = 0 ;
8193 char * kwnames[] = {
8194 (char *) "r1",(char *) "r2", NULL
8195 };
8196
8197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8199 if (!SWIG_IsOK(res1)) {
8200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8201 }
8202 arg1 = reinterpret_cast< wxRect * >(argp1);
8203 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8204 if (!SWIG_IsOK(res2)) {
8205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8206 }
8207 arg2 = reinterpret_cast< wxRect * >(argp2);
8208 {
8209 if (!wxPyCheckForApp()) SWIG_fail;
8210 PyThreadState* __tstate = wxPyBeginAllowThreads();
8211 result = (PyObject *)wxIntersectRect(arg1,arg2);
8212 wxPyEndAllowThreads(__tstate);
8213 if (PyErr_Occurred()) SWIG_fail;
8214 }
8215 resultobj = result;
8216 return resultobj;
8217fail:
8218 return NULL;
8219}
8220
8221
8222SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8223 PyObject *resultobj = 0;
8224 double arg1 = (double) 0.0 ;
8225 double arg2 = (double) 0.0 ;
8226 wxPoint2D *result = 0 ;
8227 double val1 ;
8228 int ecode1 = 0 ;
8229 double val2 ;
8230 int ecode2 = 0 ;
8231 PyObject * obj0 = 0 ;
8232 PyObject * obj1 = 0 ;
8233 char * kwnames[] = {
8234 (char *) "x",(char *) "y", NULL
8235 };
8236
8237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8238 if (obj0) {
8239 ecode1 = SWIG_AsVal_double(obj0, &val1);
8240 if (!SWIG_IsOK(ecode1)) {
8241 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8242 }
8243 arg1 = static_cast< double >(val1);
8244 }
8245 if (obj1) {
8246 ecode2 = SWIG_AsVal_double(obj1, &val2);
8247 if (!SWIG_IsOK(ecode2)) {
8248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8249 }
8250 arg2 = static_cast< double >(val2);
8251 }
8252 {
1bd55598 8253 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
1bd55598
RD
8254 if (PyErr_Occurred()) SWIG_fail;
8255 }
8256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8257 return resultobj;
8258fail:
8259 return NULL;
d55e5bfc
RD
8260}
8261
8262
1bd55598
RD
8263SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8264 PyObject *resultobj = 0;
8265 wxPoint2D *arg1 = 0 ;
8266 wxPoint2D *result = 0 ;
8267 wxPoint2D temp1 ;
8268 PyObject * obj0 = 0 ;
8269 char * kwnames[] = {
8270 (char *) "pt", NULL
8271 };
8272
8273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8274 {
8275 arg1 = &temp1;
8276 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8277 }
8278 {
1bd55598 8279 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
1bd55598
RD
8280 if (PyErr_Occurred()) SWIG_fail;
8281 }
8282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8283 return resultobj;
8284fail:
8285 return NULL;
d55e5bfc
RD
8286}
8287
8288
1bd55598
RD
8289SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8290 PyObject *resultobj = 0;
8291 wxPoint *arg1 = 0 ;
8292 wxPoint2D *result = 0 ;
8293 wxPoint temp1 ;
8294 PyObject * obj0 = 0 ;
8295 char * kwnames[] = {
8296 (char *) "pt", NULL
8297 };
8298
8299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8300 {
8301 arg1 = &temp1;
8302 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8303 }
8304 {
1bd55598 8305 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
1bd55598
RD
8306 if (PyErr_Occurred()) SWIG_fail;
8307 }
8308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8309 return resultobj;
8310fail:
8311 return NULL;
8312}
8313
8314
b39fe951
RD
8315SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8316 PyObject *resultobj = 0;
8317 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8318 void *argp1 = 0 ;
8319 int res1 = 0 ;
8320 PyObject *swig_obj[1] ;
8321
8322 if (!args) SWIG_fail;
8323 swig_obj[0] = args;
8324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8325 if (!SWIG_IsOK(res1)) {
8326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8327 }
8328 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8329 {
b39fe951
RD
8330 delete arg1;
8331
b39fe951
RD
8332 if (PyErr_Occurred()) SWIG_fail;
8333 }
8334 resultobj = SWIG_Py_Void();
8335 return resultobj;
8336fail:
8337 return NULL;
8338}
8339
8340
1bd55598
RD
8341SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8342 PyObject *resultobj = 0;
8343 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8344 int *arg2 = (int *) 0 ;
8345 int *arg3 = (int *) 0 ;
8346 void *argp1 = 0 ;
8347 int res1 = 0 ;
8348 int temp2 ;
8349 int res2 = SWIG_TMPOBJ ;
8350 int temp3 ;
8351 int res3 = SWIG_TMPOBJ ;
8352 PyObject *swig_obj[1] ;
8353
8354 arg2 = &temp2;
8355 arg3 = &temp3;
8356 if (!args) SWIG_fail;
8357 swig_obj[0] = args;
8358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8359 if (!SWIG_IsOK(res1)) {
8360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8361 }
8362 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8363 {
1bd55598 8364 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
1bd55598
RD
8365 if (PyErr_Occurred()) SWIG_fail;
8366 }
8367 resultobj = SWIG_Py_Void();
8368 if (SWIG_IsTmpObj(res2)) {
8369 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8370 } else {
8371 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8373 }
8374 if (SWIG_IsTmpObj(res3)) {
8375 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8376 } else {
8377 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8379 }
8380 return resultobj;
8381fail:
8382 return NULL;
8383}
8384
8385
8386SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8387 PyObject *resultobj = 0;
8388 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8389 int *arg2 = (int *) 0 ;
8390 int *arg3 = (int *) 0 ;
8391 void *argp1 = 0 ;
8392 int res1 = 0 ;
8393 int temp2 ;
8394 int res2 = SWIG_TMPOBJ ;
8395 int temp3 ;
8396 int res3 = SWIG_TMPOBJ ;
8397 PyObject *swig_obj[1] ;
8398
8399 arg2 = &temp2;
8400 arg3 = &temp3;
8401 if (!args) SWIG_fail;
8402 swig_obj[0] = args;
8403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8404 if (!SWIG_IsOK(res1)) {
8405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8406 }
8407 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8408 {
1bd55598 8409 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
1bd55598
RD
8410 if (PyErr_Occurred()) SWIG_fail;
8411 }
8412 resultobj = SWIG_Py_Void();
8413 if (SWIG_IsTmpObj(res2)) {
8414 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8415 } else {
8416 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8417 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8418 }
8419 if (SWIG_IsTmpObj(res3)) {
8420 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8421 } else {
8422 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8423 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8424 }
8425 return resultobj;
8426fail:
8427 return NULL;
d55e5bfc
RD
8428}
8429
8430
1bd55598
RD
8431SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8432 PyObject *resultobj = 0;
8433 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8434 double result;
8435 void *argp1 = 0 ;
8436 int res1 = 0 ;
8437 PyObject *swig_obj[1] ;
8438
8439 if (!args) SWIG_fail;
8440 swig_obj[0] = args;
8441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8442 if (!SWIG_IsOK(res1)) {
8443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8444 }
8445 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8446 {
1bd55598 8447 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
1bd55598
RD
8448 if (PyErr_Occurred()) SWIG_fail;
8449 }
8450 resultobj = SWIG_From_double(static_cast< double >(result));
8451 return resultobj;
8452fail:
8453 return NULL;
d55e5bfc
RD
8454}
8455
8456
1bd55598
RD
8457SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8458 PyObject *resultobj = 0;
8459 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8460 double result;
8461 void *argp1 = 0 ;
8462 int res1 = 0 ;
8463 PyObject *swig_obj[1] ;
8464
8465 if (!args) SWIG_fail;
8466 swig_obj[0] = args;
8467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8468 if (!SWIG_IsOK(res1)) {
8469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8470 }
8471 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8472 {
1bd55598 8473 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
1bd55598
RD
8474 if (PyErr_Occurred()) SWIG_fail;
8475 }
8476 resultobj = SWIG_From_double(static_cast< double >(result));
8477 return resultobj;
8478fail:
8479 return NULL;
8480}
8481
8482
8483SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8484 PyObject *resultobj = 0;
8485 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8486 double arg2 ;
8487 void *argp1 = 0 ;
8488 int res1 = 0 ;
8489 double val2 ;
8490 int ecode2 = 0 ;
8491 PyObject * obj0 = 0 ;
8492 PyObject * obj1 = 0 ;
8493 char * kwnames[] = {
8494 (char *) "self",(char *) "length", NULL
8495 };
8496
8497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8499 if (!SWIG_IsOK(res1)) {
8500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8501 }
8502 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8503 ecode2 = SWIG_AsVal_double(obj1, &val2);
8504 if (!SWIG_IsOK(ecode2)) {
8505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8506 }
8507 arg2 = static_cast< double >(val2);
8508 {
1bd55598 8509 (arg1)->SetVectorLength(arg2);
1bd55598
RD
8510 if (PyErr_Occurred()) SWIG_fail;
8511 }
8512 resultobj = SWIG_Py_Void();
8513 return resultobj;
8514fail:
8515 return NULL;
8516}
8517
8518
8519SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8520 PyObject *resultobj = 0;
8521 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8522 double arg2 ;
8523 void *argp1 = 0 ;
8524 int res1 = 0 ;
8525 double val2 ;
8526 int ecode2 = 0 ;
8527 PyObject * obj0 = 0 ;
8528 PyObject * obj1 = 0 ;
8529 char * kwnames[] = {
8530 (char *) "self",(char *) "degrees", NULL
8531 };
8532
8533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8535 if (!SWIG_IsOK(res1)) {
8536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8537 }
8538 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8539 ecode2 = SWIG_AsVal_double(obj1, &val2);
8540 if (!SWIG_IsOK(ecode2)) {
8541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8542 }
8543 arg2 = static_cast< double >(val2);
8544 {
1bd55598 8545 (arg1)->SetVectorAngle(arg2);
1bd55598
RD
8546 if (PyErr_Occurred()) SWIG_fail;
8547 }
8548 resultobj = SWIG_Py_Void();
8549 return resultobj;
8550fail:
8551 return NULL;
8552}
8553
8554
8555SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8556 PyObject *resultobj = 0;
8557 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8558 wxPoint2D *arg2 = 0 ;
8559 double result;
8560 void *argp1 = 0 ;
8561 int res1 = 0 ;
8562 wxPoint2D temp2 ;
8563 PyObject * obj0 = 0 ;
8564 PyObject * obj1 = 0 ;
8565 char * kwnames[] = {
8566 (char *) "self",(char *) "pt", NULL
8567 };
8568
8569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8571 if (!SWIG_IsOK(res1)) {
8572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8573 }
8574 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8575 {
8576 arg2 = &temp2;
8577 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8578 }
8579 {
1bd55598 8580 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
1bd55598
RD
8581 if (PyErr_Occurred()) SWIG_fail;
8582 }
8583 resultobj = SWIG_From_double(static_cast< double >(result));
8584 return resultobj;
8585fail:
8586 return NULL;
8587}
8588
8589
8590SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8591 PyObject *resultobj = 0;
8592 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8593 wxPoint2D *arg2 = 0 ;
8594 double result;
8595 void *argp1 = 0 ;
8596 int res1 = 0 ;
8597 wxPoint2D temp2 ;
8598 PyObject * obj0 = 0 ;
8599 PyObject * obj1 = 0 ;
8600 char * kwnames[] = {
8601 (char *) "self",(char *) "pt", NULL
8602 };
8603
8604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8606 if (!SWIG_IsOK(res1)) {
8607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8608 }
8609 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8610 {
8611 arg2 = &temp2;
8612 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8613 }
8614 {
1bd55598 8615 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
1bd55598
RD
8616 if (PyErr_Occurred()) SWIG_fail;
8617 }
8618 resultobj = SWIG_From_double(static_cast< double >(result));
8619 return resultobj;
8620fail:
8621 return NULL;
8622}
8623
8624
8625SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8626 PyObject *resultobj = 0;
8627 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8628 wxPoint2D *arg2 = 0 ;
8629 double result;
8630 void *argp1 = 0 ;
8631 int res1 = 0 ;
8632 wxPoint2D temp2 ;
8633 PyObject * obj0 = 0 ;
8634 PyObject * obj1 = 0 ;
8635 char * kwnames[] = {
8636 (char *) "self",(char *) "vec", NULL
8637 };
8638
8639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8641 if (!SWIG_IsOK(res1)) {
8642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8643 }
8644 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8645 {
8646 arg2 = &temp2;
8647 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8648 }
8649 {
1bd55598 8650 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
1bd55598
RD
8651 if (PyErr_Occurred()) SWIG_fail;
8652 }
8653 resultobj = SWIG_From_double(static_cast< double >(result));
8654 return resultobj;
8655fail:
8656 return NULL;
8657}
8658
8659
8660SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8661 PyObject *resultobj = 0;
8662 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8663 wxPoint2D *arg2 = 0 ;
8664 double result;
8665 void *argp1 = 0 ;
8666 int res1 = 0 ;
8667 wxPoint2D temp2 ;
8668 PyObject * obj0 = 0 ;
8669 PyObject * obj1 = 0 ;
8670 char * kwnames[] = {
8671 (char *) "self",(char *) "vec", NULL
8672 };
8673
8674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8676 if (!SWIG_IsOK(res1)) {
8677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8678 }
8679 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8680 {
8681 arg2 = &temp2;
8682 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8683 }
8684 {
1bd55598 8685 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
1bd55598
RD
8686 if (PyErr_Occurred()) SWIG_fail;
8687 }
8688 resultobj = SWIG_From_double(static_cast< double >(result));
8689 return resultobj;
8690fail:
8691 return NULL;
d55e5bfc
RD
8692}
8693
8694
1bd55598
RD
8695SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8696 PyObject *resultobj = 0;
8697 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8698 wxPoint2D result;
8699 void *argp1 = 0 ;
8700 int res1 = 0 ;
8701 PyObject *swig_obj[1] ;
8702
8703 if (!args) SWIG_fail;
8704 swig_obj[0] = args;
8705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8706 if (!SWIG_IsOK(res1)) {
8707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8708 }
8709 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8710 {
1bd55598 8711 result = (arg1)->operator -();
1bd55598
RD
8712 if (PyErr_Occurred()) SWIG_fail;
8713 }
8714 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8715 return resultobj;
8716fail:
8717 return NULL;
8718}
8719
8720
8721SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8722 PyObject *resultobj = 0;
8723 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8724 wxPoint2D *arg2 = 0 ;
8725 wxPoint2D *result = 0 ;
8726 void *argp1 = 0 ;
8727 int res1 = 0 ;
8728 wxPoint2D temp2 ;
8729 PyObject * obj0 = 0 ;
8730 PyObject * obj1 = 0 ;
8731 char * kwnames[] = {
8732 (char *) "self",(char *) "pt", NULL
8733 };
8734
8735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8737 if (!SWIG_IsOK(res1)) {
8738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8739 }
8740 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8741 {
8742 arg2 = &temp2;
8743 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8744 }
8745 {
36ed4f51 8746 {
1bd55598
RD
8747 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8748 result = (wxPoint2D *) &_result_ref;
36ed4f51 8749 }
1bd55598
RD
8750 if (PyErr_Occurred()) SWIG_fail;
8751 }
8752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8753 return resultobj;
8754fail:
8755 return NULL;
8756}
8757
8758
8759SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8760 PyObject *resultobj = 0;
8761 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8762 wxPoint2D *arg2 = 0 ;
8763 wxPoint2D *result = 0 ;
8764 void *argp1 = 0 ;
8765 int res1 = 0 ;
8766 wxPoint2D temp2 ;
8767 PyObject * obj0 = 0 ;
8768 PyObject * obj1 = 0 ;
8769 char * kwnames[] = {
8770 (char *) "self",(char *) "pt", NULL
8771 };
8772
8773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8775 if (!SWIG_IsOK(res1)) {
8776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8777 }
8778 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8779 {
8780 arg2 = &temp2;
8781 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8782 }
8783 {
d55e5bfc 8784 {
1bd55598
RD
8785 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8786 result = (wxPoint2D *) &_result_ref;
d55e5bfc 8787 }
1bd55598
RD
8788 if (PyErr_Occurred()) SWIG_fail;
8789 }
8790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8791 return resultobj;
8792fail:
8793 return NULL;
8794}
8795
8796
8797SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8798 PyObject *resultobj = 0;
8799 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8800 wxPoint2D *arg2 = 0 ;
8801 wxPoint2D *result = 0 ;
8802 void *argp1 = 0 ;
8803 int res1 = 0 ;
8804 wxPoint2D temp2 ;
8805 PyObject * obj0 = 0 ;
8806 PyObject * obj1 = 0 ;
8807 char * kwnames[] = {
8808 (char *) "self",(char *) "pt", NULL
8809 };
8810
8811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8813 if (!SWIG_IsOK(res1)) {
8814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8815 }
8816 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8817 {
8818 arg2 = &temp2;
8819 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8820 }
8821 {
d55e5bfc 8822 {
1bd55598
RD
8823 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8824 result = (wxPoint2D *) &_result_ref;
d55e5bfc 8825 }
1bd55598
RD
8826 if (PyErr_Occurred()) SWIG_fail;
8827 }
8828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8829 return resultobj;
8830fail:
8831 return NULL;
8832}
8833
8834
8835SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8836 PyObject *resultobj = 0;
8837 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8838 wxPoint2D *arg2 = 0 ;
8839 wxPoint2D *result = 0 ;
8840 void *argp1 = 0 ;
8841 int res1 = 0 ;
8842 wxPoint2D temp2 ;
8843 PyObject * obj0 = 0 ;
8844 PyObject * obj1 = 0 ;
8845 char * kwnames[] = {
8846 (char *) "self",(char *) "pt", NULL
8847 };
8848
8849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8851 if (!SWIG_IsOK(res1)) {
8852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8853 }
8854 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8855 {
8856 arg2 = &temp2;
8857 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8858 }
8859 {
d55e5bfc 8860 {
1bd55598
RD
8861 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8862 result = (wxPoint2D *) &_result_ref;
d55e5bfc 8863 }
1bd55598
RD
8864 if (PyErr_Occurred()) SWIG_fail;
8865 }
8866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8867 return resultobj;
8868fail:
8869 return NULL;
8870}
8871
8872
8873SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8874 PyObject *resultobj = 0;
8875 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
e9d6f3a4 8876 PyObject *arg2 = (PyObject *) 0 ;
1bd55598
RD
8877 bool result;
8878 void *argp1 = 0 ;
8879 int res1 = 0 ;
1bd55598
RD
8880 PyObject * obj0 = 0 ;
8881 PyObject * obj1 = 0 ;
8882 char * kwnames[] = {
e9d6f3a4 8883 (char *) "self",(char *) "other", NULL
1bd55598
RD
8884 };
8885
8886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8888 if (!SWIG_IsOK(res1)) {
e9d6f3a4 8889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
1bd55598
RD
8890 }
8891 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
e9d6f3a4 8892 arg2 = obj1;
1bd55598 8893 {
e9d6f3a4 8894 result = (bool)wxPoint2D___eq__(arg1,arg2);
1bd55598
RD
8895 if (PyErr_Occurred()) SWIG_fail;
8896 }
8897 {
8898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8899 }
8900 return resultobj;
8901fail:
8902 return NULL;
8903}
8904
8905
8906SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj = 0;
8908 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
e9d6f3a4 8909 PyObject *arg2 = (PyObject *) 0 ;
1bd55598
RD
8910 bool result;
8911 void *argp1 = 0 ;
8912 int res1 = 0 ;
1bd55598
RD
8913 PyObject * obj0 = 0 ;
8914 PyObject * obj1 = 0 ;
8915 char * kwnames[] = {
e9d6f3a4 8916 (char *) "self",(char *) "other", NULL
1bd55598
RD
8917 };
8918
8919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8921 if (!SWIG_IsOK(res1)) {
e9d6f3a4 8922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
1bd55598
RD
8923 }
8924 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
e9d6f3a4 8925 arg2 = obj1;
1bd55598 8926 {
e9d6f3a4 8927 result = (bool)wxPoint2D___ne__(arg1,arg2);
1bd55598
RD
8928 if (PyErr_Occurred()) SWIG_fail;
8929 }
8930 {
8931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8932 }
8933 return resultobj;
8934fail:
8935 return NULL;
d55e5bfc
RD
8936}
8937
8938
1bd55598
RD
8939SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8940 PyObject *resultobj = 0;
8941 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8942 double arg2 ;
8943 void *argp1 = 0 ;
8944 int res1 = 0 ;
8945 double val2 ;
8946 int ecode2 = 0 ;
8947 PyObject *swig_obj[2] ;
8948
8949 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8951 if (!SWIG_IsOK(res1)) {
8952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8953 }
8954 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8955 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8956 if (!SWIG_IsOK(ecode2)) {
8957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8958 }
8959 arg2 = static_cast< double >(val2);
8960 if (arg1) (arg1)->m_x = arg2;
8961
8962 resultobj = SWIG_Py_Void();
8963 return resultobj;
8964fail:
8965 return NULL;
d55e5bfc
RD
8966}
8967
8968
1bd55598
RD
8969SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8970 PyObject *resultobj = 0;
8971 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8972 double result;
8973 void *argp1 = 0 ;
8974 int res1 = 0 ;
8975 PyObject *swig_obj[1] ;
8976
8977 if (!args) SWIG_fail;
8978 swig_obj[0] = args;
8979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8980 if (!SWIG_IsOK(res1)) {
8981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8982 }
8983 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8984 result = (double) ((arg1)->m_x);
8985 resultobj = SWIG_From_double(static_cast< double >(result));
8986 return resultobj;
8987fail:
8988 return NULL;
8989}
8990
8991
8992SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8993 PyObject *resultobj = 0;
8994 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8995 double arg2 ;
8996 void *argp1 = 0 ;
8997 int res1 = 0 ;
8998 double val2 ;
8999 int ecode2 = 0 ;
9000 PyObject *swig_obj[2] ;
9001
9002 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9004 if (!SWIG_IsOK(res1)) {
9005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9006 }
9007 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9008 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9009 if (!SWIG_IsOK(ecode2)) {
9010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9011 }
9012 arg2 = static_cast< double >(val2);
9013 if (arg1) (arg1)->m_y = arg2;
9014
9015 resultobj = SWIG_Py_Void();
9016 return resultobj;
9017fail:
9018 return NULL;
d55e5bfc
RD
9019}
9020
9021
1bd55598
RD
9022SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9023 PyObject *resultobj = 0;
9024 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9025 double result;
9026 void *argp1 = 0 ;
9027 int res1 = 0 ;
9028 PyObject *swig_obj[1] ;
9029
9030 if (!args) SWIG_fail;
9031 swig_obj[0] = args;
9032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9033 if (!SWIG_IsOK(res1)) {
9034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9035 }
9036 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9037 result = (double) ((arg1)->m_y);
9038 resultobj = SWIG_From_double(static_cast< double >(result));
9039 return resultobj;
9040fail:
9041 return NULL;
9042}
9043
9044
9045SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9046 PyObject *resultobj = 0;
9047 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9048 double arg2 = (double) 0 ;
9049 double arg3 = (double) 0 ;
9050 void *argp1 = 0 ;
9051 int res1 = 0 ;
9052 double val2 ;
9053 int ecode2 = 0 ;
9054 double val3 ;
9055 int ecode3 = 0 ;
9056 PyObject * obj0 = 0 ;
9057 PyObject * obj1 = 0 ;
9058 PyObject * obj2 = 0 ;
9059 char * kwnames[] = {
9060 (char *) "self",(char *) "x",(char *) "y", NULL
9061 };
9062
9063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9065 if (!SWIG_IsOK(res1)) {
9066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9067 }
9068 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9069 if (obj1) {
9070 ecode2 = SWIG_AsVal_double(obj1, &val2);
9071 if (!SWIG_IsOK(ecode2)) {
9072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9073 }
9074 arg2 = static_cast< double >(val2);
9075 }
9076 if (obj2) {
9077 ecode3 = SWIG_AsVal_double(obj2, &val3);
9078 if (!SWIG_IsOK(ecode3)) {
9079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9080 }
9081 arg3 = static_cast< double >(val3);
9082 }
9083 {
1bd55598 9084 wxPoint2D_Set(arg1,arg2,arg3);
1bd55598
RD
9085 if (PyErr_Occurred()) SWIG_fail;
9086 }
9087 resultobj = SWIG_Py_Void();
9088 return resultobj;
9089fail:
9090 return NULL;
d55e5bfc
RD
9091}
9092
9093
1bd55598
RD
9094SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9095 PyObject *resultobj = 0;
9096 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9097 PyObject *result = 0 ;
9098 void *argp1 = 0 ;
9099 int res1 = 0 ;
9100 PyObject *swig_obj[1] ;
9101
9102 if (!args) SWIG_fail;
9103 swig_obj[0] = args;
9104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9105 if (!SWIG_IsOK(res1)) {
9106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9107 }
9108 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9109 {
1bd55598 9110 result = (PyObject *)wxPoint2D_Get(arg1);
1bd55598
RD
9111 if (PyErr_Occurred()) SWIG_fail;
9112 }
9113 resultobj = result;
9114 return resultobj;
9115fail:
9116 return NULL;
aff4cc5c
RD
9117}
9118
9119
1bd55598
RD
9120SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9121 PyObject *obj;
9122 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9123 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9124 return SWIG_Py_Void();
d55e5bfc
RD
9125}
9126
1bd55598
RD
9127SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9128 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
9129}
9130
70d7cb34
RD
9131SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9132 PyObject *resultobj = 0;
9133 wxDouble arg1 = (wxDouble) 0.0 ;
9134 wxDouble arg2 = (wxDouble) 0.0 ;
9135 wxDouble arg3 = (wxDouble) 0.0 ;
9136 wxDouble arg4 = (wxDouble) 0.0 ;
9137 wxRect2D *result = 0 ;
9138 void *argp1 ;
9139 int res1 = 0 ;
9140 void *argp2 ;
9141 int res2 = 0 ;
9142 void *argp3 ;
9143 int res3 = 0 ;
9144 void *argp4 ;
9145 int res4 = 0 ;
9146 PyObject * obj0 = 0 ;
9147 PyObject * obj1 = 0 ;
9148 PyObject * obj2 = 0 ;
9149 PyObject * obj3 = 0 ;
9150 char * kwnames[] = {
9151 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9152 };
9153
9154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9155 if (obj0) {
9156 {
9157 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9158 if (!SWIG_IsOK(res1)) {
9159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9160 }
9161 if (!argp1) {
9162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9163 } else {
9164 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9165 arg1 = *temp;
9166 if (SWIG_IsNewObj(res1)) delete temp;
9167 }
9168 }
9169 }
9170 if (obj1) {
9171 {
9172 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9173 if (!SWIG_IsOK(res2)) {
9174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9175 }
9176 if (!argp2) {
9177 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9178 } else {
9179 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9180 arg2 = *temp;
9181 if (SWIG_IsNewObj(res2)) delete temp;
9182 }
9183 }
9184 }
9185 if (obj2) {
9186 {
9187 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9188 if (!SWIG_IsOK(res3)) {
9189 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9190 }
9191 if (!argp3) {
9192 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9193 } else {
9194 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9195 arg3 = *temp;
9196 if (SWIG_IsNewObj(res3)) delete temp;
9197 }
9198 }
9199 }
9200 if (obj3) {
9201 {
9202 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9203 if (!SWIG_IsOK(res4)) {
9204 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9205 }
9206 if (!argp4) {
9207 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9208 } else {
9209 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9210 arg4 = *temp;
9211 if (SWIG_IsNewObj(res4)) delete temp;
9212 }
9213 }
9214 }
9215 {
9216 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9217 if (PyErr_Occurred()) SWIG_fail;
9218 }
9219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9220 return resultobj;
9221fail:
9222 return NULL;
9223}
9224
9225
9226SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9227 PyObject *resultobj = 0;
9228 wxRect2D *arg1 = (wxRect2D *) 0 ;
9229 void *argp1 = 0 ;
9230 int res1 = 0 ;
9231 PyObject *swig_obj[1] ;
9232
9233 if (!args) SWIG_fail;
9234 swig_obj[0] = args;
9235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9236 if (!SWIG_IsOK(res1)) {
9237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9238 }
9239 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9240 {
9241 delete arg1;
9242
9243 if (PyErr_Occurred()) SWIG_fail;
9244 }
9245 resultobj = SWIG_Py_Void();
9246 return resultobj;
9247fail:
9248 return NULL;
9249}
9250
9251
9252SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9253 PyObject *resultobj = 0;
9254 wxRect2D *arg1 = (wxRect2D *) 0 ;
9255 wxPoint2D result;
9256 void *argp1 = 0 ;
9257 int res1 = 0 ;
9258 PyObject *swig_obj[1] ;
9259
9260 if (!args) SWIG_fail;
9261 swig_obj[0] = args;
9262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9263 if (!SWIG_IsOK(res1)) {
9264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9265 }
9266 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9267 {
9268 result = (arg1)->GetPosition();
9269 if (PyErr_Occurred()) SWIG_fail;
9270 }
9271 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9272 return resultobj;
9273fail:
9274 return NULL;
9275}
9276
9277
9278SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9279 PyObject *resultobj = 0;
9280 wxRect2D *arg1 = (wxRect2D *) 0 ;
9281 wxSize result;
9282 void *argp1 = 0 ;
9283 int res1 = 0 ;
9284 PyObject *swig_obj[1] ;
9285
9286 if (!args) SWIG_fail;
9287 swig_obj[0] = args;
9288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9289 if (!SWIG_IsOK(res1)) {
9290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9291 }
9292 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9293 {
9294 result = (arg1)->GetSize();
9295 if (PyErr_Occurred()) SWIG_fail;
9296 }
9297 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9298 return resultobj;
9299fail:
9300 return NULL;
9301}
9302
9303
9304SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9305 PyObject *resultobj = 0;
9306 wxRect2D *arg1 = (wxRect2D *) 0 ;
9307 wxDouble result;
9308 void *argp1 = 0 ;
9309 int res1 = 0 ;
9310 PyObject *swig_obj[1] ;
9311
9312 if (!args) SWIG_fail;
9313 swig_obj[0] = args;
9314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9315 if (!SWIG_IsOK(res1)) {
9316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9317 }
9318 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9319 {
9320 result = ((wxRect2D const *)arg1)->GetLeft();
9321 if (PyErr_Occurred()) SWIG_fail;
9322 }
9323 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9324 return resultobj;
9325fail:
9326 return NULL;
9327}
9328
9329
9330SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9331 PyObject *resultobj = 0;
9332 wxRect2D *arg1 = (wxRect2D *) 0 ;
9333 wxDouble arg2 ;
9334 void *argp1 = 0 ;
9335 int res1 = 0 ;
9336 void *argp2 ;
9337 int res2 = 0 ;
9338 PyObject * obj0 = 0 ;
9339 PyObject * obj1 = 0 ;
9340 char * kwnames[] = {
9341 (char *) "self",(char *) "n", NULL
9342 };
9343
9344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9346 if (!SWIG_IsOK(res1)) {
9347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9348 }
9349 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9350 {
9351 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9352 if (!SWIG_IsOK(res2)) {
9353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9354 }
9355 if (!argp2) {
9356 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9357 } else {
9358 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9359 arg2 = *temp;
9360 if (SWIG_IsNewObj(res2)) delete temp;
9361 }
9362 }
9363 {
9364 (arg1)->SetLeft(arg2);
9365 if (PyErr_Occurred()) SWIG_fail;
9366 }
9367 resultobj = SWIG_Py_Void();
9368 return resultobj;
9369fail:
9370 return NULL;
9371}
9372
9373
9374SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9375 PyObject *resultobj = 0;
9376 wxRect2D *arg1 = (wxRect2D *) 0 ;
9377 wxDouble arg2 ;
9378 void *argp1 = 0 ;
9379 int res1 = 0 ;
9380 void *argp2 ;
9381 int res2 = 0 ;
9382 PyObject * obj0 = 0 ;
9383 PyObject * obj1 = 0 ;
9384 char * kwnames[] = {
9385 (char *) "self",(char *) "n", NULL
9386 };
9387
9388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9390 if (!SWIG_IsOK(res1)) {
9391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9392 }
9393 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9394 {
9395 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9396 if (!SWIG_IsOK(res2)) {
9397 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9398 }
9399 if (!argp2) {
9400 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9401 } else {
9402 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9403 arg2 = *temp;
9404 if (SWIG_IsNewObj(res2)) delete temp;
9405 }
9406 }
9407 {
9408 (arg1)->MoveLeftTo(arg2);
9409 if (PyErr_Occurred()) SWIG_fail;
9410 }
9411 resultobj = SWIG_Py_Void();
9412 return resultobj;
9413fail:
9414 return NULL;
9415}
9416
9417
9418SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9419 PyObject *resultobj = 0;
9420 wxRect2D *arg1 = (wxRect2D *) 0 ;
9421 wxDouble result;
9422 void *argp1 = 0 ;
9423 int res1 = 0 ;
9424 PyObject *swig_obj[1] ;
9425
9426 if (!args) SWIG_fail;
9427 swig_obj[0] = args;
9428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9429 if (!SWIG_IsOK(res1)) {
9430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9431 }
9432 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9433 {
9434 result = ((wxRect2D const *)arg1)->GetTop();
9435 if (PyErr_Occurred()) SWIG_fail;
9436 }
9437 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9438 return resultobj;
9439fail:
9440 return NULL;
9441}
9442
9443
9444SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9445 PyObject *resultobj = 0;
9446 wxRect2D *arg1 = (wxRect2D *) 0 ;
9447 wxDouble arg2 ;
9448 void *argp1 = 0 ;
9449 int res1 = 0 ;
9450 void *argp2 ;
9451 int res2 = 0 ;
9452 PyObject * obj0 = 0 ;
9453 PyObject * obj1 = 0 ;
9454 char * kwnames[] = {
9455 (char *) "self",(char *) "n", NULL
9456 };
9457
9458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9460 if (!SWIG_IsOK(res1)) {
9461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9462 }
9463 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9464 {
9465 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9466 if (!SWIG_IsOK(res2)) {
9467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9468 }
9469 if (!argp2) {
9470 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9471 } else {
9472 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9473 arg2 = *temp;
9474 if (SWIG_IsNewObj(res2)) delete temp;
9475 }
9476 }
9477 {
9478 (arg1)->SetTop(arg2);
9479 if (PyErr_Occurred()) SWIG_fail;
9480 }
9481 resultobj = SWIG_Py_Void();
9482 return resultobj;
9483fail:
9484 return NULL;
9485}
9486
9487
9488SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9489 PyObject *resultobj = 0;
9490 wxRect2D *arg1 = (wxRect2D *) 0 ;
9491 wxDouble arg2 ;
9492 void *argp1 = 0 ;
9493 int res1 = 0 ;
9494 void *argp2 ;
9495 int res2 = 0 ;
9496 PyObject * obj0 = 0 ;
9497 PyObject * obj1 = 0 ;
9498 char * kwnames[] = {
9499 (char *) "self",(char *) "n", NULL
9500 };
9501
9502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9504 if (!SWIG_IsOK(res1)) {
9505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9506 }
9507 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9508 {
9509 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9510 if (!SWIG_IsOK(res2)) {
9511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9512 }
9513 if (!argp2) {
9514 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9515 } else {
9516 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9517 arg2 = *temp;
9518 if (SWIG_IsNewObj(res2)) delete temp;
9519 }
9520 }
9521 {
9522 (arg1)->MoveTopTo(arg2);
9523 if (PyErr_Occurred()) SWIG_fail;
9524 }
9525 resultobj = SWIG_Py_Void();
9526 return resultobj;
9527fail:
9528 return NULL;
9529}
9530
9531
9532SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9533 PyObject *resultobj = 0;
9534 wxRect2D *arg1 = (wxRect2D *) 0 ;
9535 wxDouble result;
9536 void *argp1 = 0 ;
9537 int res1 = 0 ;
9538 PyObject *swig_obj[1] ;
9539
9540 if (!args) SWIG_fail;
9541 swig_obj[0] = args;
9542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9543 if (!SWIG_IsOK(res1)) {
9544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9545 }
9546 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9547 {
9548 result = ((wxRect2D const *)arg1)->GetBottom();
9549 if (PyErr_Occurred()) SWIG_fail;
9550 }
9551 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9552 return resultobj;
9553fail:
9554 return NULL;
9555}
9556
9557
9558SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9559 PyObject *resultobj = 0;
9560 wxRect2D *arg1 = (wxRect2D *) 0 ;
9561 wxDouble arg2 ;
9562 void *argp1 = 0 ;
9563 int res1 = 0 ;
9564 void *argp2 ;
9565 int res2 = 0 ;
9566 PyObject * obj0 = 0 ;
9567 PyObject * obj1 = 0 ;
9568 char * kwnames[] = {
9569 (char *) "self",(char *) "n", NULL
9570 };
9571
9572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9574 if (!SWIG_IsOK(res1)) {
9575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9576 }
9577 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9578 {
9579 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9580 if (!SWIG_IsOK(res2)) {
9581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9582 }
9583 if (!argp2) {
9584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9585 } else {
9586 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9587 arg2 = *temp;
9588 if (SWIG_IsNewObj(res2)) delete temp;
9589 }
9590 }
9591 {
9592 (arg1)->SetBottom(arg2);
9593 if (PyErr_Occurred()) SWIG_fail;
9594 }
9595 resultobj = SWIG_Py_Void();
9596 return resultobj;
9597fail:
9598 return NULL;
9599}
9600
9601
9602SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9603 PyObject *resultobj = 0;
9604 wxRect2D *arg1 = (wxRect2D *) 0 ;
9605 wxDouble arg2 ;
9606 void *argp1 = 0 ;
9607 int res1 = 0 ;
9608 void *argp2 ;
9609 int res2 = 0 ;
9610 PyObject * obj0 = 0 ;
9611 PyObject * obj1 = 0 ;
9612 char * kwnames[] = {
9613 (char *) "self",(char *) "n", NULL
9614 };
9615
9616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9618 if (!SWIG_IsOK(res1)) {
9619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9620 }
9621 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9622 {
9623 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9624 if (!SWIG_IsOK(res2)) {
9625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9626 }
9627 if (!argp2) {
9628 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9629 } else {
9630 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9631 arg2 = *temp;
9632 if (SWIG_IsNewObj(res2)) delete temp;
9633 }
9634 }
9635 {
9636 (arg1)->MoveBottomTo(arg2);
9637 if (PyErr_Occurred()) SWIG_fail;
9638 }
9639 resultobj = SWIG_Py_Void();
9640 return resultobj;
9641fail:
9642 return NULL;
9643}
9644
9645
9646SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9647 PyObject *resultobj = 0;
9648 wxRect2D *arg1 = (wxRect2D *) 0 ;
9649 wxDouble result;
9650 void *argp1 = 0 ;
9651 int res1 = 0 ;
9652 PyObject *swig_obj[1] ;
9653
9654 if (!args) SWIG_fail;
9655 swig_obj[0] = args;
9656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9657 if (!SWIG_IsOK(res1)) {
9658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9659 }
9660 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9661 {
9662 result = ((wxRect2D const *)arg1)->GetRight();
9663 if (PyErr_Occurred()) SWIG_fail;
9664 }
9665 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9666 return resultobj;
9667fail:
9668 return NULL;
9669}
9670
9671
9672SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9673 PyObject *resultobj = 0;
9674 wxRect2D *arg1 = (wxRect2D *) 0 ;
9675 wxDouble arg2 ;
9676 void *argp1 = 0 ;
9677 int res1 = 0 ;
9678 void *argp2 ;
9679 int res2 = 0 ;
9680 PyObject * obj0 = 0 ;
9681 PyObject * obj1 = 0 ;
9682 char * kwnames[] = {
9683 (char *) "self",(char *) "n", NULL
9684 };
9685
9686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9688 if (!SWIG_IsOK(res1)) {
9689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9690 }
9691 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9692 {
9693 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9694 if (!SWIG_IsOK(res2)) {
9695 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9696 }
9697 if (!argp2) {
9698 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9699 } else {
9700 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9701 arg2 = *temp;
9702 if (SWIG_IsNewObj(res2)) delete temp;
9703 }
9704 }
9705 {
9706 (arg1)->SetRight(arg2);
9707 if (PyErr_Occurred()) SWIG_fail;
9708 }
9709 resultobj = SWIG_Py_Void();
9710 return resultobj;
9711fail:
9712 return NULL;
9713}
9714
9715
9716SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9717 PyObject *resultobj = 0;
9718 wxRect2D *arg1 = (wxRect2D *) 0 ;
9719 wxDouble arg2 ;
9720 void *argp1 = 0 ;
9721 int res1 = 0 ;
9722 void *argp2 ;
9723 int res2 = 0 ;
9724 PyObject * obj0 = 0 ;
9725 PyObject * obj1 = 0 ;
9726 char * kwnames[] = {
9727 (char *) "self",(char *) "n", NULL
9728 };
9729
9730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9732 if (!SWIG_IsOK(res1)) {
9733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9734 }
9735 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9736 {
9737 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9738 if (!SWIG_IsOK(res2)) {
9739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9740 }
9741 if (!argp2) {
9742 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9743 } else {
9744 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9745 arg2 = *temp;
9746 if (SWIG_IsNewObj(res2)) delete temp;
9747 }
9748 }
9749 {
9750 (arg1)->MoveRightTo(arg2);
9751 if (PyErr_Occurred()) SWIG_fail;
9752 }
9753 resultobj = SWIG_Py_Void();
9754 return resultobj;
9755fail:
9756 return NULL;
9757}
9758
9759
9760SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9761 PyObject *resultobj = 0;
9762 wxRect2D *arg1 = (wxRect2D *) 0 ;
9763 wxPoint2D result;
9764 void *argp1 = 0 ;
9765 int res1 = 0 ;
9766 PyObject *swig_obj[1] ;
9767
9768 if (!args) SWIG_fail;
9769 swig_obj[0] = args;
9770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9771 if (!SWIG_IsOK(res1)) {
9772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9773 }
9774 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9775 {
9776 result = ((wxRect2D const *)arg1)->GetLeftTop();
9777 if (PyErr_Occurred()) SWIG_fail;
9778 }
9779 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9780 return resultobj;
9781fail:
9782 return NULL;
9783}
9784
9785
9786SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9787 PyObject *resultobj = 0;
9788 wxRect2D *arg1 = (wxRect2D *) 0 ;
9789 wxPoint2D *arg2 = 0 ;
9790 void *argp1 = 0 ;
9791 int res1 = 0 ;
9792 wxPoint2D temp2 ;
9793 PyObject * obj0 = 0 ;
9794 PyObject * obj1 = 0 ;
9795 char * kwnames[] = {
9796 (char *) "self",(char *) "pt", NULL
9797 };
9798
9799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9801 if (!SWIG_IsOK(res1)) {
9802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9803 }
9804 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9805 {
9806 arg2 = &temp2;
9807 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9808 }
9809 {
9810 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9811 if (PyErr_Occurred()) SWIG_fail;
9812 }
9813 resultobj = SWIG_Py_Void();
9814 return resultobj;
9815fail:
9816 return NULL;
9817}
9818
9819
9820SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9821 PyObject *resultobj = 0;
9822 wxRect2D *arg1 = (wxRect2D *) 0 ;
9823 wxPoint2D *arg2 = 0 ;
9824 void *argp1 = 0 ;
9825 int res1 = 0 ;
9826 wxPoint2D temp2 ;
9827 PyObject * obj0 = 0 ;
9828 PyObject * obj1 = 0 ;
9829 char * kwnames[] = {
9830 (char *) "self",(char *) "pt", NULL
9831 };
9832
9833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9835 if (!SWIG_IsOK(res1)) {
9836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9837 }
9838 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9839 {
9840 arg2 = &temp2;
9841 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9842 }
9843 {
9844 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9845 if (PyErr_Occurred()) SWIG_fail;
9846 }
9847 resultobj = SWIG_Py_Void();
9848 return resultobj;
9849fail:
9850 return NULL;
9851}
9852
9853
9854SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9855 PyObject *resultobj = 0;
9856 wxRect2D *arg1 = (wxRect2D *) 0 ;
9857 wxPoint2D 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_wxRect2D, 0 | 0 );
9865 if (!SWIG_IsOK(res1)) {
9866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9867 }
9868 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9869 {
9870 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9871 if (PyErr_Occurred()) SWIG_fail;
9872 }
9873 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9874 return resultobj;
9875fail:
9876 return NULL;
9877}
9878
9879
9880SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9881 PyObject *resultobj = 0;
9882 wxRect2D *arg1 = (wxRect2D *) 0 ;
9883 wxPoint2D *arg2 = 0 ;
9884 void *argp1 = 0 ;
9885 int res1 = 0 ;
9886 wxPoint2D temp2 ;
9887 PyObject * obj0 = 0 ;
9888 PyObject * obj1 = 0 ;
9889 char * kwnames[] = {
9890 (char *) "self",(char *) "pt", NULL
9891 };
9892
9893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9895 if (!SWIG_IsOK(res1)) {
9896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9897 }
9898 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9899 {
9900 arg2 = &temp2;
9901 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9902 }
9903 {
9904 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9905 if (PyErr_Occurred()) SWIG_fail;
9906 }
9907 resultobj = SWIG_Py_Void();
9908 return resultobj;
9909fail:
9910 return NULL;
9911}
9912
9913
9914SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9915 PyObject *resultobj = 0;
9916 wxRect2D *arg1 = (wxRect2D *) 0 ;
9917 wxPoint2D *arg2 = 0 ;
9918 void *argp1 = 0 ;
9919 int res1 = 0 ;
9920 wxPoint2D temp2 ;
9921 PyObject * obj0 = 0 ;
9922 PyObject * obj1 = 0 ;
9923 char * kwnames[] = {
9924 (char *) "self",(char *) "pt", NULL
9925 };
9926
9927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9929 if (!SWIG_IsOK(res1)) {
9930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9931 }
9932 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9933 {
9934 arg2 = &temp2;
9935 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9936 }
9937 {
9938 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
9939 if (PyErr_Occurred()) SWIG_fail;
9940 }
9941 resultobj = SWIG_Py_Void();
9942 return resultobj;
9943fail:
9944 return NULL;
9945}
9946
9947
9948SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9949 PyObject *resultobj = 0;
9950 wxRect2D *arg1 = (wxRect2D *) 0 ;
9951 wxPoint2D result;
9952 void *argp1 = 0 ;
9953 int res1 = 0 ;
9954 PyObject *swig_obj[1] ;
9955
9956 if (!args) SWIG_fail;
9957 swig_obj[0] = args;
9958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9959 if (!SWIG_IsOK(res1)) {
9960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9961 }
9962 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9963 {
9964 result = ((wxRect2D const *)arg1)->GetRightTop();
9965 if (PyErr_Occurred()) SWIG_fail;
9966 }
9967 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9968 return resultobj;
9969fail:
9970 return NULL;
9971}
9972
9973
9974SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9975 PyObject *resultobj = 0;
9976 wxRect2D *arg1 = (wxRect2D *) 0 ;
9977 wxPoint2D *arg2 = 0 ;
9978 void *argp1 = 0 ;
9979 int res1 = 0 ;
9980 wxPoint2D temp2 ;
9981 PyObject * obj0 = 0 ;
9982 PyObject * obj1 = 0 ;
9983 char * kwnames[] = {
9984 (char *) "self",(char *) "pt", NULL
9985 };
9986
9987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
9988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9989 if (!SWIG_IsOK(res1)) {
9990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9991 }
9992 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9993 {
9994 arg2 = &temp2;
9995 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9996 }
9997 {
9998 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
9999 if (PyErr_Occurred()) SWIG_fail;
10000 }
10001 resultobj = SWIG_Py_Void();
10002 return resultobj;
10003fail:
10004 return NULL;
10005}
10006
10007
10008SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10009 PyObject *resultobj = 0;
10010 wxRect2D *arg1 = (wxRect2D *) 0 ;
10011 wxPoint2D *arg2 = 0 ;
10012 void *argp1 = 0 ;
10013 int res1 = 0 ;
10014 wxPoint2D temp2 ;
10015 PyObject * obj0 = 0 ;
10016 PyObject * obj1 = 0 ;
10017 char * kwnames[] = {
10018 (char *) "self",(char *) "pt", NULL
10019 };
10020
10021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10023 if (!SWIG_IsOK(res1)) {
10024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10025 }
10026 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10027 {
10028 arg2 = &temp2;
10029 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10030 }
10031 {
10032 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10033 if (PyErr_Occurred()) SWIG_fail;
10034 }
10035 resultobj = SWIG_Py_Void();
10036 return resultobj;
10037fail:
10038 return NULL;
10039}
10040
10041
10042SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10043 PyObject *resultobj = 0;
10044 wxRect2D *arg1 = (wxRect2D *) 0 ;
10045 wxPoint2D result;
10046 void *argp1 = 0 ;
10047 int res1 = 0 ;
10048 PyObject *swig_obj[1] ;
10049
10050 if (!args) SWIG_fail;
10051 swig_obj[0] = args;
10052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10053 if (!SWIG_IsOK(res1)) {
10054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10055 }
10056 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10057 {
10058 result = ((wxRect2D const *)arg1)->GetRightBottom();
10059 if (PyErr_Occurred()) SWIG_fail;
10060 }
10061 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10062 return resultobj;
10063fail:
10064 return NULL;
10065}
10066
10067
10068SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10069 PyObject *resultobj = 0;
10070 wxRect2D *arg1 = (wxRect2D *) 0 ;
10071 wxPoint2D *arg2 = 0 ;
10072 void *argp1 = 0 ;
10073 int res1 = 0 ;
10074 wxPoint2D temp2 ;
10075 PyObject * obj0 = 0 ;
10076 PyObject * obj1 = 0 ;
10077 char * kwnames[] = {
10078 (char *) "self",(char *) "pt", NULL
10079 };
10080
10081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10083 if (!SWIG_IsOK(res1)) {
10084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10085 }
10086 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10087 {
10088 arg2 = &temp2;
10089 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10090 }
10091 {
10092 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10093 if (PyErr_Occurred()) SWIG_fail;
10094 }
10095 resultobj = SWIG_Py_Void();
10096 return resultobj;
10097fail:
10098 return NULL;
10099}
10100
10101
10102SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10103 PyObject *resultobj = 0;
10104 wxRect2D *arg1 = (wxRect2D *) 0 ;
10105 wxPoint2D *arg2 = 0 ;
10106 void *argp1 = 0 ;
10107 int res1 = 0 ;
10108 wxPoint2D temp2 ;
10109 PyObject * obj0 = 0 ;
10110 PyObject * obj1 = 0 ;
10111 char * kwnames[] = {
10112 (char *) "self",(char *) "pt", NULL
10113 };
10114
10115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10117 if (!SWIG_IsOK(res1)) {
10118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10119 }
10120 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10121 {
10122 arg2 = &temp2;
10123 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10124 }
10125 {
10126 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10127 if (PyErr_Occurred()) SWIG_fail;
10128 }
10129 resultobj = SWIG_Py_Void();
10130 return resultobj;
10131fail:
10132 return NULL;
10133}
10134
10135
10136SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10137 PyObject *resultobj = 0;
10138 wxRect2D *arg1 = (wxRect2D *) 0 ;
10139 wxPoint2D result;
10140 void *argp1 = 0 ;
10141 int res1 = 0 ;
10142 PyObject *swig_obj[1] ;
10143
10144 if (!args) SWIG_fail;
10145 swig_obj[0] = args;
10146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10147 if (!SWIG_IsOK(res1)) {
10148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10149 }
10150 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10151 {
10152 result = ((wxRect2D const *)arg1)->GetCentre();
10153 if (PyErr_Occurred()) SWIG_fail;
10154 }
10155 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10156 return resultobj;
10157fail:
10158 return NULL;
10159}
10160
10161
10162SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10163 PyObject *resultobj = 0;
10164 wxRect2D *arg1 = (wxRect2D *) 0 ;
10165 wxPoint2D *arg2 = 0 ;
10166 void *argp1 = 0 ;
10167 int res1 = 0 ;
10168 wxPoint2D temp2 ;
10169 PyObject * obj0 = 0 ;
10170 PyObject * obj1 = 0 ;
10171 char * kwnames[] = {
10172 (char *) "self",(char *) "pt", NULL
10173 };
10174
10175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10177 if (!SWIG_IsOK(res1)) {
10178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10179 }
10180 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10181 {
10182 arg2 = &temp2;
10183 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10184 }
10185 {
10186 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10187 if (PyErr_Occurred()) SWIG_fail;
10188 }
10189 resultobj = SWIG_Py_Void();
10190 return resultobj;
10191fail:
10192 return NULL;
10193}
10194
10195
10196SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10197 PyObject *resultobj = 0;
10198 wxRect2D *arg1 = (wxRect2D *) 0 ;
10199 wxPoint2D *arg2 = 0 ;
10200 void *argp1 = 0 ;
10201 int res1 = 0 ;
10202 wxPoint2D temp2 ;
10203 PyObject * obj0 = 0 ;
10204 PyObject * obj1 = 0 ;
10205 char * kwnames[] = {
10206 (char *) "self",(char *) "pt", NULL
10207 };
10208
10209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10211 if (!SWIG_IsOK(res1)) {
10212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10213 }
10214 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10215 {
10216 arg2 = &temp2;
10217 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10218 }
10219 {
10220 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10221 if (PyErr_Occurred()) SWIG_fail;
10222 }
10223 resultobj = SWIG_Py_Void();
10224 return resultobj;
10225fail:
10226 return NULL;
10227}
10228
10229
10230SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10231 PyObject *resultobj = 0;
10232 wxRect2D *arg1 = (wxRect2D *) 0 ;
10233 wxPoint2D *arg2 = 0 ;
10234 wxOutCode result;
10235 void *argp1 = 0 ;
10236 int res1 = 0 ;
10237 wxPoint2D temp2 ;
10238 PyObject * obj0 = 0 ;
10239 PyObject * obj1 = 0 ;
10240 char * kwnames[] = {
10241 (char *) "self",(char *) "pt", NULL
10242 };
10243
10244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10246 if (!SWIG_IsOK(res1)) {
10247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10248 }
10249 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10250 {
10251 arg2 = &temp2;
10252 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10253 }
10254 {
10255 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10256 if (PyErr_Occurred()) SWIG_fail;
10257 }
10258 resultobj = SWIG_From_int(static_cast< int >(result));
10259 return resultobj;
10260fail:
10261 return NULL;
10262}
10263
10264
10265SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10266 PyObject *resultobj = 0;
10267 wxRect2D *arg1 = (wxRect2D *) 0 ;
10268 wxPoint2D *arg2 = 0 ;
10269 bool result;
10270 void *argp1 = 0 ;
10271 int res1 = 0 ;
10272 wxPoint2D temp2 ;
10273 PyObject * obj0 = 0 ;
10274 PyObject * obj1 = 0 ;
10275 char * kwnames[] = {
10276 (char *) "self",(char *) "pt", NULL
10277 };
10278
10279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10281 if (!SWIG_IsOK(res1)) {
10282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10283 }
10284 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10285 {
10286 arg2 = &temp2;
10287 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10288 }
10289 {
10290 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10291 if (PyErr_Occurred()) SWIG_fail;
10292 }
10293 {
10294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10295 }
10296 return resultobj;
10297fail:
10298 return NULL;
10299}
10300
10301
10302SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10303 PyObject *resultobj = 0;
10304 wxRect2D *arg1 = (wxRect2D *) 0 ;
10305 wxRect2D *arg2 = 0 ;
10306 bool result;
10307 void *argp1 = 0 ;
10308 int res1 = 0 ;
10309 wxRect2D temp2 ;
10310 PyObject * obj0 = 0 ;
10311 PyObject * obj1 = 0 ;
10312 char * kwnames[] = {
10313 (char *) "self",(char *) "rect", NULL
10314 };
10315
10316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10318 if (!SWIG_IsOK(res1)) {
10319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10320 }
10321 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10322 {
10323 arg2 = &temp2;
10324 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10325 }
10326 {
10327 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10328 if (PyErr_Occurred()) SWIG_fail;
10329 }
10330 {
10331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10332 }
10333 return resultobj;
10334fail:
10335 return NULL;
10336}
10337
10338
10339SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10340 PyObject *resultobj = 0;
10341 wxRect2D *arg1 = (wxRect2D *) 0 ;
10342 bool result;
10343 void *argp1 = 0 ;
10344 int res1 = 0 ;
10345 PyObject *swig_obj[1] ;
10346
10347 if (!args) SWIG_fail;
10348 swig_obj[0] = args;
10349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10350 if (!SWIG_IsOK(res1)) {
10351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10352 }
10353 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10354 {
10355 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10356 if (PyErr_Occurred()) SWIG_fail;
10357 }
10358 {
10359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10360 }
10361 return resultobj;
10362fail:
10363 return NULL;
10364}
10365
10366
10367SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10368 PyObject *resultobj = 0;
10369 wxRect2D *arg1 = (wxRect2D *) 0 ;
10370 wxRect2D *arg2 = 0 ;
10371 bool result;
10372 void *argp1 = 0 ;
10373 int res1 = 0 ;
10374 wxRect2D temp2 ;
10375 PyObject * obj0 = 0 ;
10376 PyObject * obj1 = 0 ;
10377 char * kwnames[] = {
10378 (char *) "self",(char *) "rect", NULL
10379 };
10380
10381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10383 if (!SWIG_IsOK(res1)) {
10384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10385 }
10386 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10387 {
10388 arg2 = &temp2;
10389 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10390 }
10391 {
10392 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10393 if (PyErr_Occurred()) SWIG_fail;
10394 }
10395 {
10396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10397 }
10398 return resultobj;
10399fail:
10400 return NULL;
10401}
10402
10403
10404SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10405 PyObject *resultobj = 0;
10406 wxRect2D *arg1 = (wxRect2D *) 0 ;
10407 wxDouble arg2 ;
10408 wxDouble arg3 ;
10409 void *argp1 = 0 ;
10410 int res1 = 0 ;
10411 void *argp2 ;
10412 int res2 = 0 ;
10413 void *argp3 ;
10414 int res3 = 0 ;
10415
10416 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10418 if (!SWIG_IsOK(res1)) {
10419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10420 }
10421 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10422 {
10423 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10424 if (!SWIG_IsOK(res2)) {
10425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10426 }
10427 if (!argp2) {
10428 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10429 } else {
10430 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10431 arg2 = *temp;
10432 if (SWIG_IsNewObj(res2)) delete temp;
10433 }
10434 }
10435 {
10436 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10437 if (!SWIG_IsOK(res3)) {
10438 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10439 }
10440 if (!argp3) {
10441 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10442 } else {
10443 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10444 arg3 = *temp;
10445 if (SWIG_IsNewObj(res3)) delete temp;
10446 }
10447 }
10448 {
10449 (arg1)->Inset(arg2,arg3);
10450 if (PyErr_Occurred()) SWIG_fail;
10451 }
10452 resultobj = SWIG_Py_Void();
10453 return resultobj;
10454fail:
10455 return NULL;
10456}
10457
10458
10459SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10460 PyObject *resultobj = 0;
10461 wxRect2D *arg1 = (wxRect2D *) 0 ;
10462 wxDouble arg2 ;
10463 wxDouble arg3 ;
10464 wxDouble arg4 ;
10465 wxDouble arg5 ;
10466 void *argp1 = 0 ;
10467 int res1 = 0 ;
10468 void *argp2 ;
10469 int res2 = 0 ;
10470 void *argp3 ;
10471 int res3 = 0 ;
10472 void *argp4 ;
10473 int res4 = 0 ;
10474 void *argp5 ;
10475 int res5 = 0 ;
10476
10477 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10479 if (!SWIG_IsOK(res1)) {
10480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10481 }
10482 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10483 {
10484 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10485 if (!SWIG_IsOK(res2)) {
10486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10487 }
10488 if (!argp2) {
10489 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10490 } else {
10491 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10492 arg2 = *temp;
10493 if (SWIG_IsNewObj(res2)) delete temp;
10494 }
10495 }
10496 {
10497 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10498 if (!SWIG_IsOK(res3)) {
10499 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10500 }
10501 if (!argp3) {
10502 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10503 } else {
10504 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10505 arg3 = *temp;
10506 if (SWIG_IsNewObj(res3)) delete temp;
10507 }
10508 }
10509 {
10510 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10511 if (!SWIG_IsOK(res4)) {
10512 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10513 }
10514 if (!argp4) {
10515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10516 } else {
10517 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10518 arg4 = *temp;
10519 if (SWIG_IsNewObj(res4)) delete temp;
10520 }
10521 }
10522 {
10523 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10524 if (!SWIG_IsOK(res5)) {
10525 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10526 }
10527 if (!argp5) {
10528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10529 } else {
10530 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10531 arg5 = *temp;
10532 if (SWIG_IsNewObj(res5)) delete temp;
10533 }
10534 }
10535 {
10536 (arg1)->Inset(arg2,arg3,arg4,arg5);
10537 if (PyErr_Occurred()) SWIG_fail;
10538 }
10539 resultobj = SWIG_Py_Void();
10540 return resultobj;
10541fail:
10542 return NULL;
10543}
10544
10545
10546SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10547 int argc;
10548 PyObject *argv[6];
10549
10550 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10551 --argc;
10552 if (argc == 3) {
10553 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10554 }
10555 if (argc == 5) {
10556 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10557 }
10558
10559fail:
10560 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10561 return NULL;
10562}
10563
10564
10565SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10566 PyObject *resultobj = 0;
10567 wxRect2D *arg1 = (wxRect2D *) 0 ;
10568 wxPoint2D *arg2 = 0 ;
10569 void *argp1 = 0 ;
10570 int res1 = 0 ;
10571 wxPoint2D temp2 ;
10572 PyObject * obj0 = 0 ;
10573 PyObject * obj1 = 0 ;
10574 char * kwnames[] = {
10575 (char *) "self",(char *) "pt", NULL
10576 };
10577
10578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10580 if (!SWIG_IsOK(res1)) {
10581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10582 }
10583 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10584 {
10585 arg2 = &temp2;
10586 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10587 }
10588 {
10589 (arg1)->Offset((wxPoint2D const &)*arg2);
10590 if (PyErr_Occurred()) SWIG_fail;
10591 }
10592 resultobj = SWIG_Py_Void();
10593 return resultobj;
10594fail:
10595 return NULL;
10596}
10597
10598
10599SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10600 PyObject *resultobj = 0;
10601 wxRect2D *arg1 = (wxRect2D *) 0 ;
10602 wxRect2D *arg2 = 0 ;
10603 void *argp1 = 0 ;
10604 int res1 = 0 ;
10605 wxRect2D temp2 ;
10606 PyObject * obj0 = 0 ;
10607 PyObject * obj1 = 0 ;
10608 char * kwnames[] = {
10609 (char *) "self",(char *) "rect", NULL
10610 };
10611
10612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10614 if (!SWIG_IsOK(res1)) {
10615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10616 }
10617 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10618 {
10619 arg2 = &temp2;
10620 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10621 }
10622 {
10623 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10624 if (PyErr_Occurred()) SWIG_fail;
10625 }
10626 resultobj = SWIG_Py_Void();
10627 return resultobj;
10628fail:
10629 return NULL;
10630}
10631
10632
10633SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10634 PyObject *resultobj = 0;
10635 wxRect2D *arg1 = (wxRect2D *) 0 ;
10636 int arg2 ;
10637 int arg3 ;
10638 wxPoint2D result;
10639 void *argp1 = 0 ;
10640 int res1 = 0 ;
10641 int val2 ;
10642 int ecode2 = 0 ;
10643 int val3 ;
10644 int ecode3 = 0 ;
10645 PyObject * obj0 = 0 ;
10646 PyObject * obj1 = 0 ;
10647 PyObject * obj2 = 0 ;
10648 char * kwnames[] = {
10649 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10650 };
10651
10652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10654 if (!SWIG_IsOK(res1)) {
10655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10656 }
10657 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10658 ecode2 = SWIG_AsVal_int(obj1, &val2);
10659 if (!SWIG_IsOK(ecode2)) {
10660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10661 }
10662 arg2 = static_cast< int >(val2);
10663 ecode3 = SWIG_AsVal_int(obj2, &val3);
10664 if (!SWIG_IsOK(ecode3)) {
10665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10666 }
10667 arg3 = static_cast< int >(val3);
10668 {
10669 result = (arg1)->Interpolate(arg2,arg3);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10673 return resultobj;
10674fail:
10675 return NULL;
10676}
10677
10678
10679SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10680 PyObject *resultobj = 0;
10681 wxRect2D *arg1 = (wxRect2D *) 0 ;
10682 wxRect2D *arg2 = 0 ;
10683 void *argp1 = 0 ;
10684 int res1 = 0 ;
10685 wxRect2D temp2 ;
10686 PyObject * obj0 = 0 ;
10687 PyObject * obj1 = 0 ;
10688 char * kwnames[] = {
10689 (char *) "self",(char *) "otherRect", NULL
10690 };
10691
10692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10694 if (!SWIG_IsOK(res1)) {
10695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10696 }
10697 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10698 {
10699 arg2 = &temp2;
10700 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10701 }
10702 {
10703 (arg1)->Intersect((wxRect2D const &)*arg2);
10704 if (PyErr_Occurred()) SWIG_fail;
10705 }
10706 resultobj = SWIG_Py_Void();
10707 return resultobj;
10708fail:
10709 return NULL;
10710}
10711
10712
10713SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10714 PyObject *resultobj = 0;
10715 wxRect2D *arg1 = (wxRect2D *) 0 ;
10716 wxRect2D *arg2 = 0 ;
10717 wxRect2D result;
10718 void *argp1 = 0 ;
10719 int res1 = 0 ;
10720 wxRect2D temp2 ;
10721 PyObject * obj0 = 0 ;
10722 PyObject * obj1 = 0 ;
10723 char * kwnames[] = {
10724 (char *) "self",(char *) "otherRect", NULL
10725 };
10726
10727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10729 if (!SWIG_IsOK(res1)) {
10730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10731 }
10732 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10733 {
10734 arg2 = &temp2;
10735 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10736 }
10737 {
10738 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10739 if (PyErr_Occurred()) SWIG_fail;
10740 }
10741 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10742 return resultobj;
10743fail:
10744 return NULL;
10745}
10746
10747
10748SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10749 PyObject *resultobj = 0;
10750 wxRect2D *arg1 = (wxRect2D *) 0 ;
10751 wxRect2D *arg2 = 0 ;
10752 bool result;
10753 void *argp1 = 0 ;
10754 int res1 = 0 ;
10755 wxRect2D temp2 ;
10756 PyObject * obj0 = 0 ;
10757 PyObject * obj1 = 0 ;
10758 char * kwnames[] = {
10759 (char *) "self",(char *) "rect", NULL
10760 };
10761
10762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10764 if (!SWIG_IsOK(res1)) {
10765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10766 }
10767 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10768 {
10769 arg2 = &temp2;
10770 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10771 }
10772 {
10773 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10774 if (PyErr_Occurred()) SWIG_fail;
10775 }
10776 {
10777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10778 }
10779 return resultobj;
10780fail:
10781 return NULL;
10782}
10783
10784
10785SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10786 PyObject *resultobj = 0;
10787 wxRect2D *arg1 = (wxRect2D *) 0 ;
10788 wxRect2D *arg2 = 0 ;
10789 void *argp1 = 0 ;
10790 int res1 = 0 ;
10791 wxRect2D temp2 ;
10792 PyObject * obj0 = 0 ;
10793 PyObject * obj1 = 0 ;
10794 char * kwnames[] = {
10795 (char *) "self",(char *) "otherRect", NULL
10796 };
10797
10798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10800 if (!SWIG_IsOK(res1)) {
10801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10802 }
10803 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10804 {
10805 arg2 = &temp2;
10806 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10807 }
10808 {
10809 (arg1)->Union((wxRect2D const &)*arg2);
10810 if (PyErr_Occurred()) SWIG_fail;
10811 }
10812 resultobj = SWIG_Py_Void();
10813 return resultobj;
10814fail:
10815 return NULL;
10816}
10817
10818
10819SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10820 PyObject *resultobj = 0;
10821 wxRect2D *arg1 = (wxRect2D *) 0 ;
10822 wxRect2D *arg2 = 0 ;
10823 wxRect2D result;
10824 void *argp1 = 0 ;
10825 int res1 = 0 ;
10826 wxRect2D temp2 ;
10827 PyObject * obj0 = 0 ;
10828 PyObject * obj1 = 0 ;
10829 char * kwnames[] = {
10830 (char *) "self",(char *) "otherRect", NULL
10831 };
10832
10833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10835 if (!SWIG_IsOK(res1)) {
10836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10837 }
10838 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10839 {
10840 arg2 = &temp2;
10841 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10842 }
10843 {
10844 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10845 if (PyErr_Occurred()) SWIG_fail;
10846 }
10847 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10848 return resultobj;
10849fail:
10850 return NULL;
10851}
10852
10853
10854SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10855 PyObject *resultobj = 0;
10856 wxRect2D *arg1 = (wxRect2D *) 0 ;
10857 wxDouble arg2 ;
10858 void *argp1 = 0 ;
10859 int res1 = 0 ;
10860 void *argp2 ;
10861 int res2 = 0 ;
10862
10863 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10865 if (!SWIG_IsOK(res1)) {
10866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10867 }
10868 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10869 {
10870 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10871 if (!SWIG_IsOK(res2)) {
10872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10873 }
10874 if (!argp2) {
10875 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10876 } else {
10877 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10878 arg2 = *temp;
10879 if (SWIG_IsNewObj(res2)) delete temp;
10880 }
10881 }
10882 {
10883 (arg1)->Scale(arg2);
10884 if (PyErr_Occurred()) SWIG_fail;
10885 }
10886 resultobj = SWIG_Py_Void();
10887 return resultobj;
10888fail:
10889 return NULL;
10890}
10891
10892
10893SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10894 PyObject *resultobj = 0;
10895 wxRect2D *arg1 = (wxRect2D *) 0 ;
10896 int arg2 ;
10897 int arg3 ;
10898 void *argp1 = 0 ;
10899 int res1 = 0 ;
10900 int val2 ;
10901 int ecode2 = 0 ;
10902 int val3 ;
10903 int ecode3 = 0 ;
10904
10905 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10907 if (!SWIG_IsOK(res1)) {
10908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10909 }
10910 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10911 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10912 if (!SWIG_IsOK(ecode2)) {
10913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10914 }
10915 arg2 = static_cast< int >(val2);
10916 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10917 if (!SWIG_IsOK(ecode3)) {
10918 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10919 }
10920 arg3 = static_cast< int >(val3);
10921 {
10922 (arg1)->Scale(arg2,arg3);
10923 if (PyErr_Occurred()) SWIG_fail;
10924 }
10925 resultobj = SWIG_Py_Void();
10926 return resultobj;
10927fail:
10928 return NULL;
10929}
10930
10931
10932SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10933 int argc;
10934 PyObject *argv[4];
10935
10936 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10937 --argc;
10938 if (argc == 2) {
10939 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10940 }
10941 if (argc == 3) {
10942 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10943 }
10944
10945fail:
10946 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
10947 return NULL;
10948}
10949
10950
10951SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10952 PyObject *resultobj = 0;
10953 wxRect2D *arg1 = (wxRect2D *) 0 ;
10954 PyObject *arg2 = (PyObject *) 0 ;
10955 bool result;
10956 void *argp1 = 0 ;
10957 int res1 = 0 ;
10958 PyObject * obj0 = 0 ;
10959 PyObject * obj1 = 0 ;
10960 char * kwnames[] = {
10961 (char *) "self",(char *) "other", NULL
10962 };
10963
10964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10966 if (!SWIG_IsOK(res1)) {
10967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10968 }
10969 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10970 arg2 = obj1;
10971 {
10972 result = (bool)wxRect2D___eq__(arg1,arg2);
10973 if (PyErr_Occurred()) SWIG_fail;
10974 }
10975 {
10976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10977 }
10978 return resultobj;
10979fail:
10980 return NULL;
10981}
10982
10983
10984SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10985 PyObject *resultobj = 0;
10986 wxRect2D *arg1 = (wxRect2D *) 0 ;
10987 PyObject *arg2 = (PyObject *) 0 ;
10988 bool result;
10989 void *argp1 = 0 ;
10990 int res1 = 0 ;
10991 PyObject * obj0 = 0 ;
10992 PyObject * obj1 = 0 ;
10993 char * kwnames[] = {
10994 (char *) "self",(char *) "other", NULL
10995 };
10996
10997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10999 if (!SWIG_IsOK(res1)) {
11000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11001 }
11002 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11003 arg2 = obj1;
11004 {
11005 result = (bool)wxRect2D___ne__(arg1,arg2);
11006 if (PyErr_Occurred()) SWIG_fail;
11007 }
11008 {
11009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11010 }
11011 return resultobj;
11012fail:
11013 return NULL;
11014}
11015
11016
11017SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11018 PyObject *resultobj = 0;
11019 wxRect2D *arg1 = (wxRect2D *) 0 ;
11020 wxDouble arg2 ;
11021 void *argp1 = 0 ;
11022 int res1 = 0 ;
11023 void *argp2 ;
11024 int res2 = 0 ;
11025 PyObject *swig_obj[2] ;
11026
11027 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11029 if (!SWIG_IsOK(res1)) {
11030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11031 }
11032 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11033 {
11034 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11035 if (!SWIG_IsOK(res2)) {
11036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11037 }
11038 if (!argp2) {
11039 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11040 } else {
11041 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11042 arg2 = *temp;
11043 if (SWIG_IsNewObj(res2)) delete temp;
11044 }
11045 }
11046 if (arg1) (arg1)->m_x = arg2;
11047
11048 resultobj = SWIG_Py_Void();
11049 return resultobj;
11050fail:
11051 return NULL;
11052}
11053
11054
11055SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11056 PyObject *resultobj = 0;
11057 wxRect2D *arg1 = (wxRect2D *) 0 ;
11058 wxDouble result;
11059 void *argp1 = 0 ;
11060 int res1 = 0 ;
11061 PyObject *swig_obj[1] ;
11062
11063 if (!args) SWIG_fail;
11064 swig_obj[0] = args;
11065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11066 if (!SWIG_IsOK(res1)) {
11067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11068 }
11069 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11070 result = ((arg1)->m_x);
11071 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11072 return resultobj;
11073fail:
11074 return NULL;
11075}
11076
11077
11078SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11079 PyObject *resultobj = 0;
11080 wxRect2D *arg1 = (wxRect2D *) 0 ;
11081 wxDouble arg2 ;
11082 void *argp1 = 0 ;
11083 int res1 = 0 ;
11084 void *argp2 ;
11085 int res2 = 0 ;
11086 PyObject *swig_obj[2] ;
11087
11088 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11090 if (!SWIG_IsOK(res1)) {
11091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11092 }
11093 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11094 {
11095 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11096 if (!SWIG_IsOK(res2)) {
11097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11098 }
11099 if (!argp2) {
11100 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11101 } else {
11102 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11103 arg2 = *temp;
11104 if (SWIG_IsNewObj(res2)) delete temp;
11105 }
11106 }
11107 if (arg1) (arg1)->m_y = arg2;
11108
11109 resultobj = SWIG_Py_Void();
11110 return resultobj;
11111fail:
11112 return NULL;
11113}
11114
11115
11116SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11117 PyObject *resultobj = 0;
11118 wxRect2D *arg1 = (wxRect2D *) 0 ;
11119 wxDouble result;
11120 void *argp1 = 0 ;
11121 int res1 = 0 ;
11122 PyObject *swig_obj[1] ;
11123
11124 if (!args) SWIG_fail;
11125 swig_obj[0] = args;
11126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11127 if (!SWIG_IsOK(res1)) {
11128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11129 }
11130 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11131 result = ((arg1)->m_y);
11132 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11133 return resultobj;
11134fail:
11135 return NULL;
11136}
11137
11138
11139SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11140 PyObject *resultobj = 0;
11141 wxRect2D *arg1 = (wxRect2D *) 0 ;
11142 wxDouble arg2 ;
11143 void *argp1 = 0 ;
11144 int res1 = 0 ;
11145 void *argp2 ;
11146 int res2 = 0 ;
11147 PyObject *swig_obj[2] ;
11148
11149 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11151 if (!SWIG_IsOK(res1)) {
11152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11153 }
11154 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11155 {
11156 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11157 if (!SWIG_IsOK(res2)) {
11158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11159 }
11160 if (!argp2) {
11161 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11162 } else {
11163 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11164 arg2 = *temp;
11165 if (SWIG_IsNewObj(res2)) delete temp;
11166 }
11167 }
11168 if (arg1) (arg1)->m_width = arg2;
11169
11170 resultobj = SWIG_Py_Void();
11171 return resultobj;
11172fail:
11173 return NULL;
11174}
11175
11176
11177SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11178 PyObject *resultobj = 0;
11179 wxRect2D *arg1 = (wxRect2D *) 0 ;
11180 wxDouble result;
11181 void *argp1 = 0 ;
11182 int res1 = 0 ;
11183 PyObject *swig_obj[1] ;
11184
11185 if (!args) SWIG_fail;
11186 swig_obj[0] = args;
11187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11188 if (!SWIG_IsOK(res1)) {
11189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11190 }
11191 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11192 result = ((arg1)->m_width);
11193 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11194 return resultobj;
11195fail:
11196 return NULL;
11197}
11198
11199
11200SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11201 PyObject *resultobj = 0;
11202 wxRect2D *arg1 = (wxRect2D *) 0 ;
11203 wxDouble arg2 ;
11204 void *argp1 = 0 ;
11205 int res1 = 0 ;
11206 void *argp2 ;
11207 int res2 = 0 ;
11208 PyObject *swig_obj[2] ;
11209
11210 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11212 if (!SWIG_IsOK(res1)) {
11213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11214 }
11215 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11216 {
11217 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11218 if (!SWIG_IsOK(res2)) {
11219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11220 }
11221 if (!argp2) {
11222 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11223 } else {
11224 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11225 arg2 = *temp;
11226 if (SWIG_IsNewObj(res2)) delete temp;
11227 }
11228 }
11229 if (arg1) (arg1)->m_height = arg2;
11230
11231 resultobj = SWIG_Py_Void();
11232 return resultobj;
11233fail:
11234 return NULL;
11235}
11236
11237
11238SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11239 PyObject *resultobj = 0;
11240 wxRect2D *arg1 = (wxRect2D *) 0 ;
11241 wxDouble result;
11242 void *argp1 = 0 ;
11243 int res1 = 0 ;
11244 PyObject *swig_obj[1] ;
11245
11246 if (!args) SWIG_fail;
11247 swig_obj[0] = args;
11248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11249 if (!SWIG_IsOK(res1)) {
11250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11251 }
11252 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11253 result = ((arg1)->m_height);
11254 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11255 return resultobj;
11256fail:
11257 return NULL;
11258}
11259
11260
11261SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11262 PyObject *resultobj = 0;
11263 wxRect2D *arg1 = (wxRect2D *) 0 ;
11264 wxDouble arg2 = (wxDouble) 0 ;
11265 wxDouble arg3 = (wxDouble) 0 ;
11266 wxDouble arg4 = (wxDouble) 0 ;
11267 wxDouble arg5 = (wxDouble) 0 ;
11268 void *argp1 = 0 ;
11269 int res1 = 0 ;
11270 void *argp2 ;
11271 int res2 = 0 ;
11272 void *argp3 ;
11273 int res3 = 0 ;
11274 void *argp4 ;
11275 int res4 = 0 ;
11276 void *argp5 ;
11277 int res5 = 0 ;
11278 PyObject * obj0 = 0 ;
11279 PyObject * obj1 = 0 ;
11280 PyObject * obj2 = 0 ;
11281 PyObject * obj3 = 0 ;
11282 PyObject * obj4 = 0 ;
11283 char * kwnames[] = {
11284 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11285 };
11286
11287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11289 if (!SWIG_IsOK(res1)) {
11290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11291 }
11292 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11293 if (obj1) {
11294 {
11295 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11296 if (!SWIG_IsOK(res2)) {
11297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11298 }
11299 if (!argp2) {
11300 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11301 } else {
11302 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11303 arg2 = *temp;
11304 if (SWIG_IsNewObj(res2)) delete temp;
11305 }
11306 }
11307 }
11308 if (obj2) {
11309 {
11310 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11311 if (!SWIG_IsOK(res3)) {
11312 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11313 }
11314 if (!argp3) {
11315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11316 } else {
11317 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11318 arg3 = *temp;
11319 if (SWIG_IsNewObj(res3)) delete temp;
11320 }
11321 }
11322 }
11323 if (obj3) {
11324 {
11325 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11326 if (!SWIG_IsOK(res4)) {
11327 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11328 }
11329 if (!argp4) {
11330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11331 } else {
11332 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11333 arg4 = *temp;
11334 if (SWIG_IsNewObj(res4)) delete temp;
11335 }
11336 }
11337 }
11338 if (obj4) {
11339 {
11340 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11341 if (!SWIG_IsOK(res5)) {
11342 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11343 }
11344 if (!argp5) {
11345 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11346 } else {
11347 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11348 arg5 = *temp;
11349 if (SWIG_IsNewObj(res5)) delete temp;
11350 }
11351 }
11352 }
11353 {
11354 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11355 if (PyErr_Occurred()) SWIG_fail;
11356 }
11357 resultobj = SWIG_Py_Void();
11358 return resultobj;
11359fail:
11360 return NULL;
11361}
11362
11363
11364SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11365 PyObject *resultobj = 0;
11366 wxRect2D *arg1 = (wxRect2D *) 0 ;
11367 PyObject *result = 0 ;
11368 void *argp1 = 0 ;
11369 int res1 = 0 ;
11370 PyObject *swig_obj[1] ;
11371
11372 if (!args) SWIG_fail;
11373 swig_obj[0] = args;
11374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11375 if (!SWIG_IsOK(res1)) {
11376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11377 }
11378 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11379 {
11380 result = (PyObject *)wxRect2D_Get(arg1);
11381 if (PyErr_Occurred()) SWIG_fail;
11382 }
11383 resultobj = result;
11384 return resultobj;
11385fail:
11386 return NULL;
11387}
11388
11389
11390SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11391 PyObject *obj;
11392 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11393 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11394 return SWIG_Py_Void();
11395}
11396
11397SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11398 return SWIG_Python_InitShadowInstance(args);
11399}
11400
1bd55598
RD
11401SWIGINTERN int DefaultPosition_set(PyObject *) {
11402 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11403 return 1;
d55e5bfc
RD
11404}
11405
11406
1bd55598
RD
11407SWIGINTERN PyObject *DefaultPosition_get(void) {
11408 PyObject *pyobj = 0;
11409
11410 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11411 return pyobj;
d55e5bfc
RD
11412}
11413
11414
1bd55598
RD
11415SWIGINTERN int DefaultSize_set(PyObject *) {
11416 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11417 return 1;
d55e5bfc
RD
11418}
11419
11420
1bd55598
RD
11421SWIGINTERN PyObject *DefaultSize_get(void) {
11422 PyObject *pyobj = 0;
11423
11424 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11425 return pyobj;
d55e5bfc
RD
11426}
11427
11428
1bd55598
RD
11429SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11430 PyObject *resultobj = 0;
11431 PyObject *arg1 = (PyObject *) 0 ;
11432 wxPyInputStream *result = 0 ;
11433 PyObject * obj0 = 0 ;
11434 char * kwnames[] = {
11435 (char *) "p", NULL
11436 };
11437
11438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11439 arg1 = obj0;
11440 {
11441 PyThreadState* __tstate = wxPyBeginAllowThreads();
11442 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11443 wxPyEndAllowThreads(__tstate);
11444 if (PyErr_Occurred()) SWIG_fail;
11445 }
11446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11447 return resultobj;
11448fail:
11449 return NULL;
d55e5bfc
RD
11450}
11451
11452
1bd55598
RD
11453SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11454 PyObject *resultobj = 0;
11455 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11456 void *argp1 = 0 ;
11457 int res1 = 0 ;
11458 PyObject *swig_obj[1] ;
11459
11460 if (!args) SWIG_fail;
11461 swig_obj[0] = args;
11462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11463 if (!SWIG_IsOK(res1)) {
11464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11465 }
11466 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11467 {
11468 PyThreadState* __tstate = wxPyBeginAllowThreads();
11469 delete arg1;
d55e5bfc 11470
1bd55598
RD
11471 wxPyEndAllowThreads(__tstate);
11472 if (PyErr_Occurred()) SWIG_fail;
11473 }
11474 resultobj = SWIG_Py_Void();
11475 return resultobj;
11476fail:
11477 return NULL;
d55e5bfc
RD
11478}
11479
11480
1bd55598
RD
11481SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11482 PyObject *resultobj = 0;
11483 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11484 void *argp1 = 0 ;
11485 int res1 = 0 ;
11486 PyObject *swig_obj[1] ;
11487
11488 if (!args) SWIG_fail;
11489 swig_obj[0] = args;
11490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11491 if (!SWIG_IsOK(res1)) {
11492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11493 }
11494 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11495 {
11496 PyThreadState* __tstate = wxPyBeginAllowThreads();
11497 (arg1)->close();
11498 wxPyEndAllowThreads(__tstate);
11499 if (PyErr_Occurred()) SWIG_fail;
11500 }
11501 resultobj = SWIG_Py_Void();
11502 return resultobj;
11503fail:
11504 return NULL;
d55e5bfc
RD
11505}
11506
11507
1bd55598
RD
11508SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11509 PyObject *resultobj = 0;
11510 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11511 void *argp1 = 0 ;
11512 int res1 = 0 ;
11513 PyObject *swig_obj[1] ;
11514
11515 if (!args) SWIG_fail;
11516 swig_obj[0] = args;
11517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11518 if (!SWIG_IsOK(res1)) {
11519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11520 }
11521 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11522 {
11523 PyThreadState* __tstate = wxPyBeginAllowThreads();
11524 (arg1)->flush();
11525 wxPyEndAllowThreads(__tstate);
11526 if (PyErr_Occurred()) SWIG_fail;
11527 }
11528 resultobj = SWIG_Py_Void();
11529 return resultobj;
11530fail:
11531 return NULL;
d55e5bfc
RD
11532}
11533
11534
1bd55598
RD
11535SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11536 PyObject *resultobj = 0;
11537 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11538 bool result;
11539 void *argp1 = 0 ;
11540 int res1 = 0 ;
11541 PyObject *swig_obj[1] ;
11542
11543 if (!args) SWIG_fail;
11544 swig_obj[0] = args;
11545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11546 if (!SWIG_IsOK(res1)) {
11547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11548 }
11549 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11550 {
11551 PyThreadState* __tstate = wxPyBeginAllowThreads();
11552 result = (bool)(arg1)->eof();
11553 wxPyEndAllowThreads(__tstate);
11554 if (PyErr_Occurred()) SWIG_fail;
11555 }
11556 {
11557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11558 }
11559 return resultobj;
11560fail:
11561 return NULL;
11562}
11563
11564
11565SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11566 PyObject *resultobj = 0;
11567 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11568 int arg2 = (int) -1 ;
11569 PyObject *result = 0 ;
11570 void *argp1 = 0 ;
11571 int res1 = 0 ;
11572 int val2 ;
11573 int ecode2 = 0 ;
11574 PyObject * obj0 = 0 ;
11575 PyObject * obj1 = 0 ;
11576 char * kwnames[] = {
11577 (char *) "self",(char *) "size", NULL
11578 };
11579
11580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11582 if (!SWIG_IsOK(res1)) {
11583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11584 }
11585 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11586 if (obj1) {
11587 ecode2 = SWIG_AsVal_int(obj1, &val2);
11588 if (!SWIG_IsOK(ecode2)) {
11589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11590 }
11591 arg2 = static_cast< int >(val2);
11592 }
11593 {
11594 PyThreadState* __tstate = wxPyBeginAllowThreads();
11595 result = (PyObject *)(arg1)->read(arg2);
11596 wxPyEndAllowThreads(__tstate);
11597 if (PyErr_Occurred()) SWIG_fail;
11598 }
11599 resultobj = result;
11600 return resultobj;
11601fail:
11602 return NULL;
11603}
11604
11605
11606SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11607 PyObject *resultobj = 0;
11608 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11609 int arg2 = (int) -1 ;
11610 PyObject *result = 0 ;
11611 void *argp1 = 0 ;
11612 int res1 = 0 ;
11613 int val2 ;
11614 int ecode2 = 0 ;
11615 PyObject * obj0 = 0 ;
11616 PyObject * obj1 = 0 ;
11617 char * kwnames[] = {
11618 (char *) "self",(char *) "size", NULL
11619 };
11620
11621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11623 if (!SWIG_IsOK(res1)) {
11624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11625 }
11626 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11627 if (obj1) {
11628 ecode2 = SWIG_AsVal_int(obj1, &val2);
11629 if (!SWIG_IsOK(ecode2)) {
11630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11631 }
11632 arg2 = static_cast< int >(val2);
11633 }
11634 {
11635 PyThreadState* __tstate = wxPyBeginAllowThreads();
11636 result = (PyObject *)(arg1)->readline(arg2);
11637 wxPyEndAllowThreads(__tstate);
11638 if (PyErr_Occurred()) SWIG_fail;
11639 }
11640 resultobj = result;
11641 return resultobj;
11642fail:
11643 return NULL;
11644}
11645
11646
11647SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11648 PyObject *resultobj = 0;
11649 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11650 int arg2 = (int) -1 ;
11651 PyObject *result = 0 ;
11652 void *argp1 = 0 ;
11653 int res1 = 0 ;
11654 int val2 ;
11655 int ecode2 = 0 ;
11656 PyObject * obj0 = 0 ;
11657 PyObject * obj1 = 0 ;
11658 char * kwnames[] = {
11659 (char *) "self",(char *) "sizehint", NULL
11660 };
11661
11662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11664 if (!SWIG_IsOK(res1)) {
11665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11666 }
11667 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11668 if (obj1) {
11669 ecode2 = SWIG_AsVal_int(obj1, &val2);
11670 if (!SWIG_IsOK(ecode2)) {
11671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11672 }
11673 arg2 = static_cast< int >(val2);
11674 }
11675 {
11676 PyThreadState* __tstate = wxPyBeginAllowThreads();
11677 result = (PyObject *)(arg1)->readlines(arg2);
11678 wxPyEndAllowThreads(__tstate);
11679 if (PyErr_Occurred()) SWIG_fail;
11680 }
11681 resultobj = result;
11682 return resultobj;
11683fail:
11684 return NULL;
11685}
11686
11687
11688SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11689 PyObject *resultobj = 0;
11690 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11691 int arg2 ;
11692 int arg3 = (int) 0 ;
11693 void *argp1 = 0 ;
11694 int res1 = 0 ;
11695 int val2 ;
11696 int ecode2 = 0 ;
11697 int val3 ;
11698 int ecode3 = 0 ;
11699 PyObject * obj0 = 0 ;
11700 PyObject * obj1 = 0 ;
11701 PyObject * obj2 = 0 ;
11702 char * kwnames[] = {
11703 (char *) "self",(char *) "offset",(char *) "whence", NULL
11704 };
11705
11706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11708 if (!SWIG_IsOK(res1)) {
11709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11710 }
11711 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11712 ecode2 = SWIG_AsVal_int(obj1, &val2);
11713 if (!SWIG_IsOK(ecode2)) {
11714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11715 }
11716 arg2 = static_cast< int >(val2);
11717 if (obj2) {
11718 ecode3 = SWIG_AsVal_int(obj2, &val3);
11719 if (!SWIG_IsOK(ecode3)) {
11720 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11721 }
11722 arg3 = static_cast< int >(val3);
11723 }
11724 {
11725 PyThreadState* __tstate = wxPyBeginAllowThreads();
11726 (arg1)->seek(arg2,arg3);
11727 wxPyEndAllowThreads(__tstate);
11728 if (PyErr_Occurred()) SWIG_fail;
11729 }
11730 resultobj = SWIG_Py_Void();
11731 return resultobj;
11732fail:
11733 return NULL;
d55e5bfc
RD
11734}
11735
11736
1bd55598
RD
11737SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11738 PyObject *resultobj = 0;
11739 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11740 int result;
11741 void *argp1 = 0 ;
11742 int res1 = 0 ;
11743 PyObject *swig_obj[1] ;
11744
11745 if (!args) SWIG_fail;
11746 swig_obj[0] = args;
11747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11748 if (!SWIG_IsOK(res1)) {
11749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11750 }
11751 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11752 {
11753 PyThreadState* __tstate = wxPyBeginAllowThreads();
11754 result = (int)(arg1)->tell();
11755 wxPyEndAllowThreads(__tstate);
11756 if (PyErr_Occurred()) SWIG_fail;
11757 }
11758 resultobj = SWIG_From_int(static_cast< int >(result));
11759 return resultobj;
11760fail:
11761 return NULL;
d55e5bfc
RD
11762}
11763
11764
1bd55598
RD
11765SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11766 PyObject *resultobj = 0;
11767 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11768 char result;
11769 void *argp1 = 0 ;
11770 int res1 = 0 ;
11771 PyObject *swig_obj[1] ;
11772
11773 if (!args) SWIG_fail;
11774 swig_obj[0] = args;
11775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11776 if (!SWIG_IsOK(res1)) {
11777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11778 }
11779 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11780 {
11781 PyThreadState* __tstate = wxPyBeginAllowThreads();
11782 result = (char)(arg1)->Peek();
11783 wxPyEndAllowThreads(__tstate);
11784 if (PyErr_Occurred()) SWIG_fail;
11785 }
11786 resultobj = SWIG_From_char(static_cast< char >(result));
11787 return resultobj;
11788fail:
11789 return NULL;
d55e5bfc
RD
11790}
11791
11792
1bd55598
RD
11793SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11794 PyObject *resultobj = 0;
11795 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11796 char result;
11797 void *argp1 = 0 ;
11798 int res1 = 0 ;
11799 PyObject *swig_obj[1] ;
11800
11801 if (!args) SWIG_fail;
11802 swig_obj[0] = args;
11803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11804 if (!SWIG_IsOK(res1)) {
11805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11806 }
11807 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11808 {
11809 PyThreadState* __tstate = wxPyBeginAllowThreads();
11810 result = (char)(arg1)->GetC();
11811 wxPyEndAllowThreads(__tstate);
11812 if (PyErr_Occurred()) SWIG_fail;
11813 }
11814 resultobj = SWIG_From_char(static_cast< char >(result));
11815 return resultobj;
11816fail:
11817 return NULL;
d55e5bfc
RD
11818}
11819
11820
1bd55598
RD
11821SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11822 PyObject *resultobj = 0;
11823 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11824 size_t result;
11825 void *argp1 = 0 ;
11826 int res1 = 0 ;
11827 PyObject *swig_obj[1] ;
11828
11829 if (!args) SWIG_fail;
11830 swig_obj[0] = args;
11831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11832 if (!SWIG_IsOK(res1)) {
11833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11834 }
11835 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11836 {
11837 PyThreadState* __tstate = wxPyBeginAllowThreads();
11838 result = (size_t)(arg1)->LastRead();
11839 wxPyEndAllowThreads(__tstate);
11840 if (PyErr_Occurred()) SWIG_fail;
11841 }
11842 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11843 return resultobj;
11844fail:
11845 return NULL;
d55e5bfc
RD
11846}
11847
11848
1bd55598
RD
11849SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11850 PyObject *resultobj = 0;
11851 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11852 bool result;
11853 void *argp1 = 0 ;
11854 int res1 = 0 ;
11855 PyObject *swig_obj[1] ;
11856
11857 if (!args) SWIG_fail;
11858 swig_obj[0] = args;
11859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11860 if (!SWIG_IsOK(res1)) {
11861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11862 }
11863 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11864 {
11865 PyThreadState* __tstate = wxPyBeginAllowThreads();
11866 result = (bool)(arg1)->CanRead();
11867 wxPyEndAllowThreads(__tstate);
11868 if (PyErr_Occurred()) SWIG_fail;
11869 }
11870 {
11871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11872 }
11873 return resultobj;
11874fail:
11875 return NULL;
d55e5bfc
RD
11876}
11877
11878
1bd55598
RD
11879SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11880 PyObject *resultobj = 0;
11881 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11882 bool result;
11883 void *argp1 = 0 ;
11884 int res1 = 0 ;
11885 PyObject *swig_obj[1] ;
11886
11887 if (!args) SWIG_fail;
11888 swig_obj[0] = args;
11889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11890 if (!SWIG_IsOK(res1)) {
11891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11892 }
11893 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11894 {
11895 PyThreadState* __tstate = wxPyBeginAllowThreads();
11896 result = (bool)(arg1)->Eof();
11897 wxPyEndAllowThreads(__tstate);
11898 if (PyErr_Occurred()) SWIG_fail;
11899 }
11900 {
11901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11902 }
11903 return resultobj;
11904fail:
11905 return NULL;
11906}
11907
11908
11909SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11910 PyObject *resultobj = 0;
11911 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11912 char arg2 ;
11913 bool result;
11914 void *argp1 = 0 ;
11915 int res1 = 0 ;
11916 char val2 ;
11917 int ecode2 = 0 ;
11918 PyObject * obj0 = 0 ;
11919 PyObject * obj1 = 0 ;
11920 char * kwnames[] = {
11921 (char *) "self",(char *) "c", NULL
11922 };
11923
11924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11926 if (!SWIG_IsOK(res1)) {
11927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11928 }
11929 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11930 ecode2 = SWIG_AsVal_char(obj1, &val2);
11931 if (!SWIG_IsOK(ecode2)) {
11932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11933 }
11934 arg2 = static_cast< char >(val2);
11935 {
11936 PyThreadState* __tstate = wxPyBeginAllowThreads();
11937 result = (bool)(arg1)->Ungetch(arg2);
11938 wxPyEndAllowThreads(__tstate);
11939 if (PyErr_Occurred()) SWIG_fail;
11940 }
11941 {
11942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11943 }
11944 return resultobj;
11945fail:
11946 return NULL;
11947}
11948
11949
11950SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11951 PyObject *resultobj = 0;
11952 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11953 long arg2 ;
11954 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
11955 long result;
11956 void *argp1 = 0 ;
11957 int res1 = 0 ;
11958 long val2 ;
11959 int ecode2 = 0 ;
11960 int val3 ;
11961 int ecode3 = 0 ;
11962 PyObject * obj0 = 0 ;
11963 PyObject * obj1 = 0 ;
11964 PyObject * obj2 = 0 ;
11965 char * kwnames[] = {
11966 (char *) "self",(char *) "pos",(char *) "mode", NULL
11967 };
11968
11969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11971 if (!SWIG_IsOK(res1)) {
11972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11973 }
11974 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11975 ecode2 = SWIG_AsVal_long(obj1, &val2);
11976 if (!SWIG_IsOK(ecode2)) {
11977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
11978 }
11979 arg2 = static_cast< long >(val2);
11980 if (obj2) {
11981 ecode3 = SWIG_AsVal_int(obj2, &val3);
11982 if (!SWIG_IsOK(ecode3)) {
11983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
11984 }
11985 arg3 = static_cast< wxSeekMode >(val3);
11986 }
11987 {
11988 PyThreadState* __tstate = wxPyBeginAllowThreads();
11989 result = (long)(arg1)->SeekI(arg2,arg3);
11990 wxPyEndAllowThreads(__tstate);
11991 if (PyErr_Occurred()) SWIG_fail;
11992 }
11993 resultobj = SWIG_From_long(static_cast< long >(result));
11994 return resultobj;
11995fail:
11996 return NULL;
5cbf236d
RD
11997}
11998
11999
1bd55598
RD
12000SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12001 PyObject *resultobj = 0;
12002 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12003 long result;
12004 void *argp1 = 0 ;
12005 int res1 = 0 ;
12006 PyObject *swig_obj[1] ;
12007
12008 if (!args) SWIG_fail;
12009 swig_obj[0] = args;
12010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12011 if (!SWIG_IsOK(res1)) {
12012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12013 }
12014 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12015 {
12016 PyThreadState* __tstate = wxPyBeginAllowThreads();
12017 result = (long)(arg1)->TellI();
12018 wxPyEndAllowThreads(__tstate);
12019 if (PyErr_Occurred()) SWIG_fail;
12020 }
12021 resultobj = SWIG_From_long(static_cast< long >(result));
12022 return resultobj;
12023fail:
12024 return NULL;
d55e5bfc
RD
12025}
12026
12027
1bd55598
RD
12028SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12029 PyObject *obj;
12030 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12031 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12032 return SWIG_Py_Void();
d55e5bfc
RD
12033}
12034
1bd55598
RD
12035SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12036 return SWIG_Python_InitShadowInstance(args);
12037}
d55e5bfc 12038
1bd55598
RD
12039SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12040 PyObject *resultobj = 0;
12041 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12042 PyObject *arg2 = (PyObject *) 0 ;
12043 void *argp1 = 0 ;
12044 int res1 = 0 ;
12045 PyObject * obj0 = 0 ;
12046 PyObject * obj1 = 0 ;
12047 char * kwnames[] = {
12048 (char *) "self",(char *) "obj", NULL
12049 };
12050
12051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12053 if (!SWIG_IsOK(res1)) {
12054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12055 }
12056 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12057 arg2 = obj1;
12058 {
12059 PyThreadState* __tstate = wxPyBeginAllowThreads();
12060 wxOutputStream_write(arg1,arg2);
12061 wxPyEndAllowThreads(__tstate);
12062 if (PyErr_Occurred()) SWIG_fail;
12063 }
12064 resultobj = SWIG_Py_Void();
12065 return resultobj;
12066fail:
12067 return NULL;
d55e5bfc
RD
12068}
12069
12070
1bd55598
RD
12071SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12072 PyObject *resultobj = 0;
12073 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12074 size_t result;
12075 void *argp1 = 0 ;
12076 int res1 = 0 ;
12077 PyObject *swig_obj[1] ;
12078
12079 if (!args) SWIG_fail;
12080 swig_obj[0] = args;
12081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12082 if (!SWIG_IsOK(res1)) {
12083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12084 }
12085 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12086 {
12087 PyThreadState* __tstate = wxPyBeginAllowThreads();
12088 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12089 wxPyEndAllowThreads(__tstate);
12090 if (PyErr_Occurred()) SWIG_fail;
12091 }
12092 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12093 return resultobj;
12094fail:
12095 return NULL;
12096}
12097
12098
12099SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12100 PyObject *obj;
12101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12102 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12103 return SWIG_Py_Void();
12104}
12105
12106SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12107 PyObject *resultobj = 0;
12108 wxInputStream *arg1 = (wxInputStream *) 0 ;
12109 wxString *arg2 = 0 ;
12110 wxString *arg3 = 0 ;
12111 wxString *arg4 = 0 ;
12112 wxDateTime arg5 ;
12113 wxFSFile *result = 0 ;
12114 wxPyInputStream *temp1 ;
12115 bool temp2 = false ;
12116 bool temp3 = false ;
12117 bool temp4 = false ;
12118 void *argp5 ;
12119 int res5 = 0 ;
12120 PyObject * obj0 = 0 ;
12121 PyObject * obj1 = 0 ;
12122 PyObject * obj2 = 0 ;
12123 PyObject * obj3 = 0 ;
12124 PyObject * obj4 = 0 ;
12125 char * kwnames[] = {
12126 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12127 };
12128
12129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12130 {
12131 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12132 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12133 } else {
12134 PyErr_Clear(); // clear the failure of the wxPyConvert above
12135 arg1 = wxPyCBInputStream_create(obj0, true);
12136 if (arg1 == NULL) {
12137 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12138 SWIG_fail;
12139 }
d55e5bfc 12140 }
1bd55598
RD
12141 }
12142 {
12143 arg2 = wxString_in_helper(obj1);
12144 if (arg2 == NULL) SWIG_fail;
12145 temp2 = true;
12146 }
12147 {
12148 arg3 = wxString_in_helper(obj2);
12149 if (arg3 == NULL) SWIG_fail;
12150 temp3 = true;
12151 }
12152 {
12153 arg4 = wxString_in_helper(obj3);
12154 if (arg4 == NULL) SWIG_fail;
12155 temp4 = true;
12156 }
12157 {
12158 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12159 if (!SWIG_IsOK(res5)) {
12160 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12161 }
12162 if (!argp5) {
12163 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12164 } else {
12165 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12166 arg5 = *temp;
12167 if (SWIG_IsNewObj(res5)) delete temp;
d55e5bfc 12168 }
1bd55598
RD
12169 }
12170 {
12171 PyThreadState* __tstate = wxPyBeginAllowThreads();
12172 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12173 wxPyEndAllowThreads(__tstate);
12174 if (PyErr_Occurred()) SWIG_fail;
12175 }
b850e7f3 12176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
1bd55598
RD
12177 {
12178 if (temp2)
12179 delete arg2;
12180 }
12181 {
12182 if (temp3)
12183 delete arg3;
12184 }
12185 {
12186 if (temp4)
12187 delete arg4;
12188 }
12189 return resultobj;
12190fail:
12191 {
12192 if (temp2)
12193 delete arg2;
12194 }
12195 {
12196 if (temp3)
12197 delete arg3;
12198 }
12199 {
12200 if (temp4)
12201 delete arg4;
12202 }
12203 return NULL;
d55e5bfc
RD
12204}
12205
12206
1bd55598
RD
12207SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12208 PyObject *resultobj = 0;
12209 wxFSFile *arg1 = (wxFSFile *) 0 ;
12210 void *argp1 = 0 ;
12211 int res1 = 0 ;
12212 PyObject *swig_obj[1] ;
12213
12214 if (!args) SWIG_fail;
12215 swig_obj[0] = args;
12216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12217 if (!SWIG_IsOK(res1)) {
12218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12219 }
12220 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12221 {
12222 PyThreadState* __tstate = wxPyBeginAllowThreads();
12223 delete arg1;
d55e5bfc 12224
1bd55598
RD
12225 wxPyEndAllowThreads(__tstate);
12226 if (PyErr_Occurred()) SWIG_fail;
12227 }
12228 resultobj = SWIG_Py_Void();
12229 return resultobj;
12230fail:
12231 return NULL;
d55e5bfc
RD
12232}
12233
12234
1bd55598
RD
12235SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12236 PyObject *resultobj = 0;
12237 wxFSFile *arg1 = (wxFSFile *) 0 ;
12238 wxInputStream *result = 0 ;
12239 void *argp1 = 0 ;
12240 int res1 = 0 ;
12241 PyObject *swig_obj[1] ;
12242
12243 if (!args) SWIG_fail;
12244 swig_obj[0] = args;
12245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12246 if (!SWIG_IsOK(res1)) {
12247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12248 }
12249 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12250 {
12251 PyThreadState* __tstate = wxPyBeginAllowThreads();
12252 result = (wxInputStream *)(arg1)->GetStream();
12253 wxPyEndAllowThreads(__tstate);
12254 if (PyErr_Occurred()) SWIG_fail;
12255 }
12256 {
12257 wxPyInputStream * _ptr = NULL;
d55e5bfc 12258
1bd55598
RD
12259 if (result) {
12260 _ptr = new wxPyInputStream(result);
36ed4f51 12261 }
1bd55598
RD
12262 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12263 }
12264 return resultobj;
12265fail:
12266 return NULL;
d55e5bfc
RD
12267}
12268
12269
ac5d357a
RD
12270SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12271 PyObject *resultobj = 0;
12272 wxFSFile *arg1 = (wxFSFile *) 0 ;
12273 void *argp1 = 0 ;
12274 int res1 = 0 ;
12275 PyObject *swig_obj[1] ;
12276
12277 if (!args) SWIG_fail;
12278 swig_obj[0] = args;
12279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12280 if (!SWIG_IsOK(res1)) {
12281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12282 }
12283 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12284 {
12285 PyThreadState* __tstate = wxPyBeginAllowThreads();
12286 (arg1)->DetachStream();
12287 wxPyEndAllowThreads(__tstate);
12288 if (PyErr_Occurred()) SWIG_fail;
12289 }
12290 resultobj = SWIG_Py_Void();
12291 return resultobj;
12292fail:
12293 return NULL;
12294}
12295
12296
1bd55598
RD
12297SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12298 PyObject *resultobj = 0;
12299 wxFSFile *arg1 = (wxFSFile *) 0 ;
12300 wxString *result = 0 ;
12301 void *argp1 = 0 ;
12302 int res1 = 0 ;
12303 PyObject *swig_obj[1] ;
12304
12305 if (!args) SWIG_fail;
12306 swig_obj[0] = args;
12307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12308 if (!SWIG_IsOK(res1)) {
12309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12310 }
12311 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12312 {
12313 PyThreadState* __tstate = wxPyBeginAllowThreads();
d55e5bfc 12314 {
1bd55598
RD
12315 wxString const &_result_ref = (arg1)->GetMimeType();
12316 result = (wxString *) &_result_ref;
d55e5bfc 12317 }
1bd55598
RD
12318 wxPyEndAllowThreads(__tstate);
12319 if (PyErr_Occurred()) SWIG_fail;
12320 }
12321 {
12322#if wxUSE_UNICODE
12323 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12324#else
12325 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12326#endif
12327 }
12328 return resultobj;
12329fail:
12330 return NULL;
d55e5bfc
RD
12331}
12332
12333
1bd55598
RD
12334SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12335 PyObject *resultobj = 0;
12336 wxFSFile *arg1 = (wxFSFile *) 0 ;
12337 wxString *result = 0 ;
12338 void *argp1 = 0 ;
12339 int res1 = 0 ;
12340 PyObject *swig_obj[1] ;
12341
12342 if (!args) SWIG_fail;
12343 swig_obj[0] = args;
12344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12345 if (!SWIG_IsOK(res1)) {
12346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12347 }
12348 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12349 {
12350 PyThreadState* __tstate = wxPyBeginAllowThreads();
d55e5bfc 12351 {
1bd55598
RD
12352 wxString const &_result_ref = (arg1)->GetLocation();
12353 result = (wxString *) &_result_ref;
d55e5bfc 12354 }
1bd55598
RD
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 {
12359#if wxUSE_UNICODE
12360 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12361#else
12362 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12363#endif
12364 }
12365 return resultobj;
12366fail:
12367 return NULL;
d55e5bfc
RD
12368}
12369
12370
1bd55598
RD
12371SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12372 PyObject *resultobj = 0;
12373 wxFSFile *arg1 = (wxFSFile *) 0 ;
12374 wxString *result = 0 ;
12375 void *argp1 = 0 ;
12376 int res1 = 0 ;
12377 PyObject *swig_obj[1] ;
12378
12379 if (!args) SWIG_fail;
12380 swig_obj[0] = args;
12381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12382 if (!SWIG_IsOK(res1)) {
12383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12384 }
12385 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12386 {
12387 PyThreadState* __tstate = wxPyBeginAllowThreads();
b1fcee84 12388 {
1bd55598
RD
12389 wxString const &_result_ref = (arg1)->GetAnchor();
12390 result = (wxString *) &_result_ref;
b1fcee84 12391 }
1bd55598
RD
12392 wxPyEndAllowThreads(__tstate);
12393 if (PyErr_Occurred()) SWIG_fail;
12394 }
12395 {
12396#if wxUSE_UNICODE
12397 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12398#else
12399 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12400#endif
12401 }
12402 return resultobj;
12403fail:
12404 return NULL;
b1fcee84
RD
12405}
12406
12407
1bd55598
RD
12408SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12409 PyObject *resultobj = 0;
12410 wxFSFile *arg1 = (wxFSFile *) 0 ;
12411 wxDateTime result;
12412 void *argp1 = 0 ;
12413 int res1 = 0 ;
12414 PyObject *swig_obj[1] ;
12415
12416 if (!args) SWIG_fail;
12417 swig_obj[0] = args;
12418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12419 if (!SWIG_IsOK(res1)) {
12420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12421 }
12422 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12423 {
12424 PyThreadState* __tstate = wxPyBeginAllowThreads();
12425 result = (arg1)->GetModificationTime();
12426 wxPyEndAllowThreads(__tstate);
12427 if (PyErr_Occurred()) SWIG_fail;
12428 }
12429 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12430 return resultobj;
12431fail:
12432 return NULL;
d55e5bfc
RD
12433}
12434
12435
1bd55598
RD
12436SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12437 PyObject *obj;
12438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12439 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12440 return SWIG_Py_Void();
d55e5bfc
RD
12441}
12442
1bd55598
RD
12443SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12444 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
12445}
12446
50f151d7
RD
12447SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12448 PyObject *resultobj = 0;
12449 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12450 void *argp1 = 0 ;
12451 int res1 = 0 ;
12452 PyObject *swig_obj[1] ;
12453
12454 if (!args) SWIG_fail;
12455 swig_obj[0] = args;
12456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12457 if (!SWIG_IsOK(res1)) {
12458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12459 }
12460 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12461 {
12462 PyThreadState* __tstate = wxPyBeginAllowThreads();
12463 delete arg1;
12464
12465 wxPyEndAllowThreads(__tstate);
12466 if (PyErr_Occurred()) SWIG_fail;
12467 }
12468 resultobj = SWIG_Py_Void();
12469 return resultobj;
12470fail:
12471 return NULL;
12472}
12473
12474
1bd55598
RD
12475SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12476 PyObject *obj;
12477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12478 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12479 return SWIG_Py_Void();
d55e5bfc
RD
12480}
12481
1bd55598
RD
12482SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12483 PyObject *resultobj = 0;
12484 wxPyFileSystemHandler *result = 0 ;
12485
12486 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12487 {
12488 PyThreadState* __tstate = wxPyBeginAllowThreads();
12489 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12490 wxPyEndAllowThreads(__tstate);
12491 if (PyErr_Occurred()) SWIG_fail;
12492 }
12493 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12494 return resultobj;
12495fail:
12496 return NULL;
12497}
12498
12499
12500SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12501 PyObject *resultobj = 0;
12502 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12503 PyObject *arg2 = (PyObject *) 0 ;
12504 PyObject *arg3 = (PyObject *) 0 ;
12505 void *argp1 = 0 ;
12506 int res1 = 0 ;
12507 PyObject * obj0 = 0 ;
12508 PyObject * obj1 = 0 ;
12509 PyObject * obj2 = 0 ;
12510 char * kwnames[] = {
12511 (char *) "self",(char *) "self",(char *) "_class", NULL
12512 };
12513
12514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12516 if (!SWIG_IsOK(res1)) {
12517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12518 }
12519 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12520 arg2 = obj1;
12521 arg3 = obj2;
12522 {
12523 PyThreadState* __tstate = wxPyBeginAllowThreads();
12524 (arg1)->_setCallbackInfo(arg2,arg3);
12525 wxPyEndAllowThreads(__tstate);
12526 if (PyErr_Occurred()) SWIG_fail;
12527 }
12528 resultobj = SWIG_Py_Void();
12529 return resultobj;
12530fail:
12531 return NULL;
12532}
12533
12534
12535SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12536 PyObject *resultobj = 0;
12537 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12538 wxString *arg2 = 0 ;
12539 bool result;
12540 void *argp1 = 0 ;
12541 int res1 = 0 ;
12542 bool temp2 = false ;
12543 PyObject * obj0 = 0 ;
12544 PyObject * obj1 = 0 ;
12545 char * kwnames[] = {
12546 (char *) "self",(char *) "location", NULL
12547 };
12548
12549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12551 if (!SWIG_IsOK(res1)) {
12552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12553 }
12554 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12555 {
12556 arg2 = wxString_in_helper(obj1);
12557 if (arg2 == NULL) SWIG_fail;
12558 temp2 = true;
12559 }
12560 {
12561 PyThreadState* __tstate = wxPyBeginAllowThreads();
12562 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12563 wxPyEndAllowThreads(__tstate);
12564 if (PyErr_Occurred()) SWIG_fail;
12565 }
12566 {
12567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12568 }
12569 {
12570 if (temp2)
12571 delete arg2;
12572 }
12573 return resultobj;
12574fail:
12575 {
12576 if (temp2)
12577 delete arg2;
12578 }
12579 return NULL;
12580}
12581
12582
12583SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12584 PyObject *resultobj = 0;
12585 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12586 wxFileSystem *arg2 = 0 ;
12587 wxString *arg3 = 0 ;
12588 wxFSFile *result = 0 ;
12589 void *argp1 = 0 ;
12590 int res1 = 0 ;
12591 void *argp2 = 0 ;
12592 int res2 = 0 ;
12593 bool temp3 = false ;
12594 PyObject * obj0 = 0 ;
12595 PyObject * obj1 = 0 ;
12596 PyObject * obj2 = 0 ;
12597 char * kwnames[] = {
12598 (char *) "self",(char *) "fs",(char *) "location", NULL
12599 };
12600
12601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12603 if (!SWIG_IsOK(res1)) {
12604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12605 }
12606 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12607 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12608 if (!SWIG_IsOK(res2)) {
12609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12610 }
12611 if (!argp2) {
12612 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12613 }
12614 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12615 {
12616 arg3 = wxString_in_helper(obj2);
12617 if (arg3 == NULL) SWIG_fail;
12618 temp3 = true;
12619 }
12620 {
12621 PyThreadState* __tstate = wxPyBeginAllowThreads();
12622 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12623 wxPyEndAllowThreads(__tstate);
12624 if (PyErr_Occurred()) SWIG_fail;
12625 }
12626 {
b850e7f3 12627 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
1bd55598
RD
12628 }
12629 {
12630 if (temp3)
12631 delete arg3;
12632 }
12633 return resultobj;
12634fail:
12635 {
12636 if (temp3)
12637 delete arg3;
12638 }
12639 return NULL;
12640}
12641
12642
12643SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12644 PyObject *resultobj = 0;
12645 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12646 wxString *arg2 = 0 ;
12647 int arg3 = (int) 0 ;
12648 wxString result;
12649 void *argp1 = 0 ;
12650 int res1 = 0 ;
12651 bool temp2 = false ;
12652 int val3 ;
12653 int ecode3 = 0 ;
12654 PyObject * obj0 = 0 ;
12655 PyObject * obj1 = 0 ;
12656 PyObject * obj2 = 0 ;
12657 char * kwnames[] = {
12658 (char *) "self",(char *) "spec",(char *) "flags", NULL
12659 };
12660
12661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12663 if (!SWIG_IsOK(res1)) {
12664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12665 }
12666 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12667 {
12668 arg2 = wxString_in_helper(obj1);
12669 if (arg2 == NULL) SWIG_fail;
12670 temp2 = true;
12671 }
12672 if (obj2) {
12673 ecode3 = SWIG_AsVal_int(obj2, &val3);
12674 if (!SWIG_IsOK(ecode3)) {
12675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12676 }
12677 arg3 = static_cast< int >(val3);
12678 }
12679 {
12680 PyThreadState* __tstate = wxPyBeginAllowThreads();
12681 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12682 wxPyEndAllowThreads(__tstate);
12683 if (PyErr_Occurred()) SWIG_fail;
12684 }
12685 {
12686#if wxUSE_UNICODE
12687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12688#else
12689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12690#endif
12691 }
12692 {
12693 if (temp2)
12694 delete arg2;
12695 }
12696 return resultobj;
12697fail:
12698 {
12699 if (temp2)
12700 delete arg2;
12701 }
12702 return NULL;
d55e5bfc
RD
12703}
12704
12705
1bd55598
RD
12706SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12707 PyObject *resultobj = 0;
12708 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12709 wxString result;
12710 void *argp1 = 0 ;
12711 int res1 = 0 ;
12712 PyObject *swig_obj[1] ;
12713
12714 if (!args) SWIG_fail;
12715 swig_obj[0] = args;
12716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12717 if (!SWIG_IsOK(res1)) {
12718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12719 }
12720 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12721 {
12722 PyThreadState* __tstate = wxPyBeginAllowThreads();
12723 result = (arg1)->FindNext();
12724 wxPyEndAllowThreads(__tstate);
12725 if (PyErr_Occurred()) SWIG_fail;
12726 }
12727 {
12728#if wxUSE_UNICODE
12729 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12730#else
12731 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12732#endif
12733 }
12734 return resultobj;
12735fail:
12736 return NULL;
12737}
12738
12739
12740SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12741 PyObject *resultobj = 0;
12742 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12743 wxString *arg2 = 0 ;
12744 wxString result;
12745 void *argp1 = 0 ;
12746 int res1 = 0 ;
12747 bool temp2 = false ;
12748 PyObject * obj0 = 0 ;
12749 PyObject * obj1 = 0 ;
12750 char * kwnames[] = {
12751 (char *) "self",(char *) "location", NULL
12752 };
12753
12754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12756 if (!SWIG_IsOK(res1)) {
12757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12758 }
12759 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12760 {
12761 arg2 = wxString_in_helper(obj1);
12762 if (arg2 == NULL) SWIG_fail;
12763 temp2 = true;
12764 }
12765 {
12766 PyThreadState* __tstate = wxPyBeginAllowThreads();
12767 result = (arg1)->GetProtocol((wxString const &)*arg2);
12768 wxPyEndAllowThreads(__tstate);
12769 if (PyErr_Occurred()) SWIG_fail;
12770 }
12771 {
12772#if wxUSE_UNICODE
12773 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12774#else
12775 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12776#endif
12777 }
12778 {
12779 if (temp2)
12780 delete arg2;
12781 }
12782 return resultobj;
12783fail:
12784 {
12785 if (temp2)
12786 delete arg2;
12787 }
12788 return NULL;
12789}
12790
12791
12792SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12793 PyObject *resultobj = 0;
12794 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12795 wxString *arg2 = 0 ;
12796 wxString result;
12797 void *argp1 = 0 ;
12798 int res1 = 0 ;
12799 bool temp2 = false ;
12800 PyObject * obj0 = 0 ;
12801 PyObject * obj1 = 0 ;
12802 char * kwnames[] = {
12803 (char *) "self",(char *) "location", NULL
12804 };
12805
12806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12808 if (!SWIG_IsOK(res1)) {
12809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12810 }
12811 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12812 {
12813 arg2 = wxString_in_helper(obj1);
12814 if (arg2 == NULL) SWIG_fail;
12815 temp2 = true;
12816 }
12817 {
12818 PyThreadState* __tstate = wxPyBeginAllowThreads();
12819 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12820 wxPyEndAllowThreads(__tstate);
12821 if (PyErr_Occurred()) SWIG_fail;
12822 }
12823 {
12824#if wxUSE_UNICODE
12825 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12826#else
12827 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12828#endif
12829 }
12830 {
12831 if (temp2)
12832 delete arg2;
12833 }
12834 return resultobj;
12835fail:
12836 {
12837 if (temp2)
12838 delete arg2;
12839 }
12840 return NULL;
12841}
12842
12843
12844SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12845 PyObject *resultobj = 0;
12846 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12847 wxString *arg2 = 0 ;
12848 wxString result;
12849 void *argp1 = 0 ;
12850 int res1 = 0 ;
12851 bool temp2 = false ;
12852 PyObject * obj0 = 0 ;
12853 PyObject * obj1 = 0 ;
12854 char * kwnames[] = {
12855 (char *) "self",(char *) "location", NULL
12856 };
12857
12858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12860 if (!SWIG_IsOK(res1)) {
12861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12862 }
12863 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12864 {
12865 arg2 = wxString_in_helper(obj1);
12866 if (arg2 == NULL) SWIG_fail;
12867 temp2 = true;
12868 }
12869 {
12870 PyThreadState* __tstate = wxPyBeginAllowThreads();
12871 result = (arg1)->GetAnchor((wxString const &)*arg2);
12872 wxPyEndAllowThreads(__tstate);
12873 if (PyErr_Occurred()) SWIG_fail;
12874 }
12875 {
12876#if wxUSE_UNICODE
12877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12878#else
12879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12880#endif
12881 }
12882 {
12883 if (temp2)
12884 delete arg2;
12885 }
12886 return resultobj;
12887fail:
12888 {
12889 if (temp2)
12890 delete arg2;
12891 }
12892 return NULL;
12893}
12894
12895
12896SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12897 PyObject *resultobj = 0;
12898 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12899 wxString *arg2 = 0 ;
12900 wxString result;
12901 void *argp1 = 0 ;
12902 int res1 = 0 ;
12903 bool temp2 = false ;
12904 PyObject * obj0 = 0 ;
12905 PyObject * obj1 = 0 ;
12906 char * kwnames[] = {
12907 (char *) "self",(char *) "location", NULL
12908 };
12909
12910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12912 if (!SWIG_IsOK(res1)) {
12913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12914 }
12915 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12916 {
12917 arg2 = wxString_in_helper(obj1);
12918 if (arg2 == NULL) SWIG_fail;
12919 temp2 = true;
12920 }
12921 {
12922 PyThreadState* __tstate = wxPyBeginAllowThreads();
12923 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12924 wxPyEndAllowThreads(__tstate);
12925 if (PyErr_Occurred()) SWIG_fail;
12926 }
12927 {
12928#if wxUSE_UNICODE
12929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12930#else
12931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12932#endif
12933 }
12934 {
12935 if (temp2)
12936 delete arg2;
12937 }
12938 return resultobj;
12939fail:
12940 {
12941 if (temp2)
12942 delete arg2;
12943 }
12944 return NULL;
12945}
12946
12947
12948SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12949 PyObject *resultobj = 0;
12950 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12951 wxString *arg2 = 0 ;
12952 wxString result;
12953 void *argp1 = 0 ;
12954 int res1 = 0 ;
12955 bool temp2 = false ;
12956 PyObject * obj0 = 0 ;
12957 PyObject * obj1 = 0 ;
12958 char * kwnames[] = {
12959 (char *) "self",(char *) "location", NULL
12960 };
12961
12962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
12963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12964 if (!SWIG_IsOK(res1)) {
12965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12966 }
12967 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12968 {
12969 arg2 = wxString_in_helper(obj1);
12970 if (arg2 == NULL) SWIG_fail;
12971 temp2 = true;
12972 }
12973 {
12974 PyThreadState* __tstate = wxPyBeginAllowThreads();
12975 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
12976 wxPyEndAllowThreads(__tstate);
12977 if (PyErr_Occurred()) SWIG_fail;
12978 }
12979 {
12980#if wxUSE_UNICODE
12981 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12982#else
12983 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12984#endif
12985 }
12986 {
12987 if (temp2)
12988 delete arg2;
12989 }
12990 return resultobj;
12991fail:
12992 {
12993 if (temp2)
12994 delete arg2;
12995 }
12996 return NULL;
d55e5bfc
RD
12997}
12998
12999
1bd55598
RD
13000SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13001 PyObject *obj;
13002 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13003 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13004 return SWIG_Py_Void();
d55e5bfc
RD
13005}
13006
1bd55598
RD
13007SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13008 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
13009}
13010
1bd55598
RD
13011SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13012 PyObject *resultobj = 0;
13013 wxFileSystem *result = 0 ;
13014
13015 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13016 {
13017 PyThreadState* __tstate = wxPyBeginAllowThreads();
13018 result = (wxFileSystem *)new wxFileSystem();
13019 wxPyEndAllowThreads(__tstate);
13020 if (PyErr_Occurred()) SWIG_fail;
13021 }
3ecece7e 13022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
1bd55598
RD
13023 return resultobj;
13024fail:
13025 return NULL;
d55e5bfc
RD
13026}
13027
13028
1bd55598
RD
13029SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13030 PyObject *resultobj = 0;
13031 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13032 void *argp1 = 0 ;
13033 int res1 = 0 ;
13034 PyObject *swig_obj[1] ;
13035
13036 if (!args) SWIG_fail;
13037 swig_obj[0] = args;
13038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13039 if (!SWIG_IsOK(res1)) {
13040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13041 }
13042 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13043 {
13044 PyThreadState* __tstate = wxPyBeginAllowThreads();
13045 delete arg1;
d55e5bfc 13046
1bd55598
RD
13047 wxPyEndAllowThreads(__tstate);
13048 if (PyErr_Occurred()) SWIG_fail;
13049 }
13050 resultobj = SWIG_Py_Void();
13051 return resultobj;
13052fail:
13053 return NULL;
13054}
13055
13056
13057SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13058 PyObject *resultobj = 0;
13059 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13060 wxString *arg2 = 0 ;
13061 bool arg3 = (bool) false ;
13062 void *argp1 = 0 ;
13063 int res1 = 0 ;
13064 bool temp2 = false ;
13065 bool val3 ;
13066 int ecode3 = 0 ;
13067 PyObject * obj0 = 0 ;
13068 PyObject * obj1 = 0 ;
13069 PyObject * obj2 = 0 ;
13070 char * kwnames[] = {
13071 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13072 };
13073
13074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13076 if (!SWIG_IsOK(res1)) {
13077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13078 }
13079 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13080 {
13081 arg2 = wxString_in_helper(obj1);
13082 if (arg2 == NULL) SWIG_fail;
13083 temp2 = true;
13084 }
13085 if (obj2) {
13086 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13087 if (!SWIG_IsOK(ecode3)) {
13088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13089 }
13090 arg3 = static_cast< bool >(val3);
13091 }
13092 {
13093 PyThreadState* __tstate = wxPyBeginAllowThreads();
13094 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13095 wxPyEndAllowThreads(__tstate);
13096 if (PyErr_Occurred()) SWIG_fail;
13097 }
13098 resultobj = SWIG_Py_Void();
13099 {
13100 if (temp2)
13101 delete arg2;
13102 }
13103 return resultobj;
13104fail:
13105 {
13106 if (temp2)
13107 delete arg2;
13108 }
13109 return NULL;
d55e5bfc
RD
13110}
13111
13112
1bd55598
RD
13113SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13114 PyObject *resultobj = 0;
13115 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13116 wxString result;
13117 void *argp1 = 0 ;
13118 int res1 = 0 ;
13119 PyObject *swig_obj[1] ;
13120
13121 if (!args) SWIG_fail;
13122 swig_obj[0] = args;
13123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13124 if (!SWIG_IsOK(res1)) {
13125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13126 }
13127 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13128 {
13129 PyThreadState* __tstate = wxPyBeginAllowThreads();
13130 result = (arg1)->GetPath();
13131 wxPyEndAllowThreads(__tstate);
13132 if (PyErr_Occurred()) SWIG_fail;
13133 }
13134 {
13135#if wxUSE_UNICODE
13136 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13137#else
13138 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13139#endif
13140 }
13141 return resultobj;
13142fail:
13143 return NULL;
13144}
13145
13146
13147SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13148 PyObject *resultobj = 0;
13149 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13150 wxString *arg2 = 0 ;
13151 wxFSFile *result = 0 ;
13152 void *argp1 = 0 ;
13153 int res1 = 0 ;
13154 bool temp2 = false ;
13155 PyObject * obj0 = 0 ;
13156 PyObject * obj1 = 0 ;
13157 char * kwnames[] = {
13158 (char *) "self",(char *) "location", NULL
13159 };
13160
13161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13163 if (!SWIG_IsOK(res1)) {
13164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13165 }
13166 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13167 {
13168 arg2 = wxString_in_helper(obj1);
13169 if (arg2 == NULL) SWIG_fail;
13170 temp2 = true;
13171 }
13172 {
13173 PyThreadState* __tstate = wxPyBeginAllowThreads();
13174 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13175 wxPyEndAllowThreads(__tstate);
13176 if (PyErr_Occurred()) SWIG_fail;
13177 }
13178 {
b850e7f3 13179 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
1bd55598
RD
13180 }
13181 {
13182 if (temp2)
13183 delete arg2;
13184 }
13185 return resultobj;
13186fail:
13187 {
13188 if (temp2)
13189 delete arg2;
13190 }
13191 return NULL;
13192}
13193
13194
13195SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13196 PyObject *resultobj = 0;
13197 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13198 wxString *arg2 = 0 ;
13199 int arg3 = (int) 0 ;
13200 wxString result;
13201 void *argp1 = 0 ;
13202 int res1 = 0 ;
13203 bool temp2 = false ;
13204 int val3 ;
13205 int ecode3 = 0 ;
13206 PyObject * obj0 = 0 ;
13207 PyObject * obj1 = 0 ;
13208 PyObject * obj2 = 0 ;
13209 char * kwnames[] = {
13210 (char *) "self",(char *) "spec",(char *) "flags", NULL
13211 };
13212
13213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13215 if (!SWIG_IsOK(res1)) {
13216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13217 }
13218 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13219 {
13220 arg2 = wxString_in_helper(obj1);
13221 if (arg2 == NULL) SWIG_fail;
13222 temp2 = true;
13223 }
13224 if (obj2) {
13225 ecode3 = SWIG_AsVal_int(obj2, &val3);
13226 if (!SWIG_IsOK(ecode3)) {
13227 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13228 }
13229 arg3 = static_cast< int >(val3);
13230 }
13231 {
13232 PyThreadState* __tstate = wxPyBeginAllowThreads();
13233 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13234 wxPyEndAllowThreads(__tstate);
13235 if (PyErr_Occurred()) SWIG_fail;
13236 }
13237 {
13238#if wxUSE_UNICODE
13239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13240#else
13241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13242#endif
13243 }
13244 {
13245 if (temp2)
13246 delete arg2;
13247 }
13248 return resultobj;
13249fail:
13250 {
13251 if (temp2)
13252 delete arg2;
13253 }
13254 return NULL;
d55e5bfc
RD
13255}
13256
13257
1bd55598
RD
13258SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13259 PyObject *resultobj = 0;
13260 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13261 wxString result;
13262 void *argp1 = 0 ;
13263 int res1 = 0 ;
13264 PyObject *swig_obj[1] ;
13265
13266 if (!args) SWIG_fail;
13267 swig_obj[0] = args;
13268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13269 if (!SWIG_IsOK(res1)) {
13270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13271 }
13272 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13273 {
13274 PyThreadState* __tstate = wxPyBeginAllowThreads();
13275 result = (arg1)->FindNext();
13276 wxPyEndAllowThreads(__tstate);
13277 if (PyErr_Occurred()) SWIG_fail;
13278 }
13279 {
13280#if wxUSE_UNICODE
13281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13282#else
13283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13284#endif
13285 }
13286 return resultobj;
13287fail:
13288 return NULL;
d55e5bfc
RD
13289}
13290
13291
1bd55598
RD
13292SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13293 PyObject *resultobj = 0;
13294 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
1bd55598
RD
13295 int res1 = 0 ;
13296 PyObject * obj0 = 0 ;
13297 char * kwnames[] = {
13298 (char *) "handler", NULL
13299 };
13300
13301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
50f151d7 13302 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
1bd55598 13303 if (!SWIG_IsOK(res1)) {
50f151d7 13304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
1bd55598 13305 }
1bd55598
RD
13306 {
13307 PyThreadState* __tstate = wxPyBeginAllowThreads();
13308 wxFileSystem::AddHandler(arg1);
13309 wxPyEndAllowThreads(__tstate);
13310 if (PyErr_Occurred()) SWIG_fail;
13311 }
13312 resultobj = SWIG_Py_Void();
13313 return resultobj;
13314fail:
13315 return NULL;
d55e5bfc
RD
13316}
13317
13318
ac5d357a
RD
13319SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13320 PyObject *resultobj = 0;
13321 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13322 wxFileSystemHandler *result = 0 ;
13323 void *argp1 = 0 ;
13324 int res1 = 0 ;
13325 PyObject * obj0 = 0 ;
13326 char * kwnames[] = {
13327 (char *) "handler", NULL
13328 };
13329
13330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13332 if (!SWIG_IsOK(res1)) {
13333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13334 }
13335 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13336 {
13337 PyThreadState* __tstate = wxPyBeginAllowThreads();
13338 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13339 wxPyEndAllowThreads(__tstate);
13340 if (PyErr_Occurred()) SWIG_fail;
13341 }
13342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13343 return resultobj;
13344fail:
13345 return NULL;
13346}
13347
13348
1bd55598
RD
13349SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13350 PyObject *resultobj = 0;
13351
13352 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13353 {
13354 PyThreadState* __tstate = wxPyBeginAllowThreads();
13355 wxFileSystem::CleanUpHandlers();
13356 wxPyEndAllowThreads(__tstate);
13357 if (PyErr_Occurred()) SWIG_fail;
13358 }
13359 resultobj = SWIG_Py_Void();
13360 return resultobj;
13361fail:
13362 return NULL;
d55e5bfc
RD
13363}
13364
13365
1bd55598
RD
13366SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13367 PyObject *resultobj = 0;
13368 wxString *arg1 = 0 ;
13369 wxString result;
13370 bool temp1 = false ;
13371 PyObject * obj0 = 0 ;
13372 char * kwnames[] = {
13373 (char *) "filename", NULL
13374 };
13375
13376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13377 {
13378 arg1 = wxString_in_helper(obj0);
13379 if (arg1 == NULL) SWIG_fail;
13380 temp1 = true;
13381 }
13382 {
13383 PyThreadState* __tstate = wxPyBeginAllowThreads();
13384 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13385 wxPyEndAllowThreads(__tstate);
13386 if (PyErr_Occurred()) SWIG_fail;
13387 }
13388 {
13389#if wxUSE_UNICODE
13390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13391#else
13392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13393#endif
13394 }
13395 {
13396 if (temp1)
13397 delete arg1;
13398 }
13399 return resultobj;
13400fail:
13401 {
13402 if (temp1)
13403 delete arg1;
13404 }
13405 return NULL;
d55e5bfc
RD
13406}
13407
13408
1bd55598
RD
13409SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13410 PyObject *resultobj = 0;
13411 wxString *arg1 = 0 ;
13412 wxString result;
13413 bool temp1 = false ;
13414 PyObject * obj0 = 0 ;
13415 char * kwnames[] = {
13416 (char *) "url", NULL
13417 };
13418
13419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13420 {
13421 arg1 = wxString_in_helper(obj0);
13422 if (arg1 == NULL) SWIG_fail;
13423 temp1 = true;
13424 }
13425 {
13426 PyThreadState* __tstate = wxPyBeginAllowThreads();
13427 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13428 wxPyEndAllowThreads(__tstate);
13429 if (PyErr_Occurred()) SWIG_fail;
13430 }
13431 {
13432#if wxUSE_UNICODE
13433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13434#else
13435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13436#endif
13437 }
13438 {
13439 if (temp1)
13440 delete arg1;
13441 }
13442 return resultobj;
13443fail:
13444 {
13445 if (temp1)
13446 delete arg1;
13447 }
13448 return NULL;
d55e5bfc
RD
13449}
13450
13451
1bd55598
RD
13452SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13453 PyObject *obj;
13454 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13455 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13456 return SWIG_Py_Void();
d55e5bfc
RD
13457}
13458
1bd55598
RD
13459SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13460 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
13461}
13462
1bd55598
RD
13463SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13464 PyObject *resultobj = 0;
13465 wxInternetFSHandler *result = 0 ;
13466
13467 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13468 {
13469 PyThreadState* __tstate = wxPyBeginAllowThreads();
13470 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13471 wxPyEndAllowThreads(__tstate);
13472 if (PyErr_Occurred()) SWIG_fail;
13473 }
13474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13475 return resultobj;
13476fail:
13477 return NULL;
13478}
13479
13480
13481SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13482 PyObject *resultobj = 0;
13483 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13484 wxString *arg2 = 0 ;
13485 bool result;
13486 void *argp1 = 0 ;
13487 int res1 = 0 ;
13488 bool temp2 = false ;
13489 PyObject * obj0 = 0 ;
13490 PyObject * obj1 = 0 ;
13491 char * kwnames[] = {
13492 (char *) "self",(char *) "location", NULL
13493 };
13494
13495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13497 if (!SWIG_IsOK(res1)) {
13498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13499 }
13500 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13501 {
13502 arg2 = wxString_in_helper(obj1);
13503 if (arg2 == NULL) SWIG_fail;
13504 temp2 = true;
13505 }
13506 {
13507 PyThreadState* __tstate = wxPyBeginAllowThreads();
13508 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13509 wxPyEndAllowThreads(__tstate);
13510 if (PyErr_Occurred()) SWIG_fail;
13511 }
13512 {
13513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13514 }
13515 {
13516 if (temp2)
13517 delete arg2;
13518 }
13519 return resultobj;
13520fail:
13521 {
13522 if (temp2)
13523 delete arg2;
13524 }
13525 return NULL;
13526}
13527
13528
13529SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13530 PyObject *resultobj = 0;
13531 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13532 wxFileSystem *arg2 = 0 ;
13533 wxString *arg3 = 0 ;
13534 wxFSFile *result = 0 ;
13535 void *argp1 = 0 ;
13536 int res1 = 0 ;
13537 void *argp2 = 0 ;
13538 int res2 = 0 ;
13539 bool temp3 = false ;
13540 PyObject * obj0 = 0 ;
13541 PyObject * obj1 = 0 ;
13542 PyObject * obj2 = 0 ;
13543 char * kwnames[] = {
13544 (char *) "self",(char *) "fs",(char *) "location", NULL
13545 };
13546
13547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13549 if (!SWIG_IsOK(res1)) {
13550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13551 }
13552 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13553 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13554 if (!SWIG_IsOK(res2)) {
13555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13556 }
13557 if (!argp2) {
13558 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13559 }
13560 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13561 {
13562 arg3 = wxString_in_helper(obj2);
13563 if (arg3 == NULL) SWIG_fail;
13564 temp3 = true;
13565 }
13566 {
13567 PyThreadState* __tstate = wxPyBeginAllowThreads();
13568 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13569 wxPyEndAllowThreads(__tstate);
13570 if (PyErr_Occurred()) SWIG_fail;
13571 }
13572 {
b850e7f3 13573 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
1bd55598
RD
13574 }
13575 {
13576 if (temp3)
13577 delete arg3;
13578 }
13579 return resultobj;
13580fail:
13581 {
13582 if (temp3)
13583 delete arg3;
13584 }
13585 return NULL;
d55e5bfc
RD
13586}
13587
13588
1bd55598
RD
13589SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13590 PyObject *obj;
13591 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13592 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13593 return SWIG_Py_Void();
d55e5bfc
RD
13594}
13595
1bd55598
RD
13596SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13597 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
13598}
13599
1bd55598
RD
13600SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13601 PyObject *resultobj = 0;
13602 wxZipFSHandler *result = 0 ;
13603
13604 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13605 {
13606 PyThreadState* __tstate = wxPyBeginAllowThreads();
13607 result = (wxZipFSHandler *)new wxZipFSHandler();
13608 wxPyEndAllowThreads(__tstate);
13609 if (PyErr_Occurred()) SWIG_fail;
13610 }
13611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13612 return resultobj;
13613fail:
13614 return NULL;
13615}
13616
13617
13618SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13619 PyObject *resultobj = 0;
13620 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13621 wxString *arg2 = 0 ;
13622 bool result;
13623 void *argp1 = 0 ;
13624 int res1 = 0 ;
13625 bool temp2 = false ;
13626 PyObject * obj0 = 0 ;
13627 PyObject * obj1 = 0 ;
13628 char * kwnames[] = {
13629 (char *) "self",(char *) "location", NULL
13630 };
13631
13632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13634 if (!SWIG_IsOK(res1)) {
13635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13636 }
13637 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13638 {
13639 arg2 = wxString_in_helper(obj1);
13640 if (arg2 == NULL) SWIG_fail;
13641 temp2 = true;
13642 }
13643 {
13644 PyThreadState* __tstate = wxPyBeginAllowThreads();
13645 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13646 wxPyEndAllowThreads(__tstate);
13647 if (PyErr_Occurred()) SWIG_fail;
13648 }
13649 {
13650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13651 }
13652 {
13653 if (temp2)
13654 delete arg2;
13655 }
13656 return resultobj;
13657fail:
13658 {
13659 if (temp2)
13660 delete arg2;
13661 }
13662 return NULL;
13663}
13664
13665
13666SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13667 PyObject *resultobj = 0;
13668 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13669 wxFileSystem *arg2 = 0 ;
13670 wxString *arg3 = 0 ;
13671 wxFSFile *result = 0 ;
13672 void *argp1 = 0 ;
13673 int res1 = 0 ;
13674 void *argp2 = 0 ;
13675 int res2 = 0 ;
13676 bool temp3 = false ;
13677 PyObject * obj0 = 0 ;
13678 PyObject * obj1 = 0 ;
13679 PyObject * obj2 = 0 ;
13680 char * kwnames[] = {
13681 (char *) "self",(char *) "fs",(char *) "location", NULL
13682 };
13683
13684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13686 if (!SWIG_IsOK(res1)) {
13687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13688 }
13689 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13690 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13691 if (!SWIG_IsOK(res2)) {
13692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13693 }
13694 if (!argp2) {
13695 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13696 }
13697 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13698 {
13699 arg3 = wxString_in_helper(obj2);
13700 if (arg3 == NULL) SWIG_fail;
13701 temp3 = true;
13702 }
13703 {
13704 PyThreadState* __tstate = wxPyBeginAllowThreads();
13705 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13706 wxPyEndAllowThreads(__tstate);
13707 if (PyErr_Occurred()) SWIG_fail;
13708 }
13709 {
b850e7f3 13710 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
1bd55598
RD
13711 }
13712 {
13713 if (temp3)
13714 delete arg3;
13715 }
13716 return resultobj;
13717fail:
13718 {
13719 if (temp3)
13720 delete arg3;
13721 }
13722 return NULL;
13723}
13724
13725
13726SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13727 PyObject *resultobj = 0;
13728 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13729 wxString *arg2 = 0 ;
13730 int arg3 = (int) 0 ;
13731 wxString result;
13732 void *argp1 = 0 ;
13733 int res1 = 0 ;
13734 bool temp2 = false ;
13735 int val3 ;
13736 int ecode3 = 0 ;
13737 PyObject * obj0 = 0 ;
13738 PyObject * obj1 = 0 ;
13739 PyObject * obj2 = 0 ;
13740 char * kwnames[] = {
13741 (char *) "self",(char *) "spec",(char *) "flags", NULL
13742 };
13743
13744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13746 if (!SWIG_IsOK(res1)) {
13747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13748 }
13749 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13750 {
13751 arg2 = wxString_in_helper(obj1);
13752 if (arg2 == NULL) SWIG_fail;
13753 temp2 = true;
13754 }
13755 if (obj2) {
13756 ecode3 = SWIG_AsVal_int(obj2, &val3);
13757 if (!SWIG_IsOK(ecode3)) {
13758 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13759 }
13760 arg3 = static_cast< int >(val3);
13761 }
13762 {
13763 PyThreadState* __tstate = wxPyBeginAllowThreads();
13764 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13765 wxPyEndAllowThreads(__tstate);
13766 if (PyErr_Occurred()) SWIG_fail;
13767 }
13768 {
13769#if wxUSE_UNICODE
13770 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13771#else
13772 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13773#endif
13774 }
13775 {
13776 if (temp2)
13777 delete arg2;
13778 }
13779 return resultobj;
13780fail:
13781 {
13782 if (temp2)
13783 delete arg2;
13784 }
13785 return NULL;
d55e5bfc
RD
13786}
13787
13788
1bd55598
RD
13789SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13790 PyObject *resultobj = 0;
13791 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13792 wxString result;
13793 void *argp1 = 0 ;
13794 int res1 = 0 ;
13795 PyObject *swig_obj[1] ;
13796
13797 if (!args) SWIG_fail;
13798 swig_obj[0] = args;
13799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13800 if (!SWIG_IsOK(res1)) {
13801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13802 }
13803 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13804 {
13805 PyThreadState* __tstate = wxPyBeginAllowThreads();
13806 result = (arg1)->FindNext();
13807 wxPyEndAllowThreads(__tstate);
13808 if (PyErr_Occurred()) SWIG_fail;
13809 }
13810 {
13811#if wxUSE_UNICODE
13812 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13813#else
13814 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13815#endif
13816 }
13817 return resultobj;
13818fail:
13819 return NULL;
13820}
13821
13822
13823SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13824 PyObject *obj;
13825 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13826 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13827 return SWIG_Py_Void();
13828}
13829
13830SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13831 return SWIG_Python_InitShadowInstance(args);
13832}
13833
13834SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13835 PyObject *resultobj = 0;
13836 wxString *arg1 = 0 ;
13837 wxImage *arg2 = 0 ;
13838 long arg3 ;
13839 bool temp1 = false ;
13840 void *argp2 = 0 ;
13841 int res2 = 0 ;
13842 long val3 ;
13843 int ecode3 = 0 ;
13844 PyObject * obj0 = 0 ;
13845 PyObject * obj1 = 0 ;
13846 PyObject * obj2 = 0 ;
13847 char * kwnames[] = {
13848 (char *) "filename",(char *) "image",(char *) "type", NULL
13849 };
13850
13851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13852 {
13853 arg1 = wxString_in_helper(obj0);
13854 if (arg1 == NULL) SWIG_fail;
13855 temp1 = true;
13856 }
13857 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13858 if (!SWIG_IsOK(res2)) {
13859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13860 }
13861 if (!argp2) {
13862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13863 }
13864 arg2 = reinterpret_cast< wxImage * >(argp2);
13865 ecode3 = SWIG_AsVal_long(obj2, &val3);
13866 if (!SWIG_IsOK(ecode3)) {
13867 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13868 }
13869 arg3 = static_cast< long >(val3);
13870 {
13871 PyThreadState* __tstate = wxPyBeginAllowThreads();
13872 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13873 wxPyEndAllowThreads(__tstate);
13874 if (PyErr_Occurred()) SWIG_fail;
13875 }
13876 resultobj = SWIG_Py_Void();
13877 {
13878 if (temp1)
13879 delete arg1;
13880 }
13881 return resultobj;
13882fail:
13883 {
13884 if (temp1)
13885 delete arg1;
13886 }
13887 return NULL;
13888}
13889
13890
13891SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13892 PyObject *resultobj = 0;
13893 wxString *arg1 = 0 ;
13894 wxBitmap *arg2 = 0 ;
13895 long arg3 ;
13896 bool temp1 = false ;
13897 void *argp2 = 0 ;
13898 int res2 = 0 ;
13899 long val3 ;
13900 int ecode3 = 0 ;
13901 PyObject * obj0 = 0 ;
13902 PyObject * obj1 = 0 ;
13903 PyObject * obj2 = 0 ;
13904 char * kwnames[] = {
13905 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13906 };
13907
13908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13909 {
13910 arg1 = wxString_in_helper(obj0);
13911 if (arg1 == NULL) SWIG_fail;
13912 temp1 = true;
13913 }
13914 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13915 if (!SWIG_IsOK(res2)) {
13916 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13917 }
13918 if (!argp2) {
13919 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13920 }
13921 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13922 ecode3 = SWIG_AsVal_long(obj2, &val3);
13923 if (!SWIG_IsOK(ecode3)) {
13924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13925 }
13926 arg3 = static_cast< long >(val3);
13927 {
13928 PyThreadState* __tstate = wxPyBeginAllowThreads();
13929 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13930 wxPyEndAllowThreads(__tstate);
13931 if (PyErr_Occurred()) SWIG_fail;
13932 }
13933 resultobj = SWIG_Py_Void();
13934 {
13935 if (temp1)
13936 delete arg1;
13937 }
13938 return resultobj;
13939fail:
13940 {
13941 if (temp1)
13942 delete arg1;
13943 }
13944 return NULL;
d55e5bfc
RD
13945}
13946
13947
1bd55598
RD
13948SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13949 PyObject *resultobj = 0;
13950 wxString *arg1 = 0 ;
13951 PyObject *arg2 = (PyObject *) 0 ;
13952 bool temp1 = false ;
13953 PyObject * obj0 = 0 ;
13954 PyObject * obj1 = 0 ;
13955 char * kwnames[] = {
13956 (char *) "filename",(char *) "data", NULL
13957 };
13958
13959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
13960 {
13961 arg1 = wxString_in_helper(obj0);
13962 if (arg1 == NULL) SWIG_fail;
13963 temp1 = true;
13964 }
13965 arg2 = obj1;
13966 {
13967 PyThreadState* __tstate = wxPyBeginAllowThreads();
13968 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
13969 wxPyEndAllowThreads(__tstate);
13970 if (PyErr_Occurred()) SWIG_fail;
13971 }
13972 resultobj = SWIG_Py_Void();
13973 {
13974 if (temp1)
13975 delete arg1;
13976 }
13977 return resultobj;
13978fail:
13979 {
13980 if (temp1)
13981 delete arg1;
13982 }
13983 return NULL;
d55e5bfc
RD
13984}
13985
13986
1bd55598
RD
13987SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13988 PyObject *resultobj = 0;
13989 wxMemoryFSHandler *result = 0 ;
13990
13991 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
13992 {
13993 PyThreadState* __tstate = wxPyBeginAllowThreads();
13994 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
13995 wxPyEndAllowThreads(__tstate);
13996 if (PyErr_Occurred()) SWIG_fail;
13997 }
13998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
13999 return resultobj;
14000fail:
14001 return NULL;
d55e5bfc
RD
14002}
14003
14004
1bd55598
RD
14005SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14006 PyObject *resultobj = 0;
14007 wxString *arg1 = 0 ;
14008 bool temp1 = false ;
14009 PyObject * obj0 = 0 ;
14010 char * kwnames[] = {
14011 (char *) "filename", NULL
14012 };
14013
14014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14015 {
14016 arg1 = wxString_in_helper(obj0);
14017 if (arg1 == NULL) SWIG_fail;
14018 temp1 = true;
14019 }
14020 {
14021 PyThreadState* __tstate = wxPyBeginAllowThreads();
14022 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14023 wxPyEndAllowThreads(__tstate);
14024 if (PyErr_Occurred()) SWIG_fail;
14025 }
14026 resultobj = SWIG_Py_Void();
14027 {
14028 if (temp1)
14029 delete arg1;
14030 }
14031 return resultobj;
14032fail:
14033 {
14034 if (temp1)
14035 delete arg1;
14036 }
14037 return NULL;
14038}
14039
14040
14041SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14042 PyObject *resultobj = 0;
14043 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14044 wxString *arg2 = 0 ;
14045 bool result;
14046 void *argp1 = 0 ;
14047 int res1 = 0 ;
14048 bool temp2 = false ;
14049 PyObject * obj0 = 0 ;
14050 PyObject * obj1 = 0 ;
14051 char * kwnames[] = {
14052 (char *) "self",(char *) "location", NULL
14053 };
14054
14055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14057 if (!SWIG_IsOK(res1)) {
14058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14059 }
14060 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14061 {
14062 arg2 = wxString_in_helper(obj1);
14063 if (arg2 == NULL) SWIG_fail;
14064 temp2 = true;
14065 }
14066 {
14067 PyThreadState* __tstate = wxPyBeginAllowThreads();
14068 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14069 wxPyEndAllowThreads(__tstate);
14070 if (PyErr_Occurred()) SWIG_fail;
14071 }
14072 {
14073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14074 }
14075 {
14076 if (temp2)
14077 delete arg2;
14078 }
14079 return resultobj;
14080fail:
14081 {
14082 if (temp2)
14083 delete arg2;
14084 }
14085 return NULL;
14086}
14087
14088
14089SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14090 PyObject *resultobj = 0;
14091 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14092 wxFileSystem *arg2 = 0 ;
14093 wxString *arg3 = 0 ;
14094 wxFSFile *result = 0 ;
14095 void *argp1 = 0 ;
14096 int res1 = 0 ;
14097 void *argp2 = 0 ;
14098 int res2 = 0 ;
14099 bool temp3 = false ;
14100 PyObject * obj0 = 0 ;
14101 PyObject * obj1 = 0 ;
14102 PyObject * obj2 = 0 ;
14103 char * kwnames[] = {
14104 (char *) "self",(char *) "fs",(char *) "location", NULL
14105 };
14106
14107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14109 if (!SWIG_IsOK(res1)) {
14110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14111 }
14112 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14113 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14114 if (!SWIG_IsOK(res2)) {
14115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14116 }
14117 if (!argp2) {
14118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14119 }
14120 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14121 {
14122 arg3 = wxString_in_helper(obj2);
14123 if (arg3 == NULL) SWIG_fail;
14124 temp3 = true;
14125 }
14126 {
14127 PyThreadState* __tstate = wxPyBeginAllowThreads();
14128 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14129 wxPyEndAllowThreads(__tstate);
14130 if (PyErr_Occurred()) SWIG_fail;
14131 }
14132 {
b850e7f3 14133 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
1bd55598
RD
14134 }
14135 {
14136 if (temp3)
14137 delete arg3;
14138 }
14139 return resultobj;
14140fail:
14141 {
14142 if (temp3)
14143 delete arg3;
14144 }
14145 return NULL;
14146}
14147
14148
14149SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14150 PyObject *resultobj = 0;
14151 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14152 wxString *arg2 = 0 ;
14153 int arg3 = (int) 0 ;
14154 wxString result;
14155 void *argp1 = 0 ;
14156 int res1 = 0 ;
14157 bool temp2 = false ;
14158 int val3 ;
14159 int ecode3 = 0 ;
14160 PyObject * obj0 = 0 ;
14161 PyObject * obj1 = 0 ;
14162 PyObject * obj2 = 0 ;
14163 char * kwnames[] = {
14164 (char *) "self",(char *) "spec",(char *) "flags", NULL
14165 };
14166
14167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14169 if (!SWIG_IsOK(res1)) {
14170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14171 }
14172 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14173 {
14174 arg2 = wxString_in_helper(obj1);
14175 if (arg2 == NULL) SWIG_fail;
14176 temp2 = true;
14177 }
14178 if (obj2) {
14179 ecode3 = SWIG_AsVal_int(obj2, &val3);
14180 if (!SWIG_IsOK(ecode3)) {
14181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14182 }
14183 arg3 = static_cast< int >(val3);
14184 }
14185 {
14186 PyThreadState* __tstate = wxPyBeginAllowThreads();
14187 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14188 wxPyEndAllowThreads(__tstate);
14189 if (PyErr_Occurred()) SWIG_fail;
14190 }
14191 {
14192#if wxUSE_UNICODE
14193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14194#else
14195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14196#endif
14197 }
14198 {
14199 if (temp2)
14200 delete arg2;
14201 }
14202 return resultobj;
14203fail:
14204 {
14205 if (temp2)
14206 delete arg2;
14207 }
14208 return NULL;
d55e5bfc
RD
14209}
14210
14211
1bd55598
RD
14212SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14213 PyObject *resultobj = 0;
14214 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14215 wxString result;
14216 void *argp1 = 0 ;
14217 int res1 = 0 ;
14218 PyObject *swig_obj[1] ;
14219
14220 if (!args) SWIG_fail;
14221 swig_obj[0] = args;
14222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14223 if (!SWIG_IsOK(res1)) {
14224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14225 }
14226 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14227 {
14228 PyThreadState* __tstate = wxPyBeginAllowThreads();
14229 result = (arg1)->FindNext();
14230 wxPyEndAllowThreads(__tstate);
14231 if (PyErr_Occurred()) SWIG_fail;
14232 }
14233 {
14234#if wxUSE_UNICODE
14235 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14236#else
14237 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14238#endif
14239 }
14240 return resultobj;
14241fail:
14242 return NULL;
d55e5bfc
RD
14243}
14244
14245
1bd55598
RD
14246SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14247 PyObject *obj;
14248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14249 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14250 return SWIG_Py_Void();
d55e5bfc
RD
14251}
14252
1bd55598
RD
14253SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14254 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
14255}
14256
1bd55598
RD
14257SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14258 PyObject *resultobj = 0;
14259 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14260 wxString result;
14261 void *argp1 = 0 ;
14262 int res1 = 0 ;
14263 PyObject *swig_obj[1] ;
14264
14265 if (!args) SWIG_fail;
14266 swig_obj[0] = args;
14267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14268 if (!SWIG_IsOK(res1)) {
14269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14270 }
14271 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14272 {
14273 PyThreadState* __tstate = wxPyBeginAllowThreads();
14274 result = (arg1)->GetName();
14275 wxPyEndAllowThreads(__tstate);
14276 if (PyErr_Occurred()) SWIG_fail;
14277 }
14278 {
14279#if wxUSE_UNICODE
14280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14281#else
14282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14283#endif
14284 }
14285 return resultobj;
14286fail:
14287 return NULL;
d55e5bfc
RD
14288}
14289
14290
1bd55598
RD
14291SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14292 PyObject *resultobj = 0;
14293 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14294 wxString result;
14295 void *argp1 = 0 ;
14296 int res1 = 0 ;
14297 PyObject *swig_obj[1] ;
14298
14299 if (!args) SWIG_fail;
14300 swig_obj[0] = args;
14301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14302 if (!SWIG_IsOK(res1)) {
14303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14304 }
14305 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14306 {
14307 PyThreadState* __tstate = wxPyBeginAllowThreads();
14308 result = (arg1)->GetExtension();
14309 wxPyEndAllowThreads(__tstate);
14310 if (PyErr_Occurred()) SWIG_fail;
14311 }
14312 {
14313#if wxUSE_UNICODE
14314 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14315#else
14316 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14317#endif
14318 }
14319 return resultobj;
14320fail:
14321 return NULL;
d55e5bfc
RD
14322}
14323
14324
1bd55598
RD
14325SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14326 PyObject *resultobj = 0;
14327 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14328 long result;
14329 void *argp1 = 0 ;
14330 int res1 = 0 ;
14331 PyObject *swig_obj[1] ;
14332
14333 if (!args) SWIG_fail;
14334 swig_obj[0] = args;
14335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14336 if (!SWIG_IsOK(res1)) {
14337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14338 }
14339 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14340 {
14341 PyThreadState* __tstate = wxPyBeginAllowThreads();
14342 result = (long)(arg1)->GetType();
14343 wxPyEndAllowThreads(__tstate);
14344 if (PyErr_Occurred()) SWIG_fail;
14345 }
14346 resultobj = SWIG_From_long(static_cast< long >(result));
14347 return resultobj;
14348fail:
14349 return NULL;
d55e5bfc
RD
14350}
14351
14352
1bd55598
RD
14353SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14354 PyObject *resultobj = 0;
14355 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14356 wxString result;
14357 void *argp1 = 0 ;
14358 int res1 = 0 ;
14359 PyObject *swig_obj[1] ;
14360
14361 if (!args) SWIG_fail;
14362 swig_obj[0] = args;
14363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14364 if (!SWIG_IsOK(res1)) {
14365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14366 }
14367 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14368 {
14369 PyThreadState* __tstate = wxPyBeginAllowThreads();
14370 result = (arg1)->GetMimeType();
14371 wxPyEndAllowThreads(__tstate);
14372 if (PyErr_Occurred()) SWIG_fail;
14373 }
14374 {
14375#if wxUSE_UNICODE
14376 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14377#else
14378 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14379#endif
14380 }
14381 return resultobj;
14382fail:
14383 return NULL;
14384}
14385
14386
14387SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14388 PyObject *resultobj = 0;
14389 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14390 wxString *arg2 = 0 ;
14391 bool result;
14392 void *argp1 = 0 ;
14393 int res1 = 0 ;
14394 bool temp2 = false ;
14395 PyObject * obj0 = 0 ;
14396 PyObject * obj1 = 0 ;
14397 char * kwnames[] = {
14398 (char *) "self",(char *) "name", NULL
14399 };
14400
14401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14403 if (!SWIG_IsOK(res1)) {
14404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14405 }
14406 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14407 {
14408 arg2 = wxString_in_helper(obj1);
14409 if (arg2 == NULL) SWIG_fail;
14410 temp2 = true;
14411 }
14412 {
14413 PyThreadState* __tstate = wxPyBeginAllowThreads();
14414 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14415 wxPyEndAllowThreads(__tstate);
14416 if (PyErr_Occurred()) SWIG_fail;
14417 }
14418 {
14419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14420 }
14421 {
14422 if (temp2)
14423 delete arg2;
14424 }
14425 return resultobj;
14426fail:
14427 {
14428 if (temp2)
14429 delete arg2;
14430 }
14431 return NULL;
d55e5bfc
RD
14432}
14433
14434
b02396e8
RD
14435SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14436 PyObject *resultobj = 0;
14437 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14438 wxInputStream *arg2 = 0 ;
14439 bool result;
14440 void *argp1 = 0 ;
14441 int res1 = 0 ;
14442 wxPyInputStream *temp2 ;
14443 bool created2 ;
14444 PyObject * obj0 = 0 ;
14445 PyObject * obj1 = 0 ;
14446 char * kwnames[] = {
14447 (char *) "self",(char *) "stream", NULL
14448 };
14449
14450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14452 if (!SWIG_IsOK(res1)) {
14453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14454 }
14455 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14456 {
14457 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14458 arg2 = temp2->m_wxis;
14459 created2 = false;
14460 } else {
14461 PyErr_Clear(); // clear the failure of the wxPyConvert above
14462 arg2 = wxPyCBInputStream_create(obj1, false);
14463 if (arg2 == NULL) {
14464 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14465 SWIG_fail;
14466 }
14467 created2 = true;
14468 }
14469 }
14470 {
14471 PyThreadState* __tstate = wxPyBeginAllowThreads();
14472 result = (bool)(arg1)->CanRead(*arg2);
14473 wxPyEndAllowThreads(__tstate);
14474 if (PyErr_Occurred()) SWIG_fail;
14475 }
14476 {
14477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14478 }
14479 {
14480 if (created2) delete arg2;
14481 }
14482 return resultobj;
14483fail:
14484 {
14485 if (created2) delete arg2;
14486 }
14487 return NULL;
14488}
14489
14490
1bd55598
RD
14491SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14492 PyObject *resultobj = 0;
14493 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14494 wxString *arg2 = 0 ;
14495 void *argp1 = 0 ;
14496 int res1 = 0 ;
14497 bool temp2 = false ;
14498 PyObject * obj0 = 0 ;
14499 PyObject * obj1 = 0 ;
14500 char * kwnames[] = {
14501 (char *) "self",(char *) "name", NULL
14502 };
14503
14504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14506 if (!SWIG_IsOK(res1)) {
14507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14508 }
14509 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14510 {
14511 arg2 = wxString_in_helper(obj1);
14512 if (arg2 == NULL) SWIG_fail;
14513 temp2 = true;
14514 }
14515 {
14516 PyThreadState* __tstate = wxPyBeginAllowThreads();
14517 (arg1)->SetName((wxString const &)*arg2);
14518 wxPyEndAllowThreads(__tstate);
14519 if (PyErr_Occurred()) SWIG_fail;
14520 }
14521 resultobj = SWIG_Py_Void();
14522 {
14523 if (temp2)
14524 delete arg2;
14525 }
14526 return resultobj;
14527fail:
14528 {
14529 if (temp2)
14530 delete arg2;
14531 }
14532 return NULL;
d55e5bfc
RD
14533}
14534
14535
1bd55598
RD
14536SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14537 PyObject *resultobj = 0;
14538 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14539 wxString *arg2 = 0 ;
14540 void *argp1 = 0 ;
14541 int res1 = 0 ;
14542 bool temp2 = false ;
14543 PyObject * obj0 = 0 ;
14544 PyObject * obj1 = 0 ;
14545 char * kwnames[] = {
14546 (char *) "self",(char *) "extension", NULL
14547 };
14548
14549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14551 if (!SWIG_IsOK(res1)) {
14552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14553 }
14554 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14555 {
14556 arg2 = wxString_in_helper(obj1);
14557 if (arg2 == NULL) SWIG_fail;
14558 temp2 = true;
14559 }
14560 {
14561 PyThreadState* __tstate = wxPyBeginAllowThreads();
14562 (arg1)->SetExtension((wxString const &)*arg2);
14563 wxPyEndAllowThreads(__tstate);
14564 if (PyErr_Occurred()) SWIG_fail;
14565 }
14566 resultobj = SWIG_Py_Void();
14567 {
14568 if (temp2)
14569 delete arg2;
14570 }
14571 return resultobj;
14572fail:
14573 {
14574 if (temp2)
14575 delete arg2;
14576 }
14577 return NULL;
14578}
14579
14580
14581SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14582 PyObject *resultobj = 0;
14583 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14584 long arg2 ;
14585 void *argp1 = 0 ;
14586 int res1 = 0 ;
14587 long val2 ;
14588 int ecode2 = 0 ;
14589 PyObject * obj0 = 0 ;
14590 PyObject * obj1 = 0 ;
14591 char * kwnames[] = {
14592 (char *) "self",(char *) "type", NULL
14593 };
14594
14595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14597 if (!SWIG_IsOK(res1)) {
14598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14599 }
14600 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14601 ecode2 = SWIG_AsVal_long(obj1, &val2);
14602 if (!SWIG_IsOK(ecode2)) {
14603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14604 }
14605 arg2 = static_cast< long >(val2);
14606 {
14607 PyThreadState* __tstate = wxPyBeginAllowThreads();
14608 (arg1)->SetType(arg2);
14609 wxPyEndAllowThreads(__tstate);
14610 if (PyErr_Occurred()) SWIG_fail;
14611 }
14612 resultobj = SWIG_Py_Void();
14613 return resultobj;
14614fail:
14615 return NULL;
14616}
14617
14618
14619SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14620 PyObject *resultobj = 0;
14621 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14622 wxString *arg2 = 0 ;
14623 void *argp1 = 0 ;
14624 int res1 = 0 ;
14625 bool temp2 = false ;
14626 PyObject * obj0 = 0 ;
14627 PyObject * obj1 = 0 ;
14628 char * kwnames[] = {
14629 (char *) "self",(char *) "mimetype", NULL
14630 };
14631
14632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14634 if (!SWIG_IsOK(res1)) {
14635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14636 }
14637 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14638 {
14639 arg2 = wxString_in_helper(obj1);
14640 if (arg2 == NULL) SWIG_fail;
14641 temp2 = true;
14642 }
14643 {
14644 PyThreadState* __tstate = wxPyBeginAllowThreads();
14645 (arg1)->SetMimeType((wxString const &)*arg2);
14646 wxPyEndAllowThreads(__tstate);
14647 if (PyErr_Occurred()) SWIG_fail;
14648 }
14649 resultobj = SWIG_Py_Void();
14650 {
14651 if (temp2)
14652 delete arg2;
14653 }
14654 return resultobj;
14655fail:
14656 {
14657 if (temp2)
14658 delete arg2;
14659 }
14660 return NULL;
d55e5bfc
RD
14661}
14662
14663
1bd55598
RD
14664SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14665 PyObject *obj;
14666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14667 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14668 return SWIG_Py_Void();
d55e5bfc
RD
14669}
14670
1bd55598
RD
14671SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14672 PyObject *resultobj = 0;
14673 wxPyImageHandler *result = 0 ;
14674
14675 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14676 {
14677 PyThreadState* __tstate = wxPyBeginAllowThreads();
14678 result = (wxPyImageHandler *)new wxPyImageHandler();
14679 wxPyEndAllowThreads(__tstate);
14680 if (PyErr_Occurred()) SWIG_fail;
14681 }
14682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14683 return resultobj;
14684fail:
14685 return NULL;
14686}
14687
14688
14689SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14690 PyObject *resultobj = 0;
14691 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14692 PyObject *arg2 = (PyObject *) 0 ;
14693 void *argp1 = 0 ;
14694 int res1 = 0 ;
14695 PyObject * obj0 = 0 ;
14696 PyObject * obj1 = 0 ;
14697 char * kwnames[] = {
14698 (char *) "self",(char *) "self", NULL
14699 };
14700
14701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14703 if (!SWIG_IsOK(res1)) {
14704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14705 }
14706 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14707 arg2 = obj1;
14708 {
14709 PyThreadState* __tstate = wxPyBeginAllowThreads();
14710 (arg1)->_SetSelf(arg2);
14711 wxPyEndAllowThreads(__tstate);
14712 if (PyErr_Occurred()) SWIG_fail;
14713 }
14714 resultobj = SWIG_Py_Void();
14715 return resultobj;
14716fail:
14717 return NULL;
d55e5bfc
RD
14718}
14719
14720
1bd55598
RD
14721SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14722 PyObject *obj;
14723 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14724 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14725 return SWIG_Py_Void();
d55e5bfc
RD
14726}
14727
1bd55598
RD
14728SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14729 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
14730}
14731
1bd55598
RD
14732SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14733 PyObject *resultobj = 0;
14734 wxImageHistogram *result = 0 ;
14735
14736 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14737 {
14738 PyThreadState* __tstate = wxPyBeginAllowThreads();
14739 result = (wxImageHistogram *)new wxImageHistogram();
14740 wxPyEndAllowThreads(__tstate);
14741 if (PyErr_Occurred()) SWIG_fail;
14742 }
14743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14744 return resultobj;
14745fail:
14746 return NULL;
14747}
14748
14749
14750SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14751 PyObject *resultobj = 0;
14752 byte arg1 ;
14753 byte arg2 ;
14754 byte arg3 ;
14755 unsigned long result;
14756 unsigned char val1 ;
14757 int ecode1 = 0 ;
14758 unsigned char val2 ;
14759 int ecode2 = 0 ;
14760 unsigned char val3 ;
14761 int ecode3 = 0 ;
14762 PyObject * obj0 = 0 ;
14763 PyObject * obj1 = 0 ;
14764 PyObject * obj2 = 0 ;
14765 char * kwnames[] = {
14766 (char *) "r",(char *) "g",(char *) "b", NULL
14767 };
14768
14769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14770 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14771 if (!SWIG_IsOK(ecode1)) {
14772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14773 }
14774 arg1 = static_cast< byte >(val1);
14775 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14776 if (!SWIG_IsOK(ecode2)) {
14777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14778 }
14779 arg2 = static_cast< byte >(val2);
14780 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14781 if (!SWIG_IsOK(ecode3)) {
14782 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14783 }
14784 arg3 = static_cast< byte >(val3);
14785 {
14786 PyThreadState* __tstate = wxPyBeginAllowThreads();
14787 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14788 wxPyEndAllowThreads(__tstate);
14789 if (PyErr_Occurred()) SWIG_fail;
14790 }
14791 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14792 return resultobj;
14793fail:
14794 return NULL;
14795}
14796
14797
14798SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14799 PyObject *resultobj = 0;
14800 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14801 byte *arg2 = (byte *) 0 ;
14802 byte *arg3 = (byte *) 0 ;
14803 byte *arg4 = (byte *) 0 ;
14804 byte arg5 = (byte) 1 ;
14805 byte arg6 = (byte) 0 ;
14806 byte arg7 = (byte) 0 ;
14807 bool result;
14808 void *argp1 = 0 ;
14809 int res1 = 0 ;
14810 byte temp2 ;
14811 int res2 = SWIG_TMPOBJ ;
14812 byte temp3 ;
14813 int res3 = SWIG_TMPOBJ ;
14814 byte temp4 ;
14815 int res4 = SWIG_TMPOBJ ;
14816 unsigned char val5 ;
14817 int ecode5 = 0 ;
14818 unsigned char val6 ;
14819 int ecode6 = 0 ;
14820 unsigned char val7 ;
14821 int ecode7 = 0 ;
14822 PyObject * obj0 = 0 ;
14823 PyObject * obj1 = 0 ;
14824 PyObject * obj2 = 0 ;
14825 PyObject * obj3 = 0 ;
14826 char * kwnames[] = {
14827 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14828 };
14829
14830 arg2 = &temp2;
14831 arg3 = &temp3;
14832 arg4 = &temp4;
14833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14835 if (!SWIG_IsOK(res1)) {
14836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14837 }
14838 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14839 if (obj1) {
14840 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14841 if (!SWIG_IsOK(ecode5)) {
14842 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14843 }
14844 arg5 = static_cast< byte >(val5);
14845 }
14846 if (obj2) {
14847 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14848 if (!SWIG_IsOK(ecode6)) {
14849 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14850 }
14851 arg6 = static_cast< byte >(val6);
14852 }
14853 if (obj3) {
14854 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14855 if (!SWIG_IsOK(ecode7)) {
14856 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14857 }
14858 arg7 = static_cast< byte >(val7);
14859 }
14860 {
14861 PyThreadState* __tstate = wxPyBeginAllowThreads();
14862 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14863 wxPyEndAllowThreads(__tstate);
14864 if (PyErr_Occurred()) SWIG_fail;
14865 }
14866 {
14867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14868 }
14869 if (SWIG_IsTmpObj(res2)) {
14870 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14871 } else {
14872 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14873 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14874 }
14875 if (SWIG_IsTmpObj(res3)) {
14876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14877 } else {
14878 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14879 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14880 }
14881 if (SWIG_IsTmpObj(res4)) {
14882 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14883 } else {
14884 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14885 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14886 }
14887 return resultobj;
14888fail:
14889 return NULL;
14890}
14891
14892
14893SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14894 PyObject *resultobj = 0;
14895 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14896 unsigned long arg2 ;
14897 unsigned long result;
14898 void *argp1 = 0 ;
14899 int res1 = 0 ;
14900 unsigned long val2 ;
14901 int ecode2 = 0 ;
14902 PyObject * obj0 = 0 ;
14903 PyObject * obj1 = 0 ;
14904 char * kwnames[] = {
14905 (char *) "self",(char *) "key", NULL
14906 };
14907
14908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14910 if (!SWIG_IsOK(res1)) {
14911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14912 }
14913 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14914 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14915 if (!SWIG_IsOK(ecode2)) {
14916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14917 }
14918 arg2 = static_cast< unsigned long >(val2);
14919 {
14920 PyThreadState* __tstate = wxPyBeginAllowThreads();
14921 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14922 wxPyEndAllowThreads(__tstate);
14923 if (PyErr_Occurred()) SWIG_fail;
14924 }
14925 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14926 return resultobj;
14927fail:
14928 return NULL;
14929}
14930
14931
14932SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14933 PyObject *resultobj = 0;
14934 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14935 byte arg2 ;
14936 byte arg3 ;
14937 byte arg4 ;
14938 unsigned long result;
14939 void *argp1 = 0 ;
14940 int res1 = 0 ;
14941 unsigned char val2 ;
14942 int ecode2 = 0 ;
14943 unsigned char val3 ;
14944 int ecode3 = 0 ;
14945 unsigned char val4 ;
14946 int ecode4 = 0 ;
14947 PyObject * obj0 = 0 ;
14948 PyObject * obj1 = 0 ;
14949 PyObject * obj2 = 0 ;
14950 PyObject * obj3 = 0 ;
14951 char * kwnames[] = {
14952 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14953 };
14954
14955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14957 if (!SWIG_IsOK(res1)) {
14958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14959 }
14960 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14961 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14962 if (!SWIG_IsOK(ecode2)) {
14963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
14964 }
14965 arg2 = static_cast< byte >(val2);
14966 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14967 if (!SWIG_IsOK(ecode3)) {
14968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
14969 }
14970 arg3 = static_cast< byte >(val3);
14971 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14972 if (!SWIG_IsOK(ecode4)) {
14973 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
14974 }
14975 arg4 = static_cast< byte >(val4);
14976 {
14977 PyThreadState* __tstate = wxPyBeginAllowThreads();
14978 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
14979 wxPyEndAllowThreads(__tstate);
14980 if (PyErr_Occurred()) SWIG_fail;
14981 }
14982 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14983 return resultobj;
14984fail:
14985 return NULL;
14986}
14987
14988
14989SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14990 PyObject *resultobj = 0;
14991 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14992 wxColour *arg2 = 0 ;
14993 unsigned long result;
14994 void *argp1 = 0 ;
14995 int res1 = 0 ;
14996 wxColour temp2 ;
14997 PyObject * obj0 = 0 ;
14998 PyObject * obj1 = 0 ;
14999 char * kwnames[] = {
15000 (char *) "self",(char *) "colour", NULL
15001 };
15002
15003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15005 if (!SWIG_IsOK(res1)) {
15006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15007 }
15008 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15009 {
15010 arg2 = &temp2;
15011 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15012 }
15013 {
15014 PyThreadState* __tstate = wxPyBeginAllowThreads();
15015 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15016 wxPyEndAllowThreads(__tstate);
15017 if (PyErr_Occurred()) SWIG_fail;
15018 }
15019 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15020 return resultobj;
15021fail:
15022 return NULL;
15023}
15024
15025
15026SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15027 PyObject *obj;
15028 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15029 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15030 return SWIG_Py_Void();
15031}
15032
15033SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15034 return SWIG_Python_InitShadowInstance(args);
15035}
15036
15037SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15038 PyObject *resultobj = 0;
15039 byte arg1 = (byte) 0 ;
15040 byte arg2 = (byte) 0 ;
15041 byte arg3 = (byte) 0 ;
15042 wxImage_RGBValue *result = 0 ;
15043 unsigned char val1 ;
15044 int ecode1 = 0 ;
15045 unsigned char val2 ;
15046 int ecode2 = 0 ;
15047 unsigned char val3 ;
15048 int ecode3 = 0 ;
15049 PyObject * obj0 = 0 ;
15050 PyObject * obj1 = 0 ;
15051 PyObject * obj2 = 0 ;
15052 char * kwnames[] = {
15053 (char *) "r",(char *) "g",(char *) "b", NULL
15054 };
15055
15056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15057 if (obj0) {
15058 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15059 if (!SWIG_IsOK(ecode1)) {
15060 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15061 }
15062 arg1 = static_cast< byte >(val1);
15063 }
15064 if (obj1) {
15065 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15066 if (!SWIG_IsOK(ecode2)) {
15067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15068 }
15069 arg2 = static_cast< byte >(val2);
15070 }
15071 if (obj2) {
15072 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15073 if (!SWIG_IsOK(ecode3)) {
15074 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15075 }
15076 arg3 = static_cast< byte >(val3);
15077 }
15078 {
15079 PyThreadState* __tstate = wxPyBeginAllowThreads();
15080 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15081 wxPyEndAllowThreads(__tstate);
15082 if (PyErr_Occurred()) SWIG_fail;
15083 }
15084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15085 return resultobj;
15086fail:
15087 return NULL;
15088}
15089
15090
15091SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15092 PyObject *resultobj = 0;
15093 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15094 byte arg2 ;
15095 void *argp1 = 0 ;
15096 int res1 = 0 ;
15097 unsigned char val2 ;
15098 int ecode2 = 0 ;
15099 PyObject *swig_obj[2] ;
15100
15101 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15103 if (!SWIG_IsOK(res1)) {
15104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15105 }
15106 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15107 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15108 if (!SWIG_IsOK(ecode2)) {
15109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15110 }
15111 arg2 = static_cast< byte >(val2);
15112 if (arg1) (arg1)->red = arg2;
15113
15114 resultobj = SWIG_Py_Void();
15115 return resultobj;
15116fail:
15117 return NULL;
d55e5bfc
RD
15118}
15119
15120
1bd55598
RD
15121SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15122 PyObject *resultobj = 0;
15123 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15124 byte result;
15125 void *argp1 = 0 ;
15126 int res1 = 0 ;
15127 PyObject *swig_obj[1] ;
15128
15129 if (!args) SWIG_fail;
15130 swig_obj[0] = args;
15131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15132 if (!SWIG_IsOK(res1)) {
15133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15134 }
15135 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15136 result = (byte) ((arg1)->red);
15137 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15138 return resultobj;
15139fail:
15140 return NULL;
15141}
15142
15143
15144SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15145 PyObject *resultobj = 0;
15146 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15147 byte arg2 ;
15148 void *argp1 = 0 ;
15149 int res1 = 0 ;
15150 unsigned char val2 ;
15151 int ecode2 = 0 ;
15152 PyObject *swig_obj[2] ;
15153
15154 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15156 if (!SWIG_IsOK(res1)) {
15157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15158 }
15159 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15160 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15161 if (!SWIG_IsOK(ecode2)) {
15162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15163 }
15164 arg2 = static_cast< byte >(val2);
15165 if (arg1) (arg1)->green = arg2;
15166
15167 resultobj = SWIG_Py_Void();
15168 return resultobj;
15169fail:
15170 return NULL;
d55e5bfc
RD
15171}
15172
15173
1bd55598
RD
15174SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15175 PyObject *resultobj = 0;
15176 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15177 byte result;
15178 void *argp1 = 0 ;
15179 int res1 = 0 ;
15180 PyObject *swig_obj[1] ;
15181
15182 if (!args) SWIG_fail;
15183 swig_obj[0] = args;
15184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15185 if (!SWIG_IsOK(res1)) {
15186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15187 }
15188 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15189 result = (byte) ((arg1)->green);
15190 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15191 return resultobj;
15192fail:
15193 return NULL;
15194}
15195
15196
15197SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15198 PyObject *resultobj = 0;
15199 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15200 byte arg2 ;
15201 void *argp1 = 0 ;
15202 int res1 = 0 ;
15203 unsigned char val2 ;
15204 int ecode2 = 0 ;
15205 PyObject *swig_obj[2] ;
15206
15207 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15209 if (!SWIG_IsOK(res1)) {
15210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15211 }
15212 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15213 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15214 if (!SWIG_IsOK(ecode2)) {
15215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15216 }
15217 arg2 = static_cast< byte >(val2);
15218 if (arg1) (arg1)->blue = arg2;
15219
15220 resultobj = SWIG_Py_Void();
15221 return resultobj;
15222fail:
15223 return NULL;
8fb0e70a
RD
15224}
15225
15226
1bd55598
RD
15227SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15228 PyObject *resultobj = 0;
15229 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15230 byte result;
15231 void *argp1 = 0 ;
15232 int res1 = 0 ;
15233 PyObject *swig_obj[1] ;
15234
15235 if (!args) SWIG_fail;
15236 swig_obj[0] = args;
15237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15238 if (!SWIG_IsOK(res1)) {
15239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15240 }
15241 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15242 result = (byte) ((arg1)->blue);
15243 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15244 return resultobj;
15245fail:
15246 return NULL;
15247}
15248
15249
15250SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15251 PyObject *obj;
15252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15253 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15254 return SWIG_Py_Void();
15255}
15256
15257SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15258 return SWIG_Python_InitShadowInstance(args);
15259}
15260
15261SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15262 PyObject *resultobj = 0;
15263 double arg1 = (double) 0.0 ;
15264 double arg2 = (double) 0.0 ;
15265 double arg3 = (double) 0.0 ;
15266 wxImage_HSVValue *result = 0 ;
15267 double val1 ;
15268 int ecode1 = 0 ;
15269 double val2 ;
15270 int ecode2 = 0 ;
15271 double val3 ;
15272 int ecode3 = 0 ;
15273 PyObject * obj0 = 0 ;
15274 PyObject * obj1 = 0 ;
15275 PyObject * obj2 = 0 ;
15276 char * kwnames[] = {
15277 (char *) "h",(char *) "s",(char *) "v", NULL
15278 };
15279
15280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15281 if (obj0) {
15282 ecode1 = SWIG_AsVal_double(obj0, &val1);
15283 if (!SWIG_IsOK(ecode1)) {
15284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15285 }
15286 arg1 = static_cast< double >(val1);
15287 }
15288 if (obj1) {
15289 ecode2 = SWIG_AsVal_double(obj1, &val2);
15290 if (!SWIG_IsOK(ecode2)) {
15291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15292 }
15293 arg2 = static_cast< double >(val2);
15294 }
15295 if (obj2) {
15296 ecode3 = SWIG_AsVal_double(obj2, &val3);
15297 if (!SWIG_IsOK(ecode3)) {
15298 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15299 }
15300 arg3 = static_cast< double >(val3);
15301 }
15302 {
15303 PyThreadState* __tstate = wxPyBeginAllowThreads();
15304 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15305 wxPyEndAllowThreads(__tstate);
15306 if (PyErr_Occurred()) SWIG_fail;
15307 }
15308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15309 return resultobj;
15310fail:
15311 return NULL;
15312}
15313
15314
15315SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15316 PyObject *resultobj = 0;
15317 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15318 double arg2 ;
15319 void *argp1 = 0 ;
15320 int res1 = 0 ;
15321 double val2 ;
15322 int ecode2 = 0 ;
15323 PyObject *swig_obj[2] ;
15324
15325 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15327 if (!SWIG_IsOK(res1)) {
15328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15329 }
15330 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15331 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15332 if (!SWIG_IsOK(ecode2)) {
15333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15334 }
15335 arg2 = static_cast< double >(val2);
15336 if (arg1) (arg1)->hue = arg2;
15337
15338 resultobj = SWIG_Py_Void();
15339 return resultobj;
15340fail:
15341 return NULL;
d55e5bfc
RD
15342}
15343
15344
1bd55598
RD
15345SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15346 PyObject *resultobj = 0;
15347 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15348 double result;
15349 void *argp1 = 0 ;
15350 int res1 = 0 ;
15351 PyObject *swig_obj[1] ;
15352
15353 if (!args) SWIG_fail;
15354 swig_obj[0] = args;
15355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15356 if (!SWIG_IsOK(res1)) {
15357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15358 }
15359 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15360 result = (double) ((arg1)->hue);
15361 resultobj = SWIG_From_double(static_cast< double >(result));
15362 return resultobj;
15363fail:
15364 return NULL;
15365}
15366
15367
15368SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15369 PyObject *resultobj = 0;
15370 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15371 double arg2 ;
15372 void *argp1 = 0 ;
15373 int res1 = 0 ;
15374 double val2 ;
15375 int ecode2 = 0 ;
15376 PyObject *swig_obj[2] ;
15377
15378 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15380 if (!SWIG_IsOK(res1)) {
15381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15382 }
15383 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15384 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15385 if (!SWIG_IsOK(ecode2)) {
15386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15387 }
15388 arg2 = static_cast< double >(val2);
15389 if (arg1) (arg1)->saturation = arg2;
15390
15391 resultobj = SWIG_Py_Void();
15392 return resultobj;
15393fail:
15394 return NULL;
d55e5bfc
RD
15395}
15396
15397
1bd55598
RD
15398SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15399 PyObject *resultobj = 0;
15400 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15401 double result;
15402 void *argp1 = 0 ;
15403 int res1 = 0 ;
15404 PyObject *swig_obj[1] ;
15405
15406 if (!args) SWIG_fail;
15407 swig_obj[0] = args;
15408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15409 if (!SWIG_IsOK(res1)) {
15410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15411 }
15412 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15413 result = (double) ((arg1)->saturation);
15414 resultobj = SWIG_From_double(static_cast< double >(result));
15415 return resultobj;
15416fail:
15417 return NULL;
15418}
15419
15420
15421SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15422 PyObject *resultobj = 0;
15423 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15424 double arg2 ;
15425 void *argp1 = 0 ;
15426 int res1 = 0 ;
15427 double val2 ;
15428 int ecode2 = 0 ;
15429 PyObject *swig_obj[2] ;
15430
15431 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15433 if (!SWIG_IsOK(res1)) {
15434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15435 }
15436 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15437 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15438 if (!SWIG_IsOK(ecode2)) {
15439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15440 }
15441 arg2 = static_cast< double >(val2);
15442 if (arg1) (arg1)->value = arg2;
15443
15444 resultobj = SWIG_Py_Void();
15445 return resultobj;
15446fail:
15447 return NULL;
d55e5bfc
RD
15448}
15449
15450
1bd55598
RD
15451SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15452 PyObject *resultobj = 0;
15453 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15454 double result;
15455 void *argp1 = 0 ;
15456 int res1 = 0 ;
15457 PyObject *swig_obj[1] ;
15458
15459 if (!args) SWIG_fail;
15460 swig_obj[0] = args;
15461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15462 if (!SWIG_IsOK(res1)) {
15463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15464 }
15465 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15466 result = (double) ((arg1)->value);
15467 resultobj = SWIG_From_double(static_cast< double >(result));
15468 return resultobj;
15469fail:
15470 return NULL;
15471}
15472
15473
15474SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15475 PyObject *obj;
15476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15477 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15478 return SWIG_Py_Void();
15479}
15480
15481SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15482 return SWIG_Python_InitShadowInstance(args);
15483}
15484
15485SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15486 PyObject *resultobj = 0;
15487 wxString *arg1 = 0 ;
15488 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15489 int arg3 = (int) -1 ;
15490 wxImage *result = 0 ;
15491 bool temp1 = false ;
15492 long val2 ;
15493 int ecode2 = 0 ;
15494 int val3 ;
15495 int ecode3 = 0 ;
15496 PyObject * obj0 = 0 ;
15497 PyObject * obj1 = 0 ;
15498 PyObject * obj2 = 0 ;
15499 char * kwnames[] = {
15500 (char *) "name",(char *) "type",(char *) "index", NULL
15501 };
15502
15503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15504 {
15505 arg1 = wxString_in_helper(obj0);
15506 if (arg1 == NULL) SWIG_fail;
15507 temp1 = true;
15508 }
15509 if (obj1) {
15510 ecode2 = SWIG_AsVal_long(obj1, &val2);
15511 if (!SWIG_IsOK(ecode2)) {
15512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15513 }
15514 arg2 = static_cast< long >(val2);
15515 }
15516 if (obj2) {
15517 ecode3 = SWIG_AsVal_int(obj2, &val3);
15518 if (!SWIG_IsOK(ecode3)) {
15519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15520 }
15521 arg3 = static_cast< int >(val3);
15522 }
15523 {
15524 PyThreadState* __tstate = wxPyBeginAllowThreads();
15525 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15526 wxPyEndAllowThreads(__tstate);
15527 if (PyErr_Occurred()) SWIG_fail;
15528 }
15529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15530 {
15531 if (temp1)
15532 delete arg1;
15533 }
15534 return resultobj;
15535fail:
15536 {
15537 if (temp1)
15538 delete arg1;
15539 }
15540 return NULL;
d55e5bfc
RD
15541}
15542
15543
1bd55598
RD
15544SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15545 PyObject *resultobj = 0;
15546 wxImage *arg1 = (wxImage *) 0 ;
15547 void *argp1 = 0 ;
15548 int res1 = 0 ;
15549 PyObject *swig_obj[1] ;
15550
15551 if (!args) SWIG_fail;
15552 swig_obj[0] = args;
15553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15554 if (!SWIG_IsOK(res1)) {
15555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15556 }
15557 arg1 = reinterpret_cast< wxImage * >(argp1);
15558 {
15559 PyThreadState* __tstate = wxPyBeginAllowThreads();
15560 delete arg1;
d55e5bfc 15561
1bd55598
RD
15562 wxPyEndAllowThreads(__tstate);
15563 if (PyErr_Occurred()) SWIG_fail;
15564 }
15565 resultobj = SWIG_Py_Void();
15566 return resultobj;
15567fail:
15568 return NULL;
15569}
15570
15571
15572SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15573 PyObject *resultobj = 0;
15574 wxString *arg1 = 0 ;
15575 wxString *arg2 = 0 ;
15576 int arg3 = (int) -1 ;
15577 wxImage *result = 0 ;
15578 bool temp1 = false ;
15579 bool temp2 = false ;
15580 int val3 ;
15581 int ecode3 = 0 ;
15582 PyObject * obj0 = 0 ;
15583 PyObject * obj1 = 0 ;
15584 PyObject * obj2 = 0 ;
15585 char * kwnames[] = {
15586 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15587 };
15588
15589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15590 {
15591 arg1 = wxString_in_helper(obj0);
15592 if (arg1 == NULL) SWIG_fail;
15593 temp1 = true;
15594 }
15595 {
15596 arg2 = wxString_in_helper(obj1);
15597 if (arg2 == NULL) SWIG_fail;
15598 temp2 = true;
15599 }
15600 if (obj2) {
15601 ecode3 = SWIG_AsVal_int(obj2, &val3);
15602 if (!SWIG_IsOK(ecode3)) {
15603 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15604 }
15605 arg3 = static_cast< int >(val3);
15606 }
15607 {
15608 PyThreadState* __tstate = wxPyBeginAllowThreads();
15609 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15610 wxPyEndAllowThreads(__tstate);
15611 if (PyErr_Occurred()) SWIG_fail;
15612 }
15613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15614 {
15615 if (temp1)
15616 delete arg1;
15617 }
15618 {
15619 if (temp2)
15620 delete arg2;
15621 }
15622 return resultobj;
15623fail:
15624 {
15625 if (temp1)
15626 delete arg1;
15627 }
15628 {
15629 if (temp2)
15630 delete arg2;
15631 }
15632 return NULL;
15633}
15634
15635
15636SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15637 PyObject *resultobj = 0;
15638 wxInputStream *arg1 = 0 ;
15639 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15640 int arg3 = (int) -1 ;
15641 wxImage *result = 0 ;
15642 wxPyInputStream *temp1 ;
15643 bool created1 ;
15644 long val2 ;
15645 int ecode2 = 0 ;
15646 int val3 ;
15647 int ecode3 = 0 ;
15648 PyObject * obj0 = 0 ;
15649 PyObject * obj1 = 0 ;
15650 PyObject * obj2 = 0 ;
15651 char * kwnames[] = {
15652 (char *) "stream",(char *) "type",(char *) "index", NULL
15653 };
15654
15655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15656 {
15657 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15658 arg1 = temp1->m_wxis;
15659 created1 = false;
15660 } else {
15661 PyErr_Clear(); // clear the failure of the wxPyConvert above
15662 arg1 = wxPyCBInputStream_create(obj0, false);
15663 if (arg1 == NULL) {
15664 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15665 SWIG_fail;
15666 }
15667 created1 = true;
d55e5bfc 15668 }
1bd55598
RD
15669 }
15670 if (obj1) {
15671 ecode2 = SWIG_AsVal_long(obj1, &val2);
15672 if (!SWIG_IsOK(ecode2)) {
15673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15674 }
15675 arg2 = static_cast< long >(val2);
15676 }
15677 if (obj2) {
15678 ecode3 = SWIG_AsVal_int(obj2, &val3);
15679 if (!SWIG_IsOK(ecode3)) {
15680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15681 }
15682 arg3 = static_cast< int >(val3);
15683 }
15684 {
15685 PyThreadState* __tstate = wxPyBeginAllowThreads();
15686 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15687 wxPyEndAllowThreads(__tstate);
15688 if (PyErr_Occurred()) SWIG_fail;
15689 }
15690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15691 {
15692 if (created1) delete arg1;
15693 }
15694 return resultobj;
15695fail:
15696 {
15697 if (created1) delete arg1;
15698 }
15699 return NULL;
15700}
15701
15702
15703SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15704 PyObject *resultobj = 0;
15705 wxInputStream *arg1 = 0 ;
15706 wxString *arg2 = 0 ;
15707 int arg3 = (int) -1 ;
15708 wxImage *result = 0 ;
15709 wxPyInputStream *temp1 ;
15710 bool created1 ;
15711 bool temp2 = false ;
15712 int val3 ;
15713 int ecode3 = 0 ;
15714 PyObject * obj0 = 0 ;
15715 PyObject * obj1 = 0 ;
15716 PyObject * obj2 = 0 ;
15717 char * kwnames[] = {
15718 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15719 };
15720
15721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15722 {
15723 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15724 arg1 = temp1->m_wxis;
15725 created1 = false;
15726 } else {
15727 PyErr_Clear(); // clear the failure of the wxPyConvert above
15728 arg1 = wxPyCBInputStream_create(obj0, false);
15729 if (arg1 == NULL) {
15730 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15731 SWIG_fail;
15732 }
15733 created1 = true;
d55e5bfc 15734 }
1bd55598
RD
15735 }
15736 {
15737 arg2 = wxString_in_helper(obj1);
15738 if (arg2 == NULL) SWIG_fail;
15739 temp2 = true;
15740 }
15741 if (obj2) {
15742 ecode3 = SWIG_AsVal_int(obj2, &val3);
15743 if (!SWIG_IsOK(ecode3)) {
15744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15745 }
15746 arg3 = static_cast< int >(val3);
15747 }
15748 {
15749 PyThreadState* __tstate = wxPyBeginAllowThreads();
15750 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15751 wxPyEndAllowThreads(__tstate);
15752 if (PyErr_Occurred()) SWIG_fail;
15753 }
15754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15755 {
15756 if (created1) delete arg1;
15757 }
15758 {
15759 if (temp2)
15760 delete arg2;
15761 }
15762 return resultobj;
15763fail:
15764 {
15765 if (created1) delete arg1;
15766 }
15767 {
15768 if (temp2)
15769 delete arg2;
15770 }
15771 return NULL;
15772}
15773
15774
15775SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15776 PyObject *resultobj = 0;
15777 int arg1 = (int) 0 ;
15778 int arg2 = (int) 0 ;
15779 bool arg3 = (bool) true ;
15780 wxImage *result = 0 ;
15781 int val1 ;
15782 int ecode1 = 0 ;
15783 int val2 ;
15784 int ecode2 = 0 ;
15785 bool val3 ;
15786 int ecode3 = 0 ;
15787 PyObject * obj0 = 0 ;
15788 PyObject * obj1 = 0 ;
15789 PyObject * obj2 = 0 ;
15790 char * kwnames[] = {
15791 (char *) "width",(char *) "height",(char *) "clear", NULL
15792 };
15793
15794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15795 if (obj0) {
15796 ecode1 = SWIG_AsVal_int(obj0, &val1);
15797 if (!SWIG_IsOK(ecode1)) {
15798 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15799 }
15800 arg1 = static_cast< int >(val1);
15801 }
15802 if (obj1) {
15803 ecode2 = SWIG_AsVal_int(obj1, &val2);
15804 if (!SWIG_IsOK(ecode2)) {
15805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15806 }
15807 arg2 = static_cast< int >(val2);
15808 }
15809 if (obj2) {
15810 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15811 if (!SWIG_IsOK(ecode3)) {
15812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15813 }
15814 arg3 = static_cast< bool >(val3);
15815 }
15816 {
15817 PyThreadState* __tstate = wxPyBeginAllowThreads();
15818 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15819 wxPyEndAllowThreads(__tstate);
15820 if (PyErr_Occurred()) SWIG_fail;
15821 }
15822 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15823 return resultobj;
15824fail:
15825 return NULL;
15826}
15827
15828
15829SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15830 PyObject *resultobj = 0;
15831 wxBitmap *arg1 = 0 ;
15832 wxImage *result = 0 ;
15833 void *argp1 = 0 ;
15834 int res1 = 0 ;
15835 PyObject * obj0 = 0 ;
15836 char * kwnames[] = {
15837 (char *) "bitmap", NULL
15838 };
15839
15840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15841 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15842 if (!SWIG_IsOK(res1)) {
15843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15844 }
15845 if (!argp1) {
15846 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15847 }
15848 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15849 {
15850 if (!wxPyCheckForApp()) SWIG_fail;
15851 PyThreadState* __tstate = wxPyBeginAllowThreads();
15852 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15853 wxPyEndAllowThreads(__tstate);
15854 if (PyErr_Occurred()) SWIG_fail;
15855 }
15856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15857 return resultobj;
15858fail:
15859 return NULL;
15860}
15861
15862
15863SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15864 PyObject *resultobj = 0;
15865 int arg1 ;
15866 int arg2 ;
15867 buffer arg3 ;
15868 int arg4 ;
15869 wxImage *result = 0 ;
15870 int val1 ;
15871 int ecode1 = 0 ;
15872 int val2 ;
15873 int ecode2 = 0 ;
8c9c423b 15874 Py_ssize_t temp3 ;
1bd55598
RD
15875 PyObject * obj0 = 0 ;
15876 PyObject * obj1 = 0 ;
15877 PyObject * obj2 = 0 ;
15878 char * kwnames[] = {
15879 (char *) "width",(char *) "height",(char *) "data", NULL
15880 };
15881
15882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15883 ecode1 = SWIG_AsVal_int(obj0, &val1);
15884 if (!SWIG_IsOK(ecode1)) {
15885 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15886 }
15887 arg1 = static_cast< int >(val1);
15888 ecode2 = SWIG_AsVal_int(obj1, &val2);
15889 if (!SWIG_IsOK(ecode2)) {
15890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15891 }
15892 arg2 = static_cast< int >(val2);
15893 {
8c9c423b
RD
15894 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15895 arg4 = (int)temp3;
1bd55598
RD
15896 }
15897 {
15898 PyThreadState* __tstate = wxPyBeginAllowThreads();
15899 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15900 wxPyEndAllowThreads(__tstate);
15901 if (PyErr_Occurred()) SWIG_fail;
15902 }
15903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15904 return resultobj;
15905fail:
15906 return NULL;
15907}
15908
15909
15910SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15911 PyObject *resultobj = 0;
15912 int arg1 ;
15913 int arg2 ;
15914 buffer arg3 ;
15915 int arg4 ;
15916 buffer arg5 ;
15917 int arg6 ;
15918 wxImage *result = 0 ;
15919 int val1 ;
15920 int ecode1 = 0 ;
15921 int val2 ;
15922 int ecode2 = 0 ;
8c9c423b
RD
15923 Py_ssize_t temp3 ;
15924 Py_ssize_t temp5 ;
1bd55598
RD
15925 PyObject * obj0 = 0 ;
15926 PyObject * obj1 = 0 ;
15927 PyObject * obj2 = 0 ;
15928 PyObject * obj3 = 0 ;
15929 char * kwnames[] = {
15930 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15931 };
15932
15933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15934 ecode1 = SWIG_AsVal_int(obj0, &val1);
15935 if (!SWIG_IsOK(ecode1)) {
15936 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15937 }
15938 arg1 = static_cast< int >(val1);
15939 ecode2 = SWIG_AsVal_int(obj1, &val2);
15940 if (!SWIG_IsOK(ecode2)) {
15941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15942 }
15943 arg2 = static_cast< int >(val2);
15944 {
8c9c423b
RD
15945 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15946 arg4 = (int)temp3;
1bd55598
RD
15947 }
15948 {
fc46b7f3 15949 if (obj3 != Py_None) {
8c9c423b
RD
15950 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
15951 arg6 = (int)temp5;
fc46b7f3 15952 }
1bd55598
RD
15953 }
15954 {
15955 PyThreadState* __tstate = wxPyBeginAllowThreads();
15956 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
15957 wxPyEndAllowThreads(__tstate);
15958 if (PyErr_Occurred()) SWIG_fail;
15959 }
15960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15961 return resultobj;
15962fail:
15963 return NULL;
15964}
15965
15966
15967SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15968 PyObject *resultobj = 0;
15969 wxImage *arg1 = (wxImage *) 0 ;
15970 int arg2 ;
15971 int arg3 ;
15972 bool arg4 = (bool) true ;
15973 void *argp1 = 0 ;
15974 int res1 = 0 ;
15975 int val2 ;
15976 int ecode2 = 0 ;
15977 int val3 ;
15978 int ecode3 = 0 ;
15979 bool val4 ;
15980 int ecode4 = 0 ;
15981 PyObject * obj0 = 0 ;
15982 PyObject * obj1 = 0 ;
15983 PyObject * obj2 = 0 ;
15984 PyObject * obj3 = 0 ;
15985 char * kwnames[] = {
15986 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
15987 };
15988
15989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15991 if (!SWIG_IsOK(res1)) {
15992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
15993 }
15994 arg1 = reinterpret_cast< wxImage * >(argp1);
15995 ecode2 = SWIG_AsVal_int(obj1, &val2);
15996 if (!SWIG_IsOK(ecode2)) {
15997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
15998 }
15999 arg2 = static_cast< int >(val2);
16000 ecode3 = SWIG_AsVal_int(obj2, &val3);
16001 if (!SWIG_IsOK(ecode3)) {
16002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16003 }
16004 arg3 = static_cast< int >(val3);
16005 if (obj3) {
16006 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16007 if (!SWIG_IsOK(ecode4)) {
16008 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16009 }
16010 arg4 = static_cast< bool >(val4);
16011 }
16012 {
16013 PyThreadState* __tstate = wxPyBeginAllowThreads();
16014 (arg1)->Create(arg2,arg3,arg4);
16015 wxPyEndAllowThreads(__tstate);
16016 if (PyErr_Occurred()) SWIG_fail;
16017 }
16018 resultobj = SWIG_Py_Void();
16019 return resultobj;
16020fail:
16021 return NULL;
d55e5bfc
RD
16022}
16023
16024
1bd55598
RD
16025SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16026 PyObject *resultobj = 0;
16027 wxImage *arg1 = (wxImage *) 0 ;
16028 void *argp1 = 0 ;
16029 int res1 = 0 ;
16030 PyObject *swig_obj[1] ;
16031
16032 if (!args) SWIG_fail;
16033 swig_obj[0] = args;
16034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16035 if (!SWIG_IsOK(res1)) {
16036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16037 }
16038 arg1 = reinterpret_cast< wxImage * >(argp1);
16039 {
16040 PyThreadState* __tstate = wxPyBeginAllowThreads();
16041 (arg1)->Destroy();
16042 wxPyEndAllowThreads(__tstate);
16043 if (PyErr_Occurred()) SWIG_fail;
16044 }
16045 resultobj = SWIG_Py_Void();
16046 return resultobj;
16047fail:
16048 return NULL;
16049}
16050
16051
16052SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16053 PyObject *resultobj = 0;
16054 wxImage *arg1 = (wxImage *) 0 ;
16055 int arg2 ;
16056 int arg3 ;
f5263701 16057 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
1bd55598
RD
16058 SwigValueWrapper<wxImage > result;
16059 void *argp1 = 0 ;
16060 int res1 = 0 ;
16061 int val2 ;
16062 int ecode2 = 0 ;
16063 int val3 ;
16064 int ecode3 = 0 ;
f5263701
RD
16065 int val4 ;
16066 int ecode4 = 0 ;
1bd55598
RD
16067 PyObject * obj0 = 0 ;
16068 PyObject * obj1 = 0 ;
16069 PyObject * obj2 = 0 ;
f5263701 16070 PyObject * obj3 = 0 ;
1bd55598 16071 char * kwnames[] = {
f5263701 16072 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
1bd55598
RD
16073 };
16074
f5263701 16075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
1bd55598
RD
16076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16077 if (!SWIG_IsOK(res1)) {
16078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16079 }
16080 arg1 = reinterpret_cast< wxImage * >(argp1);
16081 ecode2 = SWIG_AsVal_int(obj1, &val2);
16082 if (!SWIG_IsOK(ecode2)) {
16083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16084 }
16085 arg2 = static_cast< int >(val2);
16086 ecode3 = SWIG_AsVal_int(obj2, &val3);
16087 if (!SWIG_IsOK(ecode3)) {
16088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16089 }
16090 arg3 = static_cast< int >(val3);
f5263701
RD
16091 if (obj3) {
16092 ecode4 = SWIG_AsVal_int(obj3, &val4);
16093 if (!SWIG_IsOK(ecode4)) {
16094 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16095 }
16096 arg4 = static_cast< int >(val4);
16097 }
1bd55598
RD
16098 {
16099 PyThreadState* __tstate = wxPyBeginAllowThreads();
f5263701
RD
16100 result = (arg1)->Scale(arg2,arg3,arg4);
16101 wxPyEndAllowThreads(__tstate);
16102 if (PyErr_Occurred()) SWIG_fail;
16103 }
16104 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16105 return resultobj;
16106fail:
16107 return NULL;
16108}
16109
16110
16111SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16112 PyObject *resultobj = 0;
16113 wxImage *arg1 = (wxImage *) 0 ;
16114 int arg2 ;
16115 int arg3 ;
16116 SwigValueWrapper<wxImage > result;
16117 void *argp1 = 0 ;
16118 int res1 = 0 ;
16119 int val2 ;
16120 int ecode2 = 0 ;
16121 int val3 ;
16122 int ecode3 = 0 ;
16123 PyObject * obj0 = 0 ;
16124 PyObject * obj1 = 0 ;
16125 PyObject * obj2 = 0 ;
16126 char * kwnames[] = {
16127 (char *) "self",(char *) "width",(char *) "height", NULL
16128 };
16129
16130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16132 if (!SWIG_IsOK(res1)) {
16133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16134 }
16135 arg1 = reinterpret_cast< wxImage * >(argp1);
16136 ecode2 = SWIG_AsVal_int(obj1, &val2);
16137 if (!SWIG_IsOK(ecode2)) {
16138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16139 }
16140 arg2 = static_cast< int >(val2);
16141 ecode3 = SWIG_AsVal_int(obj2, &val3);
16142 if (!SWIG_IsOK(ecode3)) {
16143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16144 }
16145 arg3 = static_cast< int >(val3);
16146 {
16147 PyThreadState* __tstate = wxPyBeginAllowThreads();
16148 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16149 wxPyEndAllowThreads(__tstate);
16150 if (PyErr_Occurred()) SWIG_fail;
16151 }
16152 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16153 return resultobj;
16154fail:
16155 return NULL;
16156}
16157
16158
16159SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16160 PyObject *resultobj = 0;
16161 wxImage *arg1 = (wxImage *) 0 ;
16162 int arg2 ;
16163 int arg3 ;
16164 SwigValueWrapper<wxImage > result;
16165 void *argp1 = 0 ;
16166 int res1 = 0 ;
16167 int val2 ;
16168 int ecode2 = 0 ;
16169 int val3 ;
16170 int ecode3 = 0 ;
16171 PyObject * obj0 = 0 ;
16172 PyObject * obj1 = 0 ;
16173 PyObject * obj2 = 0 ;
16174 char * kwnames[] = {
16175 (char *) "self",(char *) "width",(char *) "height", NULL
16176 };
16177
16178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16180 if (!SWIG_IsOK(res1)) {
16181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16182 }
16183 arg1 = reinterpret_cast< wxImage * >(argp1);
16184 ecode2 = SWIG_AsVal_int(obj1, &val2);
16185 if (!SWIG_IsOK(ecode2)) {
16186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16187 }
16188 arg2 = static_cast< int >(val2);
16189 ecode3 = SWIG_AsVal_int(obj2, &val3);
16190 if (!SWIG_IsOK(ecode3)) {
16191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16192 }
16193 arg3 = static_cast< int >(val3);
16194 {
16195 PyThreadState* __tstate = wxPyBeginAllowThreads();
16196 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16197 wxPyEndAllowThreads(__tstate);
16198 if (PyErr_Occurred()) SWIG_fail;
16199 }
16200 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16201 return resultobj;
16202fail:
16203 return NULL;
16204}
16205
16206
16207SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16208 PyObject *resultobj = 0;
16209 wxImage *arg1 = (wxImage *) 0 ;
16210 int arg2 ;
16211 SwigValueWrapper<wxImage > result;
16212 void *argp1 = 0 ;
16213 int res1 = 0 ;
16214 int val2 ;
16215 int ecode2 = 0 ;
16216 PyObject * obj0 = 0 ;
16217 PyObject * obj1 = 0 ;
16218 char * kwnames[] = {
16219 (char *) "self",(char *) "radius", NULL
16220 };
16221
16222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16224 if (!SWIG_IsOK(res1)) {
16225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16226 }
16227 arg1 = reinterpret_cast< wxImage * >(argp1);
16228 ecode2 = SWIG_AsVal_int(obj1, &val2);
16229 if (!SWIG_IsOK(ecode2)) {
16230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16231 }
16232 arg2 = static_cast< int >(val2);
16233 {
16234 PyThreadState* __tstate = wxPyBeginAllowThreads();
16235 result = (arg1)->Blur(arg2);
16236 wxPyEndAllowThreads(__tstate);
16237 if (PyErr_Occurred()) SWIG_fail;
16238 }
16239 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16240 return resultobj;
16241fail:
16242 return NULL;
16243}
16244
16245
16246SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16247 PyObject *resultobj = 0;
16248 wxImage *arg1 = (wxImage *) 0 ;
16249 int arg2 ;
16250 SwigValueWrapper<wxImage > result;
16251 void *argp1 = 0 ;
16252 int res1 = 0 ;
16253 int val2 ;
16254 int ecode2 = 0 ;
16255 PyObject * obj0 = 0 ;
16256 PyObject * obj1 = 0 ;
16257 char * kwnames[] = {
16258 (char *) "self",(char *) "radius", NULL
16259 };
16260
16261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16263 if (!SWIG_IsOK(res1)) {
16264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16265 }
16266 arg1 = reinterpret_cast< wxImage * >(argp1);
16267 ecode2 = SWIG_AsVal_int(obj1, &val2);
16268 if (!SWIG_IsOK(ecode2)) {
16269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16270 }
16271 arg2 = static_cast< int >(val2);
16272 {
16273 PyThreadState* __tstate = wxPyBeginAllowThreads();
16274 result = (arg1)->BlurHorizontal(arg2);
16275 wxPyEndAllowThreads(__tstate);
16276 if (PyErr_Occurred()) SWIG_fail;
16277 }
16278 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16279 return resultobj;
16280fail:
16281 return NULL;
16282}
16283
16284
16285SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16286 PyObject *resultobj = 0;
16287 wxImage *arg1 = (wxImage *) 0 ;
16288 int arg2 ;
16289 SwigValueWrapper<wxImage > result;
16290 void *argp1 = 0 ;
16291 int res1 = 0 ;
16292 int val2 ;
16293 int ecode2 = 0 ;
16294 PyObject * obj0 = 0 ;
16295 PyObject * obj1 = 0 ;
16296 char * kwnames[] = {
16297 (char *) "self",(char *) "radius", NULL
16298 };
16299
16300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16302 if (!SWIG_IsOK(res1)) {
16303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16304 }
16305 arg1 = reinterpret_cast< wxImage * >(argp1);
16306 ecode2 = SWIG_AsVal_int(obj1, &val2);
16307 if (!SWIG_IsOK(ecode2)) {
16308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16309 }
16310 arg2 = static_cast< int >(val2);
16311 {
16312 PyThreadState* __tstate = wxPyBeginAllowThreads();
16313 result = (arg1)->BlurVertical(arg2);
1bd55598
RD
16314 wxPyEndAllowThreads(__tstate);
16315 if (PyErr_Occurred()) SWIG_fail;
16316 }
16317 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16318 return resultobj;
16319fail:
16320 return NULL;
16321}
16322
16323
16324SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16325 PyObject *resultobj = 0;
16326 wxImage *arg1 = (wxImage *) 0 ;
16327 int arg2 ;
16328 int arg3 ;
16329 SwigValueWrapper<wxImage > result;
16330 void *argp1 = 0 ;
16331 int res1 = 0 ;
16332 int val2 ;
16333 int ecode2 = 0 ;
16334 int val3 ;
16335 int ecode3 = 0 ;
16336 PyObject * obj0 = 0 ;
16337 PyObject * obj1 = 0 ;
16338 PyObject * obj2 = 0 ;
16339 char * kwnames[] = {
16340 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16341 };
16342
16343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16345 if (!SWIG_IsOK(res1)) {
16346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16347 }
16348 arg1 = reinterpret_cast< wxImage * >(argp1);
16349 ecode2 = SWIG_AsVal_int(obj1, &val2);
16350 if (!SWIG_IsOK(ecode2)) {
16351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16352 }
16353 arg2 = static_cast< int >(val2);
16354 ecode3 = SWIG_AsVal_int(obj2, &val3);
16355 if (!SWIG_IsOK(ecode3)) {
16356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16357 }
16358 arg3 = static_cast< int >(val3);
16359 {
16360 PyThreadState* __tstate = wxPyBeginAllowThreads();
16361 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16362 wxPyEndAllowThreads(__tstate);
16363 if (PyErr_Occurred()) SWIG_fail;
16364 }
16365 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16366 return resultobj;
16367fail:
16368 return NULL;
16369}
16370
16371
16372SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16373 PyObject *resultobj = 0;
16374 wxImage *arg1 = (wxImage *) 0 ;
16375 int arg2 ;
16376 int arg3 ;
f5263701 16377 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
1bd55598
RD
16378 wxImage *result = 0 ;
16379 void *argp1 = 0 ;
16380 int res1 = 0 ;
16381 int val2 ;
16382 int ecode2 = 0 ;
16383 int val3 ;
16384 int ecode3 = 0 ;
f5263701
RD
16385 int val4 ;
16386 int ecode4 = 0 ;
1bd55598
RD
16387 PyObject * obj0 = 0 ;
16388 PyObject * obj1 = 0 ;
16389 PyObject * obj2 = 0 ;
f5263701 16390 PyObject * obj3 = 0 ;
1bd55598 16391 char * kwnames[] = {
f5263701 16392 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
1bd55598
RD
16393 };
16394
f5263701 16395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
1bd55598
RD
16396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16397 if (!SWIG_IsOK(res1)) {
16398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16399 }
16400 arg1 = reinterpret_cast< wxImage * >(argp1);
16401 ecode2 = SWIG_AsVal_int(obj1, &val2);
16402 if (!SWIG_IsOK(ecode2)) {
16403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16404 }
16405 arg2 = static_cast< int >(val2);
16406 ecode3 = SWIG_AsVal_int(obj2, &val3);
16407 if (!SWIG_IsOK(ecode3)) {
16408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16409 }
16410 arg3 = static_cast< int >(val3);
f5263701
RD
16411 if (obj3) {
16412 ecode4 = SWIG_AsVal_int(obj3, &val4);
16413 if (!SWIG_IsOK(ecode4)) {
16414 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16415 }
16416 arg4 = static_cast< int >(val4);
16417 }
1bd55598
RD
16418 {
16419 PyThreadState* __tstate = wxPyBeginAllowThreads();
d55e5bfc 16420 {
f5263701 16421 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
1bd55598 16422 result = (wxImage *) &_result_ref;
d55e5bfc 16423 }
1bd55598
RD
16424 wxPyEndAllowThreads(__tstate);
16425 if (PyErr_Occurred()) SWIG_fail;
16426 }
16427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16428 return resultobj;
16429fail:
16430 return NULL;
16431}
16432
16433
16434SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16435 PyObject *resultobj = 0;
16436 wxImage *arg1 = (wxImage *) 0 ;
16437 wxSize *arg2 = 0 ;
16438 wxPoint *arg3 = 0 ;
16439 int arg4 = (int) -1 ;
16440 int arg5 = (int) -1 ;
16441 int arg6 = (int) -1 ;
16442 wxImage *result = 0 ;
16443 void *argp1 = 0 ;
16444 int res1 = 0 ;
16445 wxSize temp2 ;
16446 wxPoint temp3 ;
16447 int val4 ;
16448 int ecode4 = 0 ;
16449 int val5 ;
16450 int ecode5 = 0 ;
16451 int val6 ;
16452 int ecode6 = 0 ;
16453 PyObject * obj0 = 0 ;
16454 PyObject * obj1 = 0 ;
16455 PyObject * obj2 = 0 ;
16456 PyObject * obj3 = 0 ;
16457 PyObject * obj4 = 0 ;
16458 PyObject * obj5 = 0 ;
16459 char * kwnames[] = {
16460 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16461 };
16462
16463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16465 if (!SWIG_IsOK(res1)) {
16466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16467 }
16468 arg1 = reinterpret_cast< wxImage * >(argp1);
16469 {
16470 arg2 = &temp2;
16471 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16472 }
16473 {
16474 arg3 = &temp3;
16475 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16476 }
16477 if (obj3) {
16478 ecode4 = SWIG_AsVal_int(obj3, &val4);
16479 if (!SWIG_IsOK(ecode4)) {
16480 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16481 }
16482 arg4 = static_cast< int >(val4);
16483 }
16484 if (obj4) {
16485 ecode5 = SWIG_AsVal_int(obj4, &val5);
16486 if (!SWIG_IsOK(ecode5)) {
16487 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16488 }
16489 arg5 = static_cast< int >(val5);
16490 }
16491 if (obj5) {
16492 ecode6 = SWIG_AsVal_int(obj5, &val6);
16493 if (!SWIG_IsOK(ecode6)) {
16494 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16495 }
16496 arg6 = static_cast< int >(val6);
16497 }
16498 {
16499 PyThreadState* __tstate = wxPyBeginAllowThreads();
36ed4f51 16500 {
1bd55598
RD
16501 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16502 result = (wxImage *) &_result_ref;
36ed4f51 16503 }
1bd55598
RD
16504 wxPyEndAllowThreads(__tstate);
16505 if (PyErr_Occurred()) SWIG_fail;
16506 }
16507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16508 return resultobj;
16509fail:
16510 return NULL;
16511}
16512
16513
16514SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16515 PyObject *resultobj = 0;
16516 wxImage *arg1 = (wxImage *) 0 ;
16517 int arg2 ;
16518 int arg3 ;
16519 byte arg4 ;
16520 byte arg5 ;
16521 byte arg6 ;
16522 void *argp1 = 0 ;
16523 int res1 = 0 ;
16524 int val2 ;
16525 int ecode2 = 0 ;
16526 int val3 ;
16527 int ecode3 = 0 ;
16528 unsigned char val4 ;
16529 int ecode4 = 0 ;
16530 unsigned char val5 ;
16531 int ecode5 = 0 ;
16532 unsigned char val6 ;
16533 int ecode6 = 0 ;
16534 PyObject * obj0 = 0 ;
16535 PyObject * obj1 = 0 ;
16536 PyObject * obj2 = 0 ;
16537 PyObject * obj3 = 0 ;
16538 PyObject * obj4 = 0 ;
16539 PyObject * obj5 = 0 ;
16540 char * kwnames[] = {
16541 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16542 };
16543
16544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16546 if (!SWIG_IsOK(res1)) {
16547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16548 }
16549 arg1 = reinterpret_cast< wxImage * >(argp1);
16550 ecode2 = SWIG_AsVal_int(obj1, &val2);
16551 if (!SWIG_IsOK(ecode2)) {
16552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16553 }
16554 arg2 = static_cast< int >(val2);
16555 ecode3 = SWIG_AsVal_int(obj2, &val3);
16556 if (!SWIG_IsOK(ecode3)) {
16557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16558 }
16559 arg3 = static_cast< int >(val3);
16560 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16561 if (!SWIG_IsOK(ecode4)) {
16562 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16563 }
16564 arg4 = static_cast< byte >(val4);
16565 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16566 if (!SWIG_IsOK(ecode5)) {
16567 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16568 }
16569 arg5 = static_cast< byte >(val5);
16570 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16571 if (!SWIG_IsOK(ecode6)) {
16572 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16573 }
16574 arg6 = static_cast< byte >(val6);
16575 {
16576 PyThreadState* __tstate = wxPyBeginAllowThreads();
16577 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16578 wxPyEndAllowThreads(__tstate);
16579 if (PyErr_Occurred()) SWIG_fail;
16580 }
16581 resultobj = SWIG_Py_Void();
16582 return resultobj;
16583fail:
16584 return NULL;
16585}
16586
16587
16588SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16589 PyObject *resultobj = 0;
16590 wxImage *arg1 = (wxImage *) 0 ;
16591 wxRect *arg2 = 0 ;
16592 byte arg3 ;
16593 byte arg4 ;
16594 byte arg5 ;
16595 void *argp1 = 0 ;
16596 int res1 = 0 ;
16597 wxRect temp2 ;
16598 unsigned char val3 ;
16599 int ecode3 = 0 ;
16600 unsigned char val4 ;
16601 int ecode4 = 0 ;
16602 unsigned char val5 ;
16603 int ecode5 = 0 ;
16604 PyObject * obj0 = 0 ;
16605 PyObject * obj1 = 0 ;
16606 PyObject * obj2 = 0 ;
16607 PyObject * obj3 = 0 ;
16608 PyObject * obj4 = 0 ;
16609 char * kwnames[] = {
16610 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16611 };
16612
16613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16615 if (!SWIG_IsOK(res1)) {
16616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16617 }
16618 arg1 = reinterpret_cast< wxImage * >(argp1);
16619 {
16620 arg2 = &temp2;
16621 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16622 }
16623 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16624 if (!SWIG_IsOK(ecode3)) {
16625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16626 }
16627 arg3 = static_cast< byte >(val3);
16628 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16629 if (!SWIG_IsOK(ecode4)) {
16630 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16631 }
16632 arg4 = static_cast< byte >(val4);
16633 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16634 if (!SWIG_IsOK(ecode5)) {
16635 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16636 }
16637 arg5 = static_cast< byte >(val5);
16638 {
16639 PyThreadState* __tstate = wxPyBeginAllowThreads();
16640 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16641 wxPyEndAllowThreads(__tstate);
16642 if (PyErr_Occurred()) SWIG_fail;
16643 }
16644 resultobj = SWIG_Py_Void();
16645 return resultobj;
16646fail:
16647 return NULL;
16648}
16649
16650
16651SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16652 PyObject *resultobj = 0;
16653 wxImage *arg1 = (wxImage *) 0 ;
16654 int arg2 ;
16655 int arg3 ;
16656 byte result;
16657 void *argp1 = 0 ;
16658 int res1 = 0 ;
16659 int val2 ;
16660 int ecode2 = 0 ;
16661 int val3 ;
16662 int ecode3 = 0 ;
16663 PyObject * obj0 = 0 ;
16664 PyObject * obj1 = 0 ;
16665 PyObject * obj2 = 0 ;
16666 char * kwnames[] = {
16667 (char *) "self",(char *) "x",(char *) "y", NULL
16668 };
16669
16670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16672 if (!SWIG_IsOK(res1)) {
16673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16674 }
16675 arg1 = reinterpret_cast< wxImage * >(argp1);
16676 ecode2 = SWIG_AsVal_int(obj1, &val2);
16677 if (!SWIG_IsOK(ecode2)) {
16678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16679 }
16680 arg2 = static_cast< int >(val2);
16681 ecode3 = SWIG_AsVal_int(obj2, &val3);
16682 if (!SWIG_IsOK(ecode3)) {
16683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16684 }
16685 arg3 = static_cast< int >(val3);
16686 {
16687 PyThreadState* __tstate = wxPyBeginAllowThreads();
16688 result = (byte)(arg1)->GetRed(arg2,arg3);
16689 wxPyEndAllowThreads(__tstate);
16690 if (PyErr_Occurred()) SWIG_fail;
16691 }
16692 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16693 return resultobj;
16694fail:
16695 return NULL;
16696}
16697
16698
16699SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16700 PyObject *resultobj = 0;
16701 wxImage *arg1 = (wxImage *) 0 ;
16702 int arg2 ;
16703 int arg3 ;
16704 byte result;
16705 void *argp1 = 0 ;
16706 int res1 = 0 ;
16707 int val2 ;
16708 int ecode2 = 0 ;
16709 int val3 ;
16710 int ecode3 = 0 ;
16711 PyObject * obj0 = 0 ;
16712 PyObject * obj1 = 0 ;
16713 PyObject * obj2 = 0 ;
16714 char * kwnames[] = {
16715 (char *) "self",(char *) "x",(char *) "y", NULL
16716 };
16717
16718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16720 if (!SWIG_IsOK(res1)) {
16721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16722 }
16723 arg1 = reinterpret_cast< wxImage * >(argp1);
16724 ecode2 = SWIG_AsVal_int(obj1, &val2);
16725 if (!SWIG_IsOK(ecode2)) {
16726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16727 }
16728 arg2 = static_cast< int >(val2);
16729 ecode3 = SWIG_AsVal_int(obj2, &val3);
16730 if (!SWIG_IsOK(ecode3)) {
16731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16732 }
16733 arg3 = static_cast< int >(val3);
16734 {
16735 PyThreadState* __tstate = wxPyBeginAllowThreads();
16736 result = (byte)(arg1)->GetGreen(arg2,arg3);
16737 wxPyEndAllowThreads(__tstate);
16738 if (PyErr_Occurred()) SWIG_fail;
16739 }
16740 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16741 return resultobj;
16742fail:
16743 return NULL;
16744}
16745
16746
16747SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16748 PyObject *resultobj = 0;
16749 wxImage *arg1 = (wxImage *) 0 ;
16750 int arg2 ;
16751 int arg3 ;
16752 byte result;
16753 void *argp1 = 0 ;
16754 int res1 = 0 ;
16755 int val2 ;
16756 int ecode2 = 0 ;
16757 int val3 ;
16758 int ecode3 = 0 ;
16759 PyObject * obj0 = 0 ;
16760 PyObject * obj1 = 0 ;
16761 PyObject * obj2 = 0 ;
16762 char * kwnames[] = {
16763 (char *) "self",(char *) "x",(char *) "y", NULL
16764 };
16765
16766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16768 if (!SWIG_IsOK(res1)) {
16769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16770 }
16771 arg1 = reinterpret_cast< wxImage * >(argp1);
16772 ecode2 = SWIG_AsVal_int(obj1, &val2);
16773 if (!SWIG_IsOK(ecode2)) {
16774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16775 }
16776 arg2 = static_cast< int >(val2);
16777 ecode3 = SWIG_AsVal_int(obj2, &val3);
16778 if (!SWIG_IsOK(ecode3)) {
16779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16780 }
16781 arg3 = static_cast< int >(val3);
16782 {
16783 PyThreadState* __tstate = wxPyBeginAllowThreads();
16784 result = (byte)(arg1)->GetBlue(arg2,arg3);
16785 wxPyEndAllowThreads(__tstate);
16786 if (PyErr_Occurred()) SWIG_fail;
16787 }
16788 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16789 return resultobj;
16790fail:
16791 return NULL;
16792}
16793
16794
16795SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16796 PyObject *resultobj = 0;
16797 wxImage *arg1 = (wxImage *) 0 ;
16798 int arg2 ;
16799 int arg3 ;
16800 byte arg4 ;
16801 void *argp1 = 0 ;
16802 int res1 = 0 ;
16803 int val2 ;
16804 int ecode2 = 0 ;
16805 int val3 ;
16806 int ecode3 = 0 ;
16807 unsigned char val4 ;
16808 int ecode4 = 0 ;
16809 PyObject * obj0 = 0 ;
16810 PyObject * obj1 = 0 ;
16811 PyObject * obj2 = 0 ;
16812 PyObject * obj3 = 0 ;
16813 char * kwnames[] = {
16814 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16815 };
16816
16817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16819 if (!SWIG_IsOK(res1)) {
16820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16821 }
16822 arg1 = reinterpret_cast< wxImage * >(argp1);
16823 ecode2 = SWIG_AsVal_int(obj1, &val2);
16824 if (!SWIG_IsOK(ecode2)) {
16825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16826 }
16827 arg2 = static_cast< int >(val2);
16828 ecode3 = SWIG_AsVal_int(obj2, &val3);
16829 if (!SWIG_IsOK(ecode3)) {
16830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16831 }
16832 arg3 = static_cast< int >(val3);
16833 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16834 if (!SWIG_IsOK(ecode4)) {
16835 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16836 }
16837 arg4 = static_cast< byte >(val4);
16838 {
16839 PyThreadState* __tstate = wxPyBeginAllowThreads();
16840 (arg1)->SetAlpha(arg2,arg3,arg4);
16841 wxPyEndAllowThreads(__tstate);
16842 if (PyErr_Occurred()) SWIG_fail;
16843 }
16844 resultobj = SWIG_Py_Void();
16845 return resultobj;
16846fail:
16847 return NULL;
16848}
16849
16850
16851SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16852 PyObject *resultobj = 0;
16853 wxImage *arg1 = (wxImage *) 0 ;
16854 int arg2 ;
16855 int arg3 ;
16856 byte result;
16857 void *argp1 = 0 ;
16858 int res1 = 0 ;
16859 int val2 ;
16860 int ecode2 = 0 ;
16861 int val3 ;
16862 int ecode3 = 0 ;
16863 PyObject * obj0 = 0 ;
16864 PyObject * obj1 = 0 ;
16865 PyObject * obj2 = 0 ;
16866 char * kwnames[] = {
16867 (char *) "self",(char *) "x",(char *) "y", NULL
16868 };
16869
16870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16872 if (!SWIG_IsOK(res1)) {
16873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16874 }
16875 arg1 = reinterpret_cast< wxImage * >(argp1);
16876 ecode2 = SWIG_AsVal_int(obj1, &val2);
16877 if (!SWIG_IsOK(ecode2)) {
16878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16879 }
16880 arg2 = static_cast< int >(val2);
16881 ecode3 = SWIG_AsVal_int(obj2, &val3);
16882 if (!SWIG_IsOK(ecode3)) {
16883 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16884 }
16885 arg3 = static_cast< int >(val3);
16886 {
16887 PyThreadState* __tstate = wxPyBeginAllowThreads();
16888 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16889 wxPyEndAllowThreads(__tstate);
16890 if (PyErr_Occurred()) SWIG_fail;
16891 }
16892 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16893 return resultobj;
16894fail:
16895 return NULL;
d55e5bfc
RD
16896}
16897
16898
1bd55598
RD
16899SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16900 PyObject *resultobj = 0;
16901 wxImage *arg1 = (wxImage *) 0 ;
16902 bool result;
16903 void *argp1 = 0 ;
16904 int res1 = 0 ;
16905 PyObject *swig_obj[1] ;
16906
16907 if (!args) SWIG_fail;
16908 swig_obj[0] = args;
16909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16910 if (!SWIG_IsOK(res1)) {
16911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16912 }
16913 arg1 = reinterpret_cast< wxImage * >(argp1);
16914 {
16915 PyThreadState* __tstate = wxPyBeginAllowThreads();
16916 result = (bool)(arg1)->HasAlpha();
16917 wxPyEndAllowThreads(__tstate);
16918 if (PyErr_Occurred()) SWIG_fail;
16919 }
16920 {
16921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16922 }
16923 return resultobj;
16924fail:
16925 return NULL;
d55e5bfc
RD
16926}
16927
16928
1bd55598
RD
16929SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16930 PyObject *resultobj = 0;
16931 wxImage *arg1 = (wxImage *) 0 ;
16932 void *argp1 = 0 ;
16933 int res1 = 0 ;
16934 PyObject *swig_obj[1] ;
16935
16936 if (!args) SWIG_fail;
16937 swig_obj[0] = args;
16938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16939 if (!SWIG_IsOK(res1)) {
16940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16941 }
16942 arg1 = reinterpret_cast< wxImage * >(argp1);
16943 {
16944 PyThreadState* __tstate = wxPyBeginAllowThreads();
16945 (arg1)->InitAlpha();
16946 wxPyEndAllowThreads(__tstate);
16947 if (PyErr_Occurred()) SWIG_fail;
16948 }
16949 resultobj = SWIG_Py_Void();
16950 return resultobj;
16951fail:
16952 return NULL;
16953}
16954
16955
16956SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16957 PyObject *resultobj = 0;
16958 wxImage *arg1 = (wxImage *) 0 ;
16959 int arg2 ;
16960 int arg3 ;
16961 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
16962 bool result;
16963 void *argp1 = 0 ;
16964 int res1 = 0 ;
16965 int val2 ;
16966 int ecode2 = 0 ;
16967 int val3 ;
16968 int ecode3 = 0 ;
16969 unsigned char val4 ;
16970 int ecode4 = 0 ;
16971 PyObject * obj0 = 0 ;
16972 PyObject * obj1 = 0 ;
16973 PyObject * obj2 = 0 ;
16974 PyObject * obj3 = 0 ;
16975 char * kwnames[] = {
16976 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
16977 };
16978
16979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16981 if (!SWIG_IsOK(res1)) {
16982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
16983 }
16984 arg1 = reinterpret_cast< wxImage * >(argp1);
16985 ecode2 = SWIG_AsVal_int(obj1, &val2);
16986 if (!SWIG_IsOK(ecode2)) {
16987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
16988 }
16989 arg2 = static_cast< int >(val2);
16990 ecode3 = SWIG_AsVal_int(obj2, &val3);
16991 if (!SWIG_IsOK(ecode3)) {
16992 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
16993 }
16994 arg3 = static_cast< int >(val3);
16995 if (obj3) {
16996 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16997 if (!SWIG_IsOK(ecode4)) {
16998 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
16999 }
17000 arg4 = static_cast< byte >(val4);
17001 }
17002 {
17003 PyThreadState* __tstate = wxPyBeginAllowThreads();
17004 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17005 wxPyEndAllowThreads(__tstate);
17006 if (PyErr_Occurred()) SWIG_fail;
17007 }
17008 {
17009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17010 }
17011 return resultobj;
17012fail:
17013 return NULL;
17014}
17015
17016
17017SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17018 PyObject *resultobj = 0;
17019 wxImage *arg1 = (wxImage *) 0 ;
17020 byte *arg2 = (byte *) 0 ;
17021 byte *arg3 = (byte *) 0 ;
17022 byte *arg4 = (byte *) 0 ;
17023 byte arg5 = (byte) 0 ;
17024 byte arg6 = (byte) 0 ;
17025 byte arg7 = (byte) 0 ;
17026 bool result;
17027 void *argp1 = 0 ;
17028 int res1 = 0 ;
17029 byte temp2 ;
17030 int res2 = SWIG_TMPOBJ ;
17031 byte temp3 ;
17032 int res3 = SWIG_TMPOBJ ;
17033 byte temp4 ;
17034 int res4 = SWIG_TMPOBJ ;
17035 unsigned char val5 ;
17036 int ecode5 = 0 ;
17037 unsigned char val6 ;
17038 int ecode6 = 0 ;
17039 unsigned char val7 ;
17040 int ecode7 = 0 ;
17041 PyObject * obj0 = 0 ;
17042 PyObject * obj1 = 0 ;
17043 PyObject * obj2 = 0 ;
17044 PyObject * obj3 = 0 ;
17045 char * kwnames[] = {
17046 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17047 };
17048
17049 arg2 = &temp2;
17050 arg3 = &temp3;
17051 arg4 = &temp4;
17052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17054 if (!SWIG_IsOK(res1)) {
17055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17056 }
17057 arg1 = reinterpret_cast< wxImage * >(argp1);
17058 if (obj1) {
17059 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17060 if (!SWIG_IsOK(ecode5)) {
17061 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17062 }
17063 arg5 = static_cast< byte >(val5);
17064 }
17065 if (obj2) {
17066 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17067 if (!SWIG_IsOK(ecode6)) {
17068 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17069 }
17070 arg6 = static_cast< byte >(val6);
17071 }
17072 if (obj3) {
17073 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17074 if (!SWIG_IsOK(ecode7)) {
17075 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17076 }
17077 arg7 = static_cast< byte >(val7);
17078 }
17079 {
17080 PyThreadState* __tstate = wxPyBeginAllowThreads();
17081 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17082 wxPyEndAllowThreads(__tstate);
17083 if (PyErr_Occurred()) SWIG_fail;
17084 }
17085 {
17086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17087 }
17088 if (SWIG_IsTmpObj(res2)) {
17089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17090 } else {
17091 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17093 }
17094 if (SWIG_IsTmpObj(res3)) {
17095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17096 } else {
17097 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17099 }
17100 if (SWIG_IsTmpObj(res4)) {
17101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17102 } else {
17103 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17104 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17105 }
17106 return resultobj;
17107fail:
17108 return NULL;
17109}
17110
17111
17112SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17113 PyObject *resultobj = 0;
17114 wxImage *arg1 = (wxImage *) 0 ;
17115 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17116 bool result;
17117 void *argp1 = 0 ;
17118 int res1 = 0 ;
17119 unsigned char val2 ;
17120 int ecode2 = 0 ;
17121 PyObject * obj0 = 0 ;
17122 PyObject * obj1 = 0 ;
17123 char * kwnames[] = {
17124 (char *) "self",(char *) "threshold", NULL
17125 };
17126
17127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17129 if (!SWIG_IsOK(res1)) {
17130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17131 }
17132 arg1 = reinterpret_cast< wxImage * >(argp1);
17133 if (obj1) {
17134 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17135 if (!SWIG_IsOK(ecode2)) {
17136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17137 }
17138 arg2 = static_cast< byte >(val2);
17139 }
17140 {
17141 PyThreadState* __tstate = wxPyBeginAllowThreads();
17142 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17143 wxPyEndAllowThreads(__tstate);
17144 if (PyErr_Occurred()) SWIG_fail;
17145 }
17146 {
17147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17148 }
17149 return resultobj;
17150fail:
17151 return NULL;
17152}
17153
17154
17155SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17156 PyObject *resultobj = 0;
17157 wxImage *arg1 = (wxImage *) 0 ;
17158 byte arg2 ;
17159 byte arg3 ;
17160 byte arg4 ;
17161 bool result;
17162 void *argp1 = 0 ;
17163 int res1 = 0 ;
17164 unsigned char val2 ;
17165 int ecode2 = 0 ;
17166 unsigned char val3 ;
17167 int ecode3 = 0 ;
17168 unsigned char val4 ;
17169 int ecode4 = 0 ;
17170 PyObject * obj0 = 0 ;
17171 PyObject * obj1 = 0 ;
17172 PyObject * obj2 = 0 ;
17173 PyObject * obj3 = 0 ;
17174 char * kwnames[] = {
17175 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17176 };
17177
17178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17180 if (!SWIG_IsOK(res1)) {
17181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17182 }
17183 arg1 = reinterpret_cast< wxImage * >(argp1);
17184 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17185 if (!SWIG_IsOK(ecode2)) {
17186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17187 }
17188 arg2 = static_cast< byte >(val2);
17189 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17190 if (!SWIG_IsOK(ecode3)) {
17191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17192 }
17193 arg3 = static_cast< byte >(val3);
17194 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17195 if (!SWIG_IsOK(ecode4)) {
17196 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17197 }
17198 arg4 = static_cast< byte >(val4);
17199 {
17200 PyThreadState* __tstate = wxPyBeginAllowThreads();
17201 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17202 wxPyEndAllowThreads(__tstate);
17203 if (PyErr_Occurred()) SWIG_fail;
17204 }
17205 {
17206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17207 }
17208 return resultobj;
17209fail:
17210 return NULL;
17211}
17212
17213
17214SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17215 PyObject *resultobj = 0;
17216 wxImage *arg1 = (wxImage *) 0 ;
17217 wxImage *arg2 = 0 ;
17218 byte arg3 ;
17219 byte arg4 ;
17220 byte arg5 ;
17221 bool result;
17222 void *argp1 = 0 ;
17223 int res1 = 0 ;
17224 void *argp2 = 0 ;
17225 int res2 = 0 ;
17226 unsigned char val3 ;
17227 int ecode3 = 0 ;
17228 unsigned char val4 ;
17229 int ecode4 = 0 ;
17230 unsigned char val5 ;
17231 int ecode5 = 0 ;
17232 PyObject * obj0 = 0 ;
17233 PyObject * obj1 = 0 ;
17234 PyObject * obj2 = 0 ;
17235 PyObject * obj3 = 0 ;
17236 PyObject * obj4 = 0 ;
17237 char * kwnames[] = {
17238 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17239 };
17240
17241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17243 if (!SWIG_IsOK(res1)) {
17244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17245 }
17246 arg1 = reinterpret_cast< wxImage * >(argp1);
17247 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17248 if (!SWIG_IsOK(res2)) {
17249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17250 }
17251 if (!argp2) {
17252 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17253 }
17254 arg2 = reinterpret_cast< wxImage * >(argp2);
17255 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17256 if (!SWIG_IsOK(ecode3)) {
17257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17258 }
17259 arg3 = static_cast< byte >(val3);
17260 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17261 if (!SWIG_IsOK(ecode4)) {
17262 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17263 }
17264 arg4 = static_cast< byte >(val4);
17265 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17266 if (!SWIG_IsOK(ecode5)) {
17267 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17268 }
17269 arg5 = static_cast< byte >(val5);
17270 {
17271 PyThreadState* __tstate = wxPyBeginAllowThreads();
17272 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17273 wxPyEndAllowThreads(__tstate);
17274 if (PyErr_Occurred()) SWIG_fail;
17275 }
17276 {
17277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17278 }
17279 return resultobj;
17280fail:
17281 return NULL;
d55e5bfc
RD
17282}
17283
17284
1bd55598
RD
17285SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17286 PyObject *resultobj = 0;
17287 wxString *arg1 = 0 ;
17288 bool result;
17289 bool temp1 = false ;
17290 PyObject * obj0 = 0 ;
17291 char * kwnames[] = {
17292 (char *) "filename", NULL
17293 };
17294
17295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17296 {
17297 arg1 = wxString_in_helper(obj0);
17298 if (arg1 == NULL) SWIG_fail;
17299 temp1 = true;
17300 }
17301 {
17302 PyThreadState* __tstate = wxPyBeginAllowThreads();
17303 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17304 wxPyEndAllowThreads(__tstate);
17305 if (PyErr_Occurred()) SWIG_fail;
17306 }
17307 {
17308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17309 }
17310 {
17311 if (temp1)
17312 delete arg1;
17313 }
17314 return resultobj;
17315fail:
17316 {
17317 if (temp1)
17318 delete arg1;
17319 }
17320 return NULL;
17321}
17322
17323
17324SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17325 PyObject *resultobj = 0;
17326 wxString *arg1 = 0 ;
17327 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17328 int result;
17329 bool temp1 = false ;
17330 long val2 ;
17331 int ecode2 = 0 ;
17332 PyObject * obj0 = 0 ;
17333 PyObject * obj1 = 0 ;
17334 char * kwnames[] = {
17335 (char *) "filename",(char *) "type", NULL
17336 };
17337
17338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17339 {
17340 arg1 = wxString_in_helper(obj0);
17341 if (arg1 == NULL) SWIG_fail;
17342 temp1 = true;
17343 }
17344 if (obj1) {
17345 ecode2 = SWIG_AsVal_long(obj1, &val2);
17346 if (!SWIG_IsOK(ecode2)) {
17347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17348 }
17349 arg2 = static_cast< long >(val2);
17350 }
17351 {
17352 PyThreadState* __tstate = wxPyBeginAllowThreads();
17353 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17354 wxPyEndAllowThreads(__tstate);
17355 if (PyErr_Occurred()) SWIG_fail;
17356 }
17357 resultobj = SWIG_From_int(static_cast< int >(result));
17358 {
17359 if (temp1)
17360 delete arg1;
17361 }
17362 return resultobj;
17363fail:
17364 {
17365 if (temp1)
17366 delete arg1;
17367 }
17368 return NULL;
17369}
17370
17371
17372SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17373 PyObject *resultobj = 0;
17374 wxImage *arg1 = (wxImage *) 0 ;
17375 wxString *arg2 = 0 ;
17376 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17377 int arg4 = (int) -1 ;
17378 bool result;
17379 void *argp1 = 0 ;
17380 int res1 = 0 ;
17381 bool temp2 = false ;
17382 long val3 ;
17383 int ecode3 = 0 ;
17384 int val4 ;
17385 int ecode4 = 0 ;
17386 PyObject * obj0 = 0 ;
17387 PyObject * obj1 = 0 ;
17388 PyObject * obj2 = 0 ;
17389 PyObject * obj3 = 0 ;
17390 char * kwnames[] = {
17391 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17392 };
17393
17394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17396 if (!SWIG_IsOK(res1)) {
17397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17398 }
17399 arg1 = reinterpret_cast< wxImage * >(argp1);
17400 {
17401 arg2 = wxString_in_helper(obj1);
17402 if (arg2 == NULL) SWIG_fail;
17403 temp2 = true;
17404 }
17405 if (obj2) {
17406 ecode3 = SWIG_AsVal_long(obj2, &val3);
17407 if (!SWIG_IsOK(ecode3)) {
17408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17409 }
17410 arg3 = static_cast< long >(val3);
17411 }
17412 if (obj3) {
17413 ecode4 = SWIG_AsVal_int(obj3, &val4);
17414 if (!SWIG_IsOK(ecode4)) {
17415 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17416 }
17417 arg4 = static_cast< int >(val4);
17418 }
17419 {
17420 PyThreadState* __tstate = wxPyBeginAllowThreads();
17421 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17422 wxPyEndAllowThreads(__tstate);
17423 if (PyErr_Occurred()) SWIG_fail;
17424 }
17425 {
17426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17427 }
17428 {
17429 if (temp2)
17430 delete arg2;
17431 }
17432 return resultobj;
17433fail:
17434 {
17435 if (temp2)
17436 delete arg2;
17437 }
17438 return NULL;
17439}
17440
17441
17442SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17443 PyObject *resultobj = 0;
17444 wxImage *arg1 = (wxImage *) 0 ;
17445 wxString *arg2 = 0 ;
17446 wxString *arg3 = 0 ;
17447 int arg4 = (int) -1 ;
17448 bool result;
17449 void *argp1 = 0 ;
17450 int res1 = 0 ;
17451 bool temp2 = false ;
17452 bool temp3 = false ;
17453 int val4 ;
17454 int ecode4 = 0 ;
17455 PyObject * obj0 = 0 ;
17456 PyObject * obj1 = 0 ;
17457 PyObject * obj2 = 0 ;
17458 PyObject * obj3 = 0 ;
17459 char * kwnames[] = {
17460 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17461 };
17462
17463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17465 if (!SWIG_IsOK(res1)) {
17466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17467 }
17468 arg1 = reinterpret_cast< wxImage * >(argp1);
17469 {
17470 arg2 = wxString_in_helper(obj1);
17471 if (arg2 == NULL) SWIG_fail;
17472 temp2 = true;
17473 }
17474 {
17475 arg3 = wxString_in_helper(obj2);
17476 if (arg3 == NULL) SWIG_fail;
17477 temp3 = true;
17478 }
17479 if (obj3) {
17480 ecode4 = SWIG_AsVal_int(obj3, &val4);
17481 if (!SWIG_IsOK(ecode4)) {
17482 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17483 }
17484 arg4 = static_cast< int >(val4);
17485 }
17486 {
17487 PyThreadState* __tstate = wxPyBeginAllowThreads();
17488 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17489 wxPyEndAllowThreads(__tstate);
17490 if (PyErr_Occurred()) SWIG_fail;
17491 }
17492 {
17493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17494 }
17495 {
17496 if (temp2)
17497 delete arg2;
17498 }
17499 {
17500 if (temp3)
17501 delete arg3;
17502 }
17503 return resultobj;
17504fail:
17505 {
17506 if (temp2)
17507 delete arg2;
17508 }
17509 {
17510 if (temp3)
17511 delete arg3;
17512 }
17513 return NULL;
17514}
17515
17516
17517SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17518 PyObject *resultobj = 0;
17519 wxImage *arg1 = (wxImage *) 0 ;
17520 wxString *arg2 = 0 ;
17521 int arg3 ;
17522 bool result;
17523 void *argp1 = 0 ;
17524 int res1 = 0 ;
17525 bool temp2 = false ;
17526 int val3 ;
17527 int ecode3 = 0 ;
17528 PyObject * obj0 = 0 ;
17529 PyObject * obj1 = 0 ;
17530 PyObject * obj2 = 0 ;
17531 char * kwnames[] = {
17532 (char *) "self",(char *) "name",(char *) "type", NULL
17533 };
17534
17535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17537 if (!SWIG_IsOK(res1)) {
17538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17539 }
17540 arg1 = reinterpret_cast< wxImage * >(argp1);
17541 {
17542 arg2 = wxString_in_helper(obj1);
17543 if (arg2 == NULL) SWIG_fail;
17544 temp2 = true;
17545 }
17546 ecode3 = SWIG_AsVal_int(obj2, &val3);
17547 if (!SWIG_IsOK(ecode3)) {
17548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17549 }
17550 arg3 = static_cast< int >(val3);
17551 {
17552 PyThreadState* __tstate = wxPyBeginAllowThreads();
17553 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17554 wxPyEndAllowThreads(__tstate);
17555 if (PyErr_Occurred()) SWIG_fail;
17556 }
17557 {
17558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17559 }
17560 {
17561 if (temp2)
17562 delete arg2;
17563 }
17564 return resultobj;
17565fail:
17566 {
17567 if (temp2)
17568 delete arg2;
17569 }
17570 return NULL;
17571}
17572
17573
17574SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17575 PyObject *resultobj = 0;
17576 wxImage *arg1 = (wxImage *) 0 ;
17577 wxString *arg2 = 0 ;
17578 wxString *arg3 = 0 ;
17579 bool result;
17580 void *argp1 = 0 ;
17581 int res1 = 0 ;
17582 bool temp2 = false ;
17583 bool temp3 = false ;
17584 PyObject * obj0 = 0 ;
17585 PyObject * obj1 = 0 ;
17586 PyObject * obj2 = 0 ;
17587 char * kwnames[] = {
17588 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17589 };
17590
17591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17593 if (!SWIG_IsOK(res1)) {
17594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17595 }
17596 arg1 = reinterpret_cast< wxImage * >(argp1);
17597 {
17598 arg2 = wxString_in_helper(obj1);
17599 if (arg2 == NULL) SWIG_fail;
17600 temp2 = true;
17601 }
17602 {
17603 arg3 = wxString_in_helper(obj2);
17604 if (arg3 == NULL) SWIG_fail;
17605 temp3 = true;
17606 }
17607 {
17608 PyThreadState* __tstate = wxPyBeginAllowThreads();
17609 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17610 wxPyEndAllowThreads(__tstate);
17611 if (PyErr_Occurred()) SWIG_fail;
17612 }
17613 {
17614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17615 }
17616 {
17617 if (temp2)
17618 delete arg2;
17619 }
17620 {
17621 if (temp3)
17622 delete arg3;
17623 }
17624 return resultobj;
17625fail:
17626 {
17627 if (temp2)
17628 delete arg2;
17629 }
17630 {
17631 if (temp3)
17632 delete arg3;
17633 }
17634 return NULL;
d55e5bfc
RD
17635}
17636
17637
1bd55598
RD
17638SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17639 PyObject *resultobj = 0;
17640 wxInputStream *arg1 = 0 ;
17641 bool result;
17642 wxPyInputStream *temp1 ;
17643 bool created1 ;
17644 PyObject * obj0 = 0 ;
17645 char * kwnames[] = {
17646 (char *) "stream", NULL
17647 };
17648
17649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17650 {
17651 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17652 arg1 = temp1->m_wxis;
17653 created1 = false;
17654 } else {
17655 PyErr_Clear(); // clear the failure of the wxPyConvert above
17656 arg1 = wxPyCBInputStream_create(obj0, false);
17657 if (arg1 == NULL) {
17658 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17659 SWIG_fail;
17660 }
17661 created1 = true;
d55e5bfc 17662 }
1bd55598
RD
17663 }
17664 {
17665 PyThreadState* __tstate = wxPyBeginAllowThreads();
17666 result = (bool)wxImage::CanRead(*arg1);
17667 wxPyEndAllowThreads(__tstate);
17668 if (PyErr_Occurred()) SWIG_fail;
17669 }
17670 {
17671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17672 }
17673 {
17674 if (created1) delete arg1;
17675 }
17676 return resultobj;
17677fail:
17678 {
17679 if (created1) delete arg1;
17680 }
17681 return NULL;
17682}
17683
17684
17685SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17686 PyObject *resultobj = 0;
17687 wxImage *arg1 = (wxImage *) 0 ;
17688 wxInputStream *arg2 = 0 ;
17689 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17690 int arg4 = (int) -1 ;
17691 bool result;
17692 void *argp1 = 0 ;
17693 int res1 = 0 ;
17694 wxPyInputStream *temp2 ;
17695 bool created2 ;
17696 long val3 ;
17697 int ecode3 = 0 ;
17698 int val4 ;
17699 int ecode4 = 0 ;
17700 PyObject * obj0 = 0 ;
17701 PyObject * obj1 = 0 ;
17702 PyObject * obj2 = 0 ;
17703 PyObject * obj3 = 0 ;
17704 char * kwnames[] = {
17705 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17706 };
17707
17708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17710 if (!SWIG_IsOK(res1)) {
17711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17712 }
17713 arg1 = reinterpret_cast< wxImage * >(argp1);
17714 {
17715 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17716 arg2 = temp2->m_wxis;
17717 created2 = false;
17718 } else {
17719 PyErr_Clear(); // clear the failure of the wxPyConvert above
17720 arg2 = wxPyCBInputStream_create(obj1, false);
17721 if (arg2 == NULL) {
17722 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17723 SWIG_fail;
17724 }
17725 created2 = true;
d55e5bfc 17726 }
1bd55598
RD
17727 }
17728 if (obj2) {
17729 ecode3 = SWIG_AsVal_long(obj2, &val3);
17730 if (!SWIG_IsOK(ecode3)) {
17731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17732 }
17733 arg3 = static_cast< long >(val3);
17734 }
17735 if (obj3) {
17736 ecode4 = SWIG_AsVal_int(obj3, &val4);
17737 if (!SWIG_IsOK(ecode4)) {
17738 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17739 }
17740 arg4 = static_cast< int >(val4);
17741 }
17742 {
17743 PyThreadState* __tstate = wxPyBeginAllowThreads();
17744 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17745 wxPyEndAllowThreads(__tstate);
17746 if (PyErr_Occurred()) SWIG_fail;
17747 }
17748 {
17749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17750 }
17751 {
17752 if (created2) delete arg2;
17753 }
17754 return resultobj;
17755fail:
17756 {
17757 if (created2) delete arg2;
17758 }
17759 return NULL;
17760}
17761
17762
17763SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17764 PyObject *resultobj = 0;
17765 wxImage *arg1 = (wxImage *) 0 ;
17766 wxInputStream *arg2 = 0 ;
17767 wxString *arg3 = 0 ;
17768 int arg4 = (int) -1 ;
17769 bool result;
17770 void *argp1 = 0 ;
17771 int res1 = 0 ;
17772 wxPyInputStream *temp2 ;
17773 bool created2 ;
17774 bool temp3 = false ;
17775 int val4 ;
17776 int ecode4 = 0 ;
17777 PyObject * obj0 = 0 ;
17778 PyObject * obj1 = 0 ;
17779 PyObject * obj2 = 0 ;
17780 PyObject * obj3 = 0 ;
17781 char * kwnames[] = {
17782 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17783 };
17784
17785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17787 if (!SWIG_IsOK(res1)) {
17788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17789 }
17790 arg1 = reinterpret_cast< wxImage * >(argp1);
17791 {
17792 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17793 arg2 = temp2->m_wxis;
17794 created2 = false;
17795 } else {
17796 PyErr_Clear(); // clear the failure of the wxPyConvert above
17797 arg2 = wxPyCBInputStream_create(obj1, false);
17798 if (arg2 == NULL) {
17799 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17800 SWIG_fail;
17801 }
17802 created2 = true;
17803 }
17804 }
17805 {
17806 arg3 = wxString_in_helper(obj2);
17807 if (arg3 == NULL) SWIG_fail;
17808 temp3 = true;
17809 }
17810 if (obj3) {
17811 ecode4 = SWIG_AsVal_int(obj3, &val4);
17812 if (!SWIG_IsOK(ecode4)) {
17813 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17814 }
17815 arg4 = static_cast< int >(val4);
17816 }
17817 {
17818 PyThreadState* __tstate = wxPyBeginAllowThreads();
17819 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17820 wxPyEndAllowThreads(__tstate);
17821 if (PyErr_Occurred()) SWIG_fail;
17822 }
17823 {
17824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17825 }
17826 {
17827 if (created2) delete arg2;
17828 }
17829 {
17830 if (temp3)
17831 delete arg3;
17832 }
17833 return resultobj;
17834fail:
17835 {
17836 if (created2) delete arg2;
17837 }
17838 {
17839 if (temp3)
17840 delete arg3;
17841 }
17842 return NULL;
d55e5bfc
RD
17843}
17844
17845
b39fe951 17846SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1bd55598
RD
17847 PyObject *resultobj = 0;
17848 wxImage *arg1 = (wxImage *) 0 ;
17849 bool result;
17850 void *argp1 = 0 ;
17851 int res1 = 0 ;
17852 PyObject *swig_obj[1] ;
17853
17854 if (!args) SWIG_fail;
17855 swig_obj[0] = args;
17856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17857 if (!SWIG_IsOK(res1)) {
b39fe951 17858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
1bd55598
RD
17859 }
17860 arg1 = reinterpret_cast< wxImage * >(argp1);
17861 {
17862 PyThreadState* __tstate = wxPyBeginAllowThreads();
b39fe951 17863 result = (bool)(arg1)->IsOk();
1bd55598
RD
17864 wxPyEndAllowThreads(__tstate);
17865 if (PyErr_Occurred()) SWIG_fail;
17866 }
17867 {
17868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17869 }
17870 return resultobj;
17871fail:
17872 return NULL;
d55e5bfc
RD
17873}
17874
17875
1bd55598
RD
17876SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17877 PyObject *resultobj = 0;
17878 wxImage *arg1 = (wxImage *) 0 ;
17879 int result;
17880 void *argp1 = 0 ;
17881 int res1 = 0 ;
17882 PyObject *swig_obj[1] ;
17883
17884 if (!args) SWIG_fail;
17885 swig_obj[0] = args;
17886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17887 if (!SWIG_IsOK(res1)) {
17888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17889 }
17890 arg1 = reinterpret_cast< wxImage * >(argp1);
17891 {
17892 PyThreadState* __tstate = wxPyBeginAllowThreads();
17893 result = (int)(arg1)->GetWidth();
17894 wxPyEndAllowThreads(__tstate);
17895 if (PyErr_Occurred()) SWIG_fail;
17896 }
17897 resultobj = SWIG_From_int(static_cast< int >(result));
17898 return resultobj;
17899fail:
17900 return NULL;
d55e5bfc
RD
17901}
17902
17903
1bd55598
RD
17904SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17905 PyObject *resultobj = 0;
17906 wxImage *arg1 = (wxImage *) 0 ;
17907 int result;
17908 void *argp1 = 0 ;
17909 int res1 = 0 ;
17910 PyObject *swig_obj[1] ;
17911
17912 if (!args) SWIG_fail;
17913 swig_obj[0] = args;
17914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17915 if (!SWIG_IsOK(res1)) {
17916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17917 }
17918 arg1 = reinterpret_cast< wxImage * >(argp1);
17919 {
17920 PyThreadState* __tstate = wxPyBeginAllowThreads();
17921 result = (int)(arg1)->GetHeight();
17922 wxPyEndAllowThreads(__tstate);
17923 if (PyErr_Occurred()) SWIG_fail;
17924 }
17925 resultobj = SWIG_From_int(static_cast< int >(result));
17926 return resultobj;
17927fail:
17928 return NULL;
d55e5bfc
RD
17929}
17930
17931
1bd55598
RD
17932SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17933 PyObject *resultobj = 0;
17934 wxImage *arg1 = (wxImage *) 0 ;
17935 wxSize result;
17936 void *argp1 = 0 ;
17937 int res1 = 0 ;
17938 PyObject *swig_obj[1] ;
17939
17940 if (!args) SWIG_fail;
17941 swig_obj[0] = args;
17942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17943 if (!SWIG_IsOK(res1)) {
17944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
17945 }
17946 arg1 = reinterpret_cast< wxImage * >(argp1);
17947 {
17948 PyThreadState* __tstate = wxPyBeginAllowThreads();
17949 result = wxImage_GetSize(arg1);
17950 wxPyEndAllowThreads(__tstate);
17951 if (PyErr_Occurred()) SWIG_fail;
17952 }
17953 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
17954 return resultobj;
17955fail:
17956 return NULL;
17957}
17958
17959
17960SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17961 PyObject *resultobj = 0;
17962 wxImage *arg1 = (wxImage *) 0 ;
17963 wxRect *arg2 = 0 ;
17964 SwigValueWrapper<wxImage > result;
17965 void *argp1 = 0 ;
17966 int res1 = 0 ;
17967 wxRect temp2 ;
17968 PyObject * obj0 = 0 ;
17969 PyObject * obj1 = 0 ;
17970 char * kwnames[] = {
17971 (char *) "self",(char *) "rect", NULL
17972 };
17973
17974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
17975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17976 if (!SWIG_IsOK(res1)) {
17977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
17978 }
17979 arg1 = reinterpret_cast< wxImage * >(argp1);
17980 {
17981 arg2 = &temp2;
17982 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17983 }
17984 {
17985 PyThreadState* __tstate = wxPyBeginAllowThreads();
17986 result = (arg1)->GetSubImage((wxRect const &)*arg2);
17987 wxPyEndAllowThreads(__tstate);
17988 if (PyErr_Occurred()) SWIG_fail;
17989 }
17990 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
17991 return resultobj;
17992fail:
17993 return NULL;
17994}
17995
17996
17997SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17998 PyObject *resultobj = 0;
17999 wxImage *arg1 = (wxImage *) 0 ;
18000 wxSize *arg2 = 0 ;
18001 wxPoint *arg3 = 0 ;
18002 int arg4 = (int) -1 ;
18003 int arg5 = (int) -1 ;
18004 int arg6 = (int) -1 ;
18005 SwigValueWrapper<wxImage > result;
18006 void *argp1 = 0 ;
18007 int res1 = 0 ;
18008 wxSize temp2 ;
18009 wxPoint temp3 ;
18010 int val4 ;
18011 int ecode4 = 0 ;
18012 int val5 ;
18013 int ecode5 = 0 ;
18014 int val6 ;
18015 int ecode6 = 0 ;
18016 PyObject * obj0 = 0 ;
18017 PyObject * obj1 = 0 ;
18018 PyObject * obj2 = 0 ;
18019 PyObject * obj3 = 0 ;
18020 PyObject * obj4 = 0 ;
18021 PyObject * obj5 = 0 ;
18022 char * kwnames[] = {
18023 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18024 };
18025
18026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18028 if (!SWIG_IsOK(res1)) {
18029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18030 }
18031 arg1 = reinterpret_cast< wxImage * >(argp1);
18032 {
18033 arg2 = &temp2;
18034 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18035 }
18036 {
18037 arg3 = &temp3;
18038 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18039 }
18040 if (obj3) {
18041 ecode4 = SWIG_AsVal_int(obj3, &val4);
18042 if (!SWIG_IsOK(ecode4)) {
18043 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18044 }
18045 arg4 = static_cast< int >(val4);
18046 }
18047 if (obj4) {
18048 ecode5 = SWIG_AsVal_int(obj4, &val5);
18049 if (!SWIG_IsOK(ecode5)) {
18050 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18051 }
18052 arg5 = static_cast< int >(val5);
18053 }
18054 if (obj5) {
18055 ecode6 = SWIG_AsVal_int(obj5, &val6);
18056 if (!SWIG_IsOK(ecode6)) {
18057 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18058 }
18059 arg6 = static_cast< int >(val6);
18060 }
18061 {
18062 PyThreadState* __tstate = wxPyBeginAllowThreads();
18063 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18064 wxPyEndAllowThreads(__tstate);
18065 if (PyErr_Occurred()) SWIG_fail;
18066 }
18067 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18068 return resultobj;
18069fail:
18070 return NULL;
d55e5bfc 18071}
1bd55598
RD
18072
18073
18074SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18075 PyObject *resultobj = 0;
18076 wxImage *arg1 = (wxImage *) 0 ;
18077 SwigValueWrapper<wxImage > result;
18078 void *argp1 = 0 ;
18079 int res1 = 0 ;
18080 PyObject *swig_obj[1] ;
18081
18082 if (!args) SWIG_fail;
18083 swig_obj[0] = args;
18084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18085 if (!SWIG_IsOK(res1)) {
18086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18087 }
18088 arg1 = reinterpret_cast< wxImage * >(argp1);
18089 {
18090 PyThreadState* __tstate = wxPyBeginAllowThreads();
18091 result = (arg1)->Copy();
18092 wxPyEndAllowThreads(__tstate);
18093 if (PyErr_Occurred()) SWIG_fail;
18094 }
18095 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18096 return resultobj;
18097fail:
18098 return NULL;
18099}
18100
18101
18102SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18103 PyObject *resultobj = 0;
18104 wxImage *arg1 = (wxImage *) 0 ;
18105 wxImage *arg2 = 0 ;
18106 int arg3 ;
18107 int arg4 ;
18108 void *argp1 = 0 ;
18109 int res1 = 0 ;
18110 void *argp2 = 0 ;
18111 int res2 = 0 ;
18112 int val3 ;
18113 int ecode3 = 0 ;
18114 int val4 ;
18115 int ecode4 = 0 ;
18116 PyObject * obj0 = 0 ;
18117 PyObject * obj1 = 0 ;
18118 PyObject * obj2 = 0 ;
18119 PyObject * obj3 = 0 ;
18120 char * kwnames[] = {
18121 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18122 };
18123
18124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18126 if (!SWIG_IsOK(res1)) {
18127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18128 }
18129 arg1 = reinterpret_cast< wxImage * >(argp1);
18130 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18131 if (!SWIG_IsOK(res2)) {
18132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18133 }
18134 if (!argp2) {
18135 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18136 }
18137 arg2 = reinterpret_cast< wxImage * >(argp2);
18138 ecode3 = SWIG_AsVal_int(obj2, &val3);
18139 if (!SWIG_IsOK(ecode3)) {
18140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18141 }
18142 arg3 = static_cast< int >(val3);
18143 ecode4 = SWIG_AsVal_int(obj3, &val4);
18144 if (!SWIG_IsOK(ecode4)) {
18145 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18146 }
18147 arg4 = static_cast< int >(val4);
18148 {
18149 PyThreadState* __tstate = wxPyBeginAllowThreads();
18150 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18151 wxPyEndAllowThreads(__tstate);
18152 if (PyErr_Occurred()) SWIG_fail;
18153 }
18154 resultobj = SWIG_Py_Void();
18155 return resultobj;
18156fail:
18157 return NULL;
d55e5bfc
RD
18158}
18159
18160
1bd55598
RD
18161SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18162 PyObject *resultobj = 0;
18163 wxImage *arg1 = (wxImage *) 0 ;
18164 PyObject *result = 0 ;
18165 void *argp1 = 0 ;
18166 int res1 = 0 ;
18167 PyObject *swig_obj[1] ;
18168
18169 if (!args) SWIG_fail;
18170 swig_obj[0] = args;
18171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18172 if (!SWIG_IsOK(res1)) {
18173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18174 }
18175 arg1 = reinterpret_cast< wxImage * >(argp1);
18176 {
18177 PyThreadState* __tstate = wxPyBeginAllowThreads();
18178 result = (PyObject *)wxImage_GetData(arg1);
18179 wxPyEndAllowThreads(__tstate);
18180 if (PyErr_Occurred()) SWIG_fail;
18181 }
18182 resultobj = result;
18183 return resultobj;
18184fail:
18185 return NULL;
18186}
18187
18188
18189SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18190 PyObject *resultobj = 0;
18191 wxImage *arg1 = (wxImage *) 0 ;
18192 buffer arg2 ;
18193 int arg3 ;
18194 void *argp1 = 0 ;
18195 int res1 = 0 ;
8c9c423b 18196 Py_ssize_t temp2 ;
1bd55598
RD
18197 PyObject * obj0 = 0 ;
18198 PyObject * obj1 = 0 ;
18199 char * kwnames[] = {
18200 (char *) "self",(char *) "data", NULL
18201 };
18202
18203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18205 if (!SWIG_IsOK(res1)) {
18206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18207 }
18208 arg1 = reinterpret_cast< wxImage * >(argp1);
18209 {
8c9c423b
RD
18210 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18211 arg3 = (int)temp2;
1bd55598
RD
18212 }
18213 {
18214 PyThreadState* __tstate = wxPyBeginAllowThreads();
18215 wxImage_SetData(arg1,arg2,arg3);
18216 wxPyEndAllowThreads(__tstate);
18217 if (PyErr_Occurred()) SWIG_fail;
18218 }
18219 resultobj = SWIG_Py_Void();
18220 return resultobj;
18221fail:
18222 return NULL;
d55e5bfc
RD
18223}
18224
18225
1bd55598
RD
18226SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18227 PyObject *resultobj = 0;
18228 wxImage *arg1 = (wxImage *) 0 ;
18229 PyObject *result = 0 ;
18230 void *argp1 = 0 ;
18231 int res1 = 0 ;
18232 PyObject *swig_obj[1] ;
18233
18234 if (!args) SWIG_fail;
18235 swig_obj[0] = args;
18236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18237 if (!SWIG_IsOK(res1)) {
18238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18239 }
18240 arg1 = reinterpret_cast< wxImage * >(argp1);
18241 {
18242 PyThreadState* __tstate = wxPyBeginAllowThreads();
18243 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18244 wxPyEndAllowThreads(__tstate);
18245 if (PyErr_Occurred()) SWIG_fail;
18246 }
18247 resultobj = result;
18248 return resultobj;
18249fail:
18250 return NULL;
18251}
18252
18253
18254SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18255 PyObject *resultobj = 0;
18256 wxImage *arg1 = (wxImage *) 0 ;
18257 buffer arg2 ;
18258 int arg3 ;
18259 void *argp1 = 0 ;
18260 int res1 = 0 ;
8c9c423b 18261 Py_ssize_t temp2 ;
1bd55598
RD
18262 PyObject * obj0 = 0 ;
18263 PyObject * obj1 = 0 ;
18264 char * kwnames[] = {
18265 (char *) "self",(char *) "data", NULL
18266 };
18267
18268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18270 if (!SWIG_IsOK(res1)) {
18271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18272 }
18273 arg1 = reinterpret_cast< wxImage * >(argp1);
18274 {
8c9c423b
RD
18275 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18276 arg3 = (int)temp2;
1bd55598
RD
18277 }
18278 {
18279 PyThreadState* __tstate = wxPyBeginAllowThreads();
18280 wxImage_SetDataBuffer(arg1,arg2,arg3);
18281 wxPyEndAllowThreads(__tstate);
18282 if (PyErr_Occurred()) SWIG_fail;
18283 }
18284 resultobj = SWIG_Py_Void();
18285 return resultobj;
18286fail:
18287 return NULL;
d55e5bfc
RD
18288}
18289
18290
1bd55598
RD
18291SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18292 PyObject *resultobj = 0;
18293 wxImage *arg1 = (wxImage *) 0 ;
18294 PyObject *result = 0 ;
18295 void *argp1 = 0 ;
18296 int res1 = 0 ;
18297 PyObject *swig_obj[1] ;
18298
18299 if (!args) SWIG_fail;
18300 swig_obj[0] = args;
18301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18302 if (!SWIG_IsOK(res1)) {
18303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18304 }
18305 arg1 = reinterpret_cast< wxImage * >(argp1);
18306 {
18307 PyThreadState* __tstate = wxPyBeginAllowThreads();
18308 result = (PyObject *)wxImage_GetAlphaData(arg1);
18309 wxPyEndAllowThreads(__tstate);
18310 if (PyErr_Occurred()) SWIG_fail;
18311 }
18312 resultobj = result;
18313 return resultobj;
18314fail:
18315 return NULL;
18316}
18317
18318
18319SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18320 PyObject *resultobj = 0;
18321 wxImage *arg1 = (wxImage *) 0 ;
18322 buffer arg2 ;
18323 int arg3 ;
18324 void *argp1 = 0 ;
18325 int res1 = 0 ;
8c9c423b 18326 Py_ssize_t temp2 ;
1bd55598
RD
18327 PyObject * obj0 = 0 ;
18328 PyObject * obj1 = 0 ;
18329 char * kwnames[] = {
18330 (char *) "self",(char *) "alpha", NULL
18331 };
18332
18333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18335 if (!SWIG_IsOK(res1)) {
18336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18337 }
18338 arg1 = reinterpret_cast< wxImage * >(argp1);
18339 {
fc46b7f3 18340 if (obj1 != Py_None) {
8c9c423b
RD
18341 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18342 arg3 = (int)temp2;
fc46b7f3 18343 }
1bd55598
RD
18344 }
18345 {
18346 PyThreadState* __tstate = wxPyBeginAllowThreads();
18347 wxImage_SetAlphaData(arg1,arg2,arg3);
18348 wxPyEndAllowThreads(__tstate);
18349 if (PyErr_Occurred()) SWIG_fail;
18350 }
18351 resultobj = SWIG_Py_Void();
18352 return resultobj;
18353fail:
18354 return NULL;
d55e5bfc
RD
18355}
18356
18357
1bd55598
RD
18358SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18359 PyObject *resultobj = 0;
18360 wxImage *arg1 = (wxImage *) 0 ;
18361 PyObject *result = 0 ;
18362 void *argp1 = 0 ;
18363 int res1 = 0 ;
18364 PyObject *swig_obj[1] ;
18365
18366 if (!args) SWIG_fail;
18367 swig_obj[0] = args;
18368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18369 if (!SWIG_IsOK(res1)) {
18370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18371 }
18372 arg1 = reinterpret_cast< wxImage * >(argp1);
18373 {
18374 PyThreadState* __tstate = wxPyBeginAllowThreads();
18375 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18376 wxPyEndAllowThreads(__tstate);
18377 if (PyErr_Occurred()) SWIG_fail;
18378 }
18379 resultobj = result;
18380 return resultobj;
18381fail:
18382 return NULL;
18383}
18384
18385
18386SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18387 PyObject *resultobj = 0;
18388 wxImage *arg1 = (wxImage *) 0 ;
18389 buffer arg2 ;
18390 int arg3 ;
18391 void *argp1 = 0 ;
18392 int res1 = 0 ;
8c9c423b 18393 Py_ssize_t temp2 ;
1bd55598
RD
18394 PyObject * obj0 = 0 ;
18395 PyObject * obj1 = 0 ;
18396 char * kwnames[] = {
18397 (char *) "self",(char *) "alpha", NULL
18398 };
18399
18400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18402 if (!SWIG_IsOK(res1)) {
18403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18404 }
18405 arg1 = reinterpret_cast< wxImage * >(argp1);
18406 {
fc46b7f3 18407 if (obj1 != Py_None) {
8c9c423b
RD
18408 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18409 arg3 = (int)temp2;
fc46b7f3 18410 }
1bd55598
RD
18411 }
18412 {
18413 PyThreadState* __tstate = wxPyBeginAllowThreads();
18414 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18415 wxPyEndAllowThreads(__tstate);
18416 if (PyErr_Occurred()) SWIG_fail;
18417 }
18418 resultobj = SWIG_Py_Void();
18419 return resultobj;
18420fail:
18421 return NULL;
18422}
18423
18424
18425SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18426 PyObject *resultobj = 0;
18427 wxImage *arg1 = (wxImage *) 0 ;
18428 byte arg2 ;
18429 byte arg3 ;
18430 byte arg4 ;
18431 void *argp1 = 0 ;
18432 int res1 = 0 ;
18433 unsigned char val2 ;
18434 int ecode2 = 0 ;
18435 unsigned char val3 ;
18436 int ecode3 = 0 ;
18437 unsigned char val4 ;
18438 int ecode4 = 0 ;
18439 PyObject * obj0 = 0 ;
18440 PyObject * obj1 = 0 ;
18441 PyObject * obj2 = 0 ;
18442 PyObject * obj3 = 0 ;
18443 char * kwnames[] = {
18444 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18445 };
18446
18447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18449 if (!SWIG_IsOK(res1)) {
18450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18451 }
18452 arg1 = reinterpret_cast< wxImage * >(argp1);
18453 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18454 if (!SWIG_IsOK(ecode2)) {
18455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18456 }
18457 arg2 = static_cast< byte >(val2);
18458 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18459 if (!SWIG_IsOK(ecode3)) {
18460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18461 }
18462 arg3 = static_cast< byte >(val3);
18463 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18464 if (!SWIG_IsOK(ecode4)) {
18465 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18466 }
18467 arg4 = static_cast< byte >(val4);
18468 {
18469 PyThreadState* __tstate = wxPyBeginAllowThreads();
18470 (arg1)->SetMaskColour(arg2,arg3,arg4);
18471 wxPyEndAllowThreads(__tstate);
18472 if (PyErr_Occurred()) SWIG_fail;
18473 }
18474 resultobj = SWIG_Py_Void();
18475 return resultobj;
18476fail:
18477 return NULL;
18478}
18479
18480
18481SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18482 PyObject *resultobj = 0;
18483 wxImage *arg1 = (wxImage *) 0 ;
18484 byte *arg2 = (byte *) 0 ;
18485 byte *arg3 = (byte *) 0 ;
18486 byte *arg4 = (byte *) 0 ;
18487 void *argp1 = 0 ;
18488 int res1 = 0 ;
18489 byte temp2 ;
18490 int res2 = SWIG_TMPOBJ ;
18491 byte temp3 ;
18492 int res3 = SWIG_TMPOBJ ;
18493 byte temp4 ;
18494 int res4 = SWIG_TMPOBJ ;
18495 PyObject *swig_obj[1] ;
18496
18497 arg2 = &temp2;
18498 arg3 = &temp3;
18499 arg4 = &temp4;
18500 if (!args) SWIG_fail;
18501 swig_obj[0] = args;
18502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18503 if (!SWIG_IsOK(res1)) {
18504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18505 }
18506 arg1 = reinterpret_cast< wxImage * >(argp1);
18507 {
18508 PyThreadState* __tstate = wxPyBeginAllowThreads();
18509 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18510 wxPyEndAllowThreads(__tstate);
18511 if (PyErr_Occurred()) SWIG_fail;
18512 }
18513 resultobj = SWIG_Py_Void();
18514 if (SWIG_IsTmpObj(res2)) {
18515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18516 } else {
18517 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18518 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18519 }
18520 if (SWIG_IsTmpObj(res3)) {
18521 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18522 } else {
18523 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18524 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18525 }
18526 if (SWIG_IsTmpObj(res4)) {
18527 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18528 } else {
18529 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18530 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18531 }
18532 return resultobj;
18533fail:
18534 return NULL;
d55e5bfc
RD
18535}
18536
18537
1bd55598
RD
18538SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18539 PyObject *resultobj = 0;
18540 wxImage *arg1 = (wxImage *) 0 ;
18541 byte result;
18542 void *argp1 = 0 ;
18543 int res1 = 0 ;
18544 PyObject *swig_obj[1] ;
18545
18546 if (!args) SWIG_fail;
18547 swig_obj[0] = args;
18548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18549 if (!SWIG_IsOK(res1)) {
18550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18551 }
18552 arg1 = reinterpret_cast< wxImage * >(argp1);
18553 {
18554 PyThreadState* __tstate = wxPyBeginAllowThreads();
18555 result = (byte)(arg1)->GetMaskRed();
18556 wxPyEndAllowThreads(__tstate);
18557 if (PyErr_Occurred()) SWIG_fail;
18558 }
18559 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18560 return resultobj;
18561fail:
18562 return NULL;
d55e5bfc
RD
18563}
18564
18565
1bd55598
RD
18566SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18567 PyObject *resultobj = 0;
18568 wxImage *arg1 = (wxImage *) 0 ;
18569 byte result;
18570 void *argp1 = 0 ;
18571 int res1 = 0 ;
18572 PyObject *swig_obj[1] ;
18573
18574 if (!args) SWIG_fail;
18575 swig_obj[0] = args;
18576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18577 if (!SWIG_IsOK(res1)) {
18578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18579 }
18580 arg1 = reinterpret_cast< wxImage * >(argp1);
18581 {
18582 PyThreadState* __tstate = wxPyBeginAllowThreads();
18583 result = (byte)(arg1)->GetMaskGreen();
18584 wxPyEndAllowThreads(__tstate);
18585 if (PyErr_Occurred()) SWIG_fail;
18586 }
18587 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18588 return resultobj;
18589fail:
18590 return NULL;
d55e5bfc
RD
18591}
18592
18593
1bd55598
RD
18594SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18595 PyObject *resultobj = 0;
18596 wxImage *arg1 = (wxImage *) 0 ;
18597 byte result;
18598 void *argp1 = 0 ;
18599 int res1 = 0 ;
18600 PyObject *swig_obj[1] ;
18601
18602 if (!args) SWIG_fail;
18603 swig_obj[0] = args;
18604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18605 if (!SWIG_IsOK(res1)) {
18606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18607 }
18608 arg1 = reinterpret_cast< wxImage * >(argp1);
18609 {
18610 PyThreadState* __tstate = wxPyBeginAllowThreads();
18611 result = (byte)(arg1)->GetMaskBlue();
18612 wxPyEndAllowThreads(__tstate);
18613 if (PyErr_Occurred()) SWIG_fail;
18614 }
18615 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18616 return resultobj;
18617fail:
18618 return NULL;
18619}
18620
18621
18622SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18623 PyObject *resultobj = 0;
18624 wxImage *arg1 = (wxImage *) 0 ;
18625 bool arg2 = (bool) true ;
18626 void *argp1 = 0 ;
18627 int res1 = 0 ;
18628 bool val2 ;
18629 int ecode2 = 0 ;
18630 PyObject * obj0 = 0 ;
18631 PyObject * obj1 = 0 ;
18632 char * kwnames[] = {
18633 (char *) "self",(char *) "mask", NULL
18634 };
18635
18636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18638 if (!SWIG_IsOK(res1)) {
18639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18640 }
18641 arg1 = reinterpret_cast< wxImage * >(argp1);
18642 if (obj1) {
18643 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18644 if (!SWIG_IsOK(ecode2)) {
18645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18646 }
18647 arg2 = static_cast< bool >(val2);
18648 }
18649 {
18650 PyThreadState* __tstate = wxPyBeginAllowThreads();
18651 (arg1)->SetMask(arg2);
18652 wxPyEndAllowThreads(__tstate);
18653 if (PyErr_Occurred()) SWIG_fail;
18654 }
18655 resultobj = SWIG_Py_Void();
18656 return resultobj;
18657fail:
18658 return NULL;
d55e5bfc
RD
18659}
18660
18661
1bd55598
RD
18662SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18663 PyObject *resultobj = 0;
18664 wxImage *arg1 = (wxImage *) 0 ;
18665 bool result;
18666 void *argp1 = 0 ;
18667 int res1 = 0 ;
18668 PyObject *swig_obj[1] ;
18669
18670 if (!args) SWIG_fail;
18671 swig_obj[0] = args;
18672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18673 if (!SWIG_IsOK(res1)) {
18674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18675 }
18676 arg1 = reinterpret_cast< wxImage * >(argp1);
18677 {
18678 PyThreadState* __tstate = wxPyBeginAllowThreads();
18679 result = (bool)(arg1)->HasMask();
18680 wxPyEndAllowThreads(__tstate);
18681 if (PyErr_Occurred()) SWIG_fail;
18682 }
18683 {
18684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18685 }
18686 return resultobj;
18687fail:
18688 return NULL;
18689}
18690
18691
18692SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18693 PyObject *resultobj = 0;
18694 wxImage *arg1 = (wxImage *) 0 ;
18695 double arg2 ;
18696 wxPoint *arg3 = 0 ;
18697 bool arg4 = (bool) true ;
18698 wxPoint *arg5 = (wxPoint *) NULL ;
18699 SwigValueWrapper<wxImage > result;
18700 void *argp1 = 0 ;
18701 int res1 = 0 ;
18702 double val2 ;
18703 int ecode2 = 0 ;
18704 wxPoint temp3 ;
18705 bool val4 ;
18706 int ecode4 = 0 ;
18707 void *argp5 = 0 ;
18708 int res5 = 0 ;
18709 PyObject * obj0 = 0 ;
18710 PyObject * obj1 = 0 ;
18711 PyObject * obj2 = 0 ;
18712 PyObject * obj3 = 0 ;
18713 PyObject * obj4 = 0 ;
18714 char * kwnames[] = {
18715 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18716 };
18717
18718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18720 if (!SWIG_IsOK(res1)) {
18721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18722 }
18723 arg1 = reinterpret_cast< wxImage * >(argp1);
18724 ecode2 = SWIG_AsVal_double(obj1, &val2);
18725 if (!SWIG_IsOK(ecode2)) {
18726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18727 }
18728 arg2 = static_cast< double >(val2);
18729 {
18730 arg3 = &temp3;
18731 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18732 }
18733 if (obj3) {
18734 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18735 if (!SWIG_IsOK(ecode4)) {
18736 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18737 }
18738 arg4 = static_cast< bool >(val4);
18739 }
18740 if (obj4) {
18741 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18742 if (!SWIG_IsOK(res5)) {
18743 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
d55e5bfc 18744 }
1bd55598
RD
18745 arg5 = reinterpret_cast< wxPoint * >(argp5);
18746 }
18747 {
18748 PyThreadState* __tstate = wxPyBeginAllowThreads();
18749 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18750 wxPyEndAllowThreads(__tstate);
18751 if (PyErr_Occurred()) SWIG_fail;
18752 }
18753 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18754 return resultobj;
18755fail:
18756 return NULL;
18757}
18758
18759
18760SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18761 PyObject *resultobj = 0;
18762 wxImage *arg1 = (wxImage *) 0 ;
18763 bool arg2 = (bool) true ;
18764 SwigValueWrapper<wxImage > result;
18765 void *argp1 = 0 ;
18766 int res1 = 0 ;
18767 bool val2 ;
18768 int ecode2 = 0 ;
18769 PyObject * obj0 = 0 ;
18770 PyObject * obj1 = 0 ;
18771 char * kwnames[] = {
18772 (char *) "self",(char *) "clockwise", NULL
18773 };
18774
18775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18777 if (!SWIG_IsOK(res1)) {
18778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18779 }
18780 arg1 = reinterpret_cast< wxImage * >(argp1);
18781 if (obj1) {
18782 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18783 if (!SWIG_IsOK(ecode2)) {
18784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18785 }
18786 arg2 = static_cast< bool >(val2);
18787 }
18788 {
18789 PyThreadState* __tstate = wxPyBeginAllowThreads();
18790 result = (arg1)->Rotate90(arg2);
18791 wxPyEndAllowThreads(__tstate);
18792 if (PyErr_Occurred()) SWIG_fail;
18793 }
18794 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18795 return resultobj;
18796fail:
18797 return NULL;
18798}
18799
18800
18801SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18802 PyObject *resultobj = 0;
18803 wxImage *arg1 = (wxImage *) 0 ;
18804 bool arg2 = (bool) true ;
18805 SwigValueWrapper<wxImage > result;
18806 void *argp1 = 0 ;
18807 int res1 = 0 ;
18808 bool val2 ;
18809 int ecode2 = 0 ;
18810 PyObject * obj0 = 0 ;
18811 PyObject * obj1 = 0 ;
18812 char * kwnames[] = {
18813 (char *) "self",(char *) "horizontally", NULL
18814 };
18815
18816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18818 if (!SWIG_IsOK(res1)) {
18819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18820 }
18821 arg1 = reinterpret_cast< wxImage * >(argp1);
18822 if (obj1) {
18823 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18824 if (!SWIG_IsOK(ecode2)) {
18825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18826 }
18827 arg2 = static_cast< bool >(val2);
18828 }
18829 {
18830 PyThreadState* __tstate = wxPyBeginAllowThreads();
18831 result = (arg1)->Mirror(arg2);
18832 wxPyEndAllowThreads(__tstate);
18833 if (PyErr_Occurred()) SWIG_fail;
18834 }
18835 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18836 return resultobj;
18837fail:
18838 return NULL;
18839}
18840
18841
18842SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18843 PyObject *resultobj = 0;
18844 wxImage *arg1 = (wxImage *) 0 ;
18845 byte arg2 ;
18846 byte arg3 ;
18847 byte arg4 ;
18848 byte arg5 ;
18849 byte arg6 ;
18850 byte arg7 ;
18851 void *argp1 = 0 ;
18852 int res1 = 0 ;
18853 unsigned char val2 ;
18854 int ecode2 = 0 ;
18855 unsigned char val3 ;
18856 int ecode3 = 0 ;
18857 unsigned char val4 ;
18858 int ecode4 = 0 ;
18859 unsigned char val5 ;
18860 int ecode5 = 0 ;
18861 unsigned char val6 ;
18862 int ecode6 = 0 ;
18863 unsigned char val7 ;
18864 int ecode7 = 0 ;
18865 PyObject * obj0 = 0 ;
18866 PyObject * obj1 = 0 ;
18867 PyObject * obj2 = 0 ;
18868 PyObject * obj3 = 0 ;
18869 PyObject * obj4 = 0 ;
18870 PyObject * obj5 = 0 ;
18871 PyObject * obj6 = 0 ;
18872 char * kwnames[] = {
18873 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18874 };
18875
18876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18878 if (!SWIG_IsOK(res1)) {
18879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18880 }
18881 arg1 = reinterpret_cast< wxImage * >(argp1);
18882 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18883 if (!SWIG_IsOK(ecode2)) {
18884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18885 }
18886 arg2 = static_cast< byte >(val2);
18887 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18888 if (!SWIG_IsOK(ecode3)) {
18889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18890 }
18891 arg3 = static_cast< byte >(val3);
18892 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18893 if (!SWIG_IsOK(ecode4)) {
18894 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18895 }
18896 arg4 = static_cast< byte >(val4);
18897 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18898 if (!SWIG_IsOK(ecode5)) {
18899 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18900 }
18901 arg5 = static_cast< byte >(val5);
18902 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18903 if (!SWIG_IsOK(ecode6)) {
18904 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18905 }
18906 arg6 = static_cast< byte >(val6);
18907 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18908 if (!SWIG_IsOK(ecode7)) {
18909 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18910 }
18911 arg7 = static_cast< byte >(val7);
18912 {
18913 PyThreadState* __tstate = wxPyBeginAllowThreads();
18914 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18915 wxPyEndAllowThreads(__tstate);
18916 if (PyErr_Occurred()) SWIG_fail;
18917 }
18918 resultobj = SWIG_Py_Void();
18919 return resultobj;
18920fail:
18921 return NULL;
18922}
18923
18924
18925SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18926 PyObject *resultobj = 0;
18927 wxImage *arg1 = (wxImage *) 0 ;
18928 double arg2 = (double) 0.299 ;
18929 double arg3 = (double) 0.587 ;
18930 double arg4 = (double) 0.114 ;
18931 SwigValueWrapper<wxImage > result;
18932 void *argp1 = 0 ;
18933 int res1 = 0 ;
18934 double val2 ;
18935 int ecode2 = 0 ;
18936 double val3 ;
18937 int ecode3 = 0 ;
18938 double val4 ;
18939 int ecode4 = 0 ;
18940 PyObject * obj0 = 0 ;
18941 PyObject * obj1 = 0 ;
18942 PyObject * obj2 = 0 ;
18943 PyObject * obj3 = 0 ;
18944 char * kwnames[] = {
18945 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
18946 };
18947
18948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18950 if (!SWIG_IsOK(res1)) {
18951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
18952 }
18953 arg1 = reinterpret_cast< wxImage * >(argp1);
18954 if (obj1) {
18955 ecode2 = SWIG_AsVal_double(obj1, &val2);
18956 if (!SWIG_IsOK(ecode2)) {
18957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
18958 }
18959 arg2 = static_cast< double >(val2);
18960 }
18961 if (obj2) {
18962 ecode3 = SWIG_AsVal_double(obj2, &val3);
18963 if (!SWIG_IsOK(ecode3)) {
18964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
18965 }
18966 arg3 = static_cast< double >(val3);
18967 }
18968 if (obj3) {
18969 ecode4 = SWIG_AsVal_double(obj3, &val4);
18970 if (!SWIG_IsOK(ecode4)) {
18971 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
18972 }
18973 arg4 = static_cast< double >(val4);
18974 }
18975 {
18976 PyThreadState* __tstate = wxPyBeginAllowThreads();
18977 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
18978 wxPyEndAllowThreads(__tstate);
18979 if (PyErr_Occurred()) SWIG_fail;
18980 }
18981 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18982 return resultobj;
18983fail:
18984 return NULL;
18985}
18986
18987
18988SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18989 PyObject *resultobj = 0;
18990 wxImage *arg1 = (wxImage *) 0 ;
18991 byte arg2 ;
18992 byte arg3 ;
18993 byte arg4 ;
18994 SwigValueWrapper<wxImage > result;
18995 void *argp1 = 0 ;
18996 int res1 = 0 ;
18997 unsigned char val2 ;
18998 int ecode2 = 0 ;
18999 unsigned char val3 ;
19000 int ecode3 = 0 ;
19001 unsigned char val4 ;
19002 int ecode4 = 0 ;
19003 PyObject * obj0 = 0 ;
19004 PyObject * obj1 = 0 ;
19005 PyObject * obj2 = 0 ;
19006 PyObject * obj3 = 0 ;
19007 char * kwnames[] = {
19008 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19009 };
19010
19011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19013 if (!SWIG_IsOK(res1)) {
19014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19015 }
19016 arg1 = reinterpret_cast< wxImage * >(argp1);
19017 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19018 if (!SWIG_IsOK(ecode2)) {
19019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19020 }
19021 arg2 = static_cast< byte >(val2);
19022 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19023 if (!SWIG_IsOK(ecode3)) {
19024 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19025 }
19026 arg3 = static_cast< byte >(val3);
19027 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19028 if (!SWIG_IsOK(ecode4)) {
19029 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19030 }
19031 arg4 = static_cast< byte >(val4);
19032 {
19033 PyThreadState* __tstate = wxPyBeginAllowThreads();
19034 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19035 wxPyEndAllowThreads(__tstate);
19036 if (PyErr_Occurred()) SWIG_fail;
19037 }
19038 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19039 return resultobj;
19040fail:
19041 return NULL;
19042}
19043
19044
19045SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19046 PyObject *resultobj = 0;
19047 wxImage *arg1 = (wxImage *) 0 ;
19048 wxString *arg2 = 0 ;
19049 wxString *arg3 = 0 ;
19050 void *argp1 = 0 ;
19051 int res1 = 0 ;
19052 bool temp2 = false ;
19053 bool temp3 = false ;
19054 PyObject * obj0 = 0 ;
19055 PyObject * obj1 = 0 ;
19056 PyObject * obj2 = 0 ;
19057 char * kwnames[] = {
19058 (char *) "self",(char *) "name",(char *) "value", NULL
19059 };
19060
19061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19063 if (!SWIG_IsOK(res1)) {
19064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19065 }
19066 arg1 = reinterpret_cast< wxImage * >(argp1);
19067 {
19068 arg2 = wxString_in_helper(obj1);
19069 if (arg2 == NULL) SWIG_fail;
19070 temp2 = true;
19071 }
19072 {
19073 arg3 = wxString_in_helper(obj2);
19074 if (arg3 == NULL) SWIG_fail;
19075 temp3 = true;
19076 }
19077 {
19078 PyThreadState* __tstate = wxPyBeginAllowThreads();
19079 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19080 wxPyEndAllowThreads(__tstate);
19081 if (PyErr_Occurred()) SWIG_fail;
19082 }
19083 resultobj = SWIG_Py_Void();
19084 {
19085 if (temp2)
19086 delete arg2;
19087 }
19088 {
19089 if (temp3)
19090 delete arg3;
19091 }
19092 return resultobj;
19093fail:
19094 {
19095 if (temp2)
19096 delete arg2;
19097 }
19098 {
19099 if (temp3)
19100 delete arg3;
19101 }
19102 return NULL;
19103}
19104
19105
19106SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19107 PyObject *resultobj = 0;
19108 wxImage *arg1 = (wxImage *) 0 ;
19109 wxString *arg2 = 0 ;
19110 int arg3 ;
19111 void *argp1 = 0 ;
19112 int res1 = 0 ;
19113 bool temp2 = false ;
19114 int val3 ;
19115 int ecode3 = 0 ;
19116 PyObject * obj0 = 0 ;
19117 PyObject * obj1 = 0 ;
19118 PyObject * obj2 = 0 ;
19119 char * kwnames[] = {
19120 (char *) "self",(char *) "name",(char *) "value", NULL
19121 };
19122
19123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19125 if (!SWIG_IsOK(res1)) {
19126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19127 }
19128 arg1 = reinterpret_cast< wxImage * >(argp1);
19129 {
19130 arg2 = wxString_in_helper(obj1);
19131 if (arg2 == NULL) SWIG_fail;
19132 temp2 = true;
19133 }
19134 ecode3 = SWIG_AsVal_int(obj2, &val3);
19135 if (!SWIG_IsOK(ecode3)) {
19136 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19137 }
19138 arg3 = static_cast< int >(val3);
19139 {
19140 PyThreadState* __tstate = wxPyBeginAllowThreads();
19141 (arg1)->SetOption((wxString const &)*arg2,arg3);
19142 wxPyEndAllowThreads(__tstate);
19143 if (PyErr_Occurred()) SWIG_fail;
19144 }
19145 resultobj = SWIG_Py_Void();
19146 {
19147 if (temp2)
19148 delete arg2;
19149 }
19150 return resultobj;
19151fail:
19152 {
19153 if (temp2)
19154 delete arg2;
19155 }
19156 return NULL;
19157}
19158
19159
19160SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19161 PyObject *resultobj = 0;
19162 wxImage *arg1 = (wxImage *) 0 ;
19163 wxString *arg2 = 0 ;
19164 wxString result;
19165 void *argp1 = 0 ;
19166 int res1 = 0 ;
19167 bool temp2 = false ;
19168 PyObject * obj0 = 0 ;
19169 PyObject * obj1 = 0 ;
19170 char * kwnames[] = {
19171 (char *) "self",(char *) "name", NULL
19172 };
19173
19174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19176 if (!SWIG_IsOK(res1)) {
19177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19178 }
19179 arg1 = reinterpret_cast< wxImage * >(argp1);
19180 {
19181 arg2 = wxString_in_helper(obj1);
19182 if (arg2 == NULL) SWIG_fail;
19183 temp2 = true;
19184 }
19185 {
19186 PyThreadState* __tstate = wxPyBeginAllowThreads();
19187 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19188 wxPyEndAllowThreads(__tstate);
19189 if (PyErr_Occurred()) SWIG_fail;
19190 }
19191 {
d55e5bfc 19192#if wxUSE_UNICODE
1bd55598 19193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
d55e5bfc 19194#else
1bd55598 19195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
d55e5bfc 19196#endif
1bd55598
RD
19197 }
19198 {
19199 if (temp2)
19200 delete arg2;
19201 }
19202 return resultobj;
19203fail:
19204 {
19205 if (temp2)
19206 delete arg2;
19207 }
19208 return NULL;
19209}
19210
19211
19212SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19213 PyObject *resultobj = 0;
19214 wxImage *arg1 = (wxImage *) 0 ;
19215 wxString *arg2 = 0 ;
19216 int result;
19217 void *argp1 = 0 ;
19218 int res1 = 0 ;
19219 bool temp2 = false ;
19220 PyObject * obj0 = 0 ;
19221 PyObject * obj1 = 0 ;
19222 char * kwnames[] = {
19223 (char *) "self",(char *) "name", NULL
19224 };
19225
19226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19228 if (!SWIG_IsOK(res1)) {
19229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19230 }
19231 arg1 = reinterpret_cast< wxImage * >(argp1);
19232 {
19233 arg2 = wxString_in_helper(obj1);
19234 if (arg2 == NULL) SWIG_fail;
19235 temp2 = true;
19236 }
19237 {
19238 PyThreadState* __tstate = wxPyBeginAllowThreads();
19239 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19240 wxPyEndAllowThreads(__tstate);
19241 if (PyErr_Occurred()) SWIG_fail;
19242 }
19243 resultobj = SWIG_From_int(static_cast< int >(result));
19244 {
19245 if (temp2)
19246 delete arg2;
19247 }
19248 return resultobj;
19249fail:
19250 {
19251 if (temp2)
19252 delete arg2;
19253 }
19254 return NULL;
19255}
19256
19257
19258SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19259 PyObject *resultobj = 0;
19260 wxImage *arg1 = (wxImage *) 0 ;
19261 wxString *arg2 = 0 ;
19262 bool result;
19263 void *argp1 = 0 ;
19264 int res1 = 0 ;
19265 bool temp2 = false ;
19266 PyObject * obj0 = 0 ;
19267 PyObject * obj1 = 0 ;
19268 char * kwnames[] = {
19269 (char *) "self",(char *) "name", NULL
19270 };
19271
19272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19274 if (!SWIG_IsOK(res1)) {
19275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19276 }
19277 arg1 = reinterpret_cast< wxImage * >(argp1);
19278 {
19279 arg2 = wxString_in_helper(obj1);
19280 if (arg2 == NULL) SWIG_fail;
19281 temp2 = true;
19282 }
19283 {
19284 PyThreadState* __tstate = wxPyBeginAllowThreads();
19285 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19286 wxPyEndAllowThreads(__tstate);
19287 if (PyErr_Occurred()) SWIG_fail;
19288 }
19289 {
19290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19291 }
19292 {
19293 if (temp2)
19294 delete arg2;
19295 }
19296 return resultobj;
19297fail:
19298 {
19299 if (temp2)
19300 delete arg2;
19301 }
19302 return NULL;
19303}
19304
19305
19306SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19307 PyObject *resultobj = 0;
19308 wxImage *arg1 = (wxImage *) 0 ;
19309 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19310 unsigned long result;
19311 void *argp1 = 0 ;
19312 int res1 = 0 ;
19313 unsigned long val2 ;
19314 int ecode2 = 0 ;
19315 PyObject * obj0 = 0 ;
19316 PyObject * obj1 = 0 ;
19317 char * kwnames[] = {
19318 (char *) "self",(char *) "stopafter", NULL
19319 };
19320
19321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19323 if (!SWIG_IsOK(res1)) {
19324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19325 }
19326 arg1 = reinterpret_cast< wxImage * >(argp1);
19327 if (obj1) {
19328 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19329 if (!SWIG_IsOK(ecode2)) {
19330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19331 }
19332 arg2 = static_cast< unsigned long >(val2);
19333 }
19334 {
19335 PyThreadState* __tstate = wxPyBeginAllowThreads();
19336 result = (unsigned long)(arg1)->CountColours(arg2);
19337 wxPyEndAllowThreads(__tstate);
19338 if (PyErr_Occurred()) SWIG_fail;
19339 }
19340 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19341 return resultobj;
19342fail:
19343 return NULL;
19344}
19345
19346
19347SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19348 PyObject *resultobj = 0;
19349 wxImage *arg1 = (wxImage *) 0 ;
19350 wxImageHistogram *arg2 = 0 ;
19351 unsigned long result;
19352 void *argp1 = 0 ;
19353 int res1 = 0 ;
19354 void *argp2 = 0 ;
19355 int res2 = 0 ;
19356 PyObject * obj0 = 0 ;
19357 PyObject * obj1 = 0 ;
19358 char * kwnames[] = {
19359 (char *) "self",(char *) "h", NULL
19360 };
19361
19362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19364 if (!SWIG_IsOK(res1)) {
19365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19366 }
19367 arg1 = reinterpret_cast< wxImage * >(argp1);
19368 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19369 if (!SWIG_IsOK(res2)) {
19370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19371 }
19372 if (!argp2) {
19373 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19374 }
19375 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19376 {
19377 PyThreadState* __tstate = wxPyBeginAllowThreads();
19378 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19379 wxPyEndAllowThreads(__tstate);
19380 if (PyErr_Occurred()) SWIG_fail;
19381 }
19382 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19383 return resultobj;
19384fail:
19385 return NULL;
d55e5bfc
RD
19386}
19387
19388
1bd55598
RD
19389SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19390 PyObject *resultobj = 0;
19391 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19392 void *argp1 = 0 ;
19393 int res1 = 0 ;
19394 PyObject * obj0 = 0 ;
19395 char * kwnames[] = {
19396 (char *) "handler", NULL
19397 };
19398
19399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19401 if (!SWIG_IsOK(res1)) {
19402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19403 }
19404 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19405 {
19406 PyThreadState* __tstate = wxPyBeginAllowThreads();
19407 wxImage::AddHandler(arg1);
19408 wxPyEndAllowThreads(__tstate);
19409 if (PyErr_Occurred()) SWIG_fail;
19410 }
19411 resultobj = SWIG_Py_Void();
19412 return resultobj;
19413fail:
19414 return NULL;
d55e5bfc
RD
19415}
19416
19417
1bd55598
RD
19418SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19419 PyObject *resultobj = 0;
19420 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19421 void *argp1 = 0 ;
19422 int res1 = 0 ;
19423 PyObject * obj0 = 0 ;
19424 char * kwnames[] = {
19425 (char *) "handler", NULL
19426 };
19427
19428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19430 if (!SWIG_IsOK(res1)) {
19431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19432 }
19433 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19434 {
19435 PyThreadState* __tstate = wxPyBeginAllowThreads();
19436 wxImage::InsertHandler(arg1);
19437 wxPyEndAllowThreads(__tstate);
19438 if (PyErr_Occurred()) SWIG_fail;
19439 }
19440 resultobj = SWIG_Py_Void();
19441 return resultobj;
19442fail:
19443 return NULL;
d55e5bfc
RD
19444}
19445
19446
1bd55598
RD
19447SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19448 PyObject *resultobj = 0;
19449 wxString *arg1 = 0 ;
19450 bool result;
19451 bool temp1 = false ;
19452 PyObject * obj0 = 0 ;
19453 char * kwnames[] = {
19454 (char *) "name", NULL
19455 };
19456
19457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19458 {
19459 arg1 = wxString_in_helper(obj0);
19460 if (arg1 == NULL) SWIG_fail;
19461 temp1 = true;
19462 }
19463 {
19464 PyThreadState* __tstate = wxPyBeginAllowThreads();
19465 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19466 wxPyEndAllowThreads(__tstate);
19467 if (PyErr_Occurred()) SWIG_fail;
19468 }
19469 {
19470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19471 }
19472 {
19473 if (temp1)
19474 delete arg1;
19475 }
19476 return resultobj;
19477fail:
19478 {
19479 if (temp1)
19480 delete arg1;
19481 }
19482 return NULL;
d55e5bfc
RD
19483}
19484
19485
1bd55598
RD
19486SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19487 PyObject *resultobj = 0;
19488 PyObject *result = 0 ;
19489
19490 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19491 {
19492 PyThreadState* __tstate = wxPyBeginAllowThreads();
19493 result = (PyObject *)wxImage_GetHandlers();
19494 wxPyEndAllowThreads(__tstate);
19495 if (PyErr_Occurred()) SWIG_fail;
19496 }
19497 resultobj = result;
19498 return resultobj;
19499fail:
19500 return NULL;
19501}
19502
19503
19504SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19505 PyObject *resultobj = 0;
19506 wxString result;
19507
19508 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19509 {
19510 PyThreadState* __tstate = wxPyBeginAllowThreads();
19511 result = wxImage::GetImageExtWildcard();
19512 wxPyEndAllowThreads(__tstate);
19513 if (PyErr_Occurred()) SWIG_fail;
19514 }
19515 {
d55e5bfc 19516#if wxUSE_UNICODE
1bd55598 19517 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
d55e5bfc 19518#else
1bd55598 19519 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
d55e5bfc 19520#endif
1bd55598
RD
19521 }
19522 return resultobj;
19523fail:
19524 return NULL;
19525}
19526
19527
19528SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19529 PyObject *resultobj = 0;
19530 wxImage *arg1 = (wxImage *) 0 ;
19531 int arg2 = (int) -1 ;
19532 wxBitmap result;
19533 void *argp1 = 0 ;
19534 int res1 = 0 ;
19535 int val2 ;
19536 int ecode2 = 0 ;
19537 PyObject * obj0 = 0 ;
19538 PyObject * obj1 = 0 ;
19539 char * kwnames[] = {
19540 (char *) "self",(char *) "depth", NULL
19541 };
19542
19543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19545 if (!SWIG_IsOK(res1)) {
19546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19547 }
19548 arg1 = reinterpret_cast< wxImage * >(argp1);
19549 if (obj1) {
19550 ecode2 = SWIG_AsVal_int(obj1, &val2);
19551 if (!SWIG_IsOK(ecode2)) {
19552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19553 }
19554 arg2 = static_cast< int >(val2);
19555 }
19556 {
19557 if (!wxPyCheckForApp()) SWIG_fail;
19558 PyThreadState* __tstate = wxPyBeginAllowThreads();
19559 result = wxImage_ConvertToBitmap(arg1,arg2);
19560 wxPyEndAllowThreads(__tstate);
19561 if (PyErr_Occurred()) SWIG_fail;
19562 }
19563 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19564 return resultobj;
19565fail:
19566 return NULL;
19567}
19568
19569
19570SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19571 PyObject *resultobj = 0;
19572 wxImage *arg1 = (wxImage *) 0 ;
19573 byte arg2 ;
19574 byte arg3 ;
19575 byte arg4 ;
19576 wxBitmap result;
19577 void *argp1 = 0 ;
19578 int res1 = 0 ;
19579 unsigned char val2 ;
19580 int ecode2 = 0 ;
19581 unsigned char val3 ;
19582 int ecode3 = 0 ;
19583 unsigned char val4 ;
19584 int ecode4 = 0 ;
19585 PyObject * obj0 = 0 ;
19586 PyObject * obj1 = 0 ;
19587 PyObject * obj2 = 0 ;
19588 PyObject * obj3 = 0 ;
19589 char * kwnames[] = {
19590 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19591 };
19592
19593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19595 if (!SWIG_IsOK(res1)) {
19596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19597 }
19598 arg1 = reinterpret_cast< wxImage * >(argp1);
19599 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19600 if (!SWIG_IsOK(ecode2)) {
19601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19602 }
19603 arg2 = static_cast< byte >(val2);
19604 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19605 if (!SWIG_IsOK(ecode3)) {
19606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19607 }
19608 arg3 = static_cast< byte >(val3);
19609 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19610 if (!SWIG_IsOK(ecode4)) {
19611 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19612 }
19613 arg4 = static_cast< byte >(val4);
19614 {
19615 if (!wxPyCheckForApp()) SWIG_fail;
19616 PyThreadState* __tstate = wxPyBeginAllowThreads();
19617 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19618 wxPyEndAllowThreads(__tstate);
19619 if (PyErr_Occurred()) SWIG_fail;
19620 }
19621 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19622 return resultobj;
19623fail:
19624 return NULL;
19625}
19626
19627
19628SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19629 PyObject *resultobj = 0;
19630 wxImage *arg1 = (wxImage *) 0 ;
19631 double arg2 ;
19632 void *argp1 = 0 ;
19633 int res1 = 0 ;
19634 double val2 ;
19635 int ecode2 = 0 ;
19636 PyObject * obj0 = 0 ;
19637 PyObject * obj1 = 0 ;
19638 char * kwnames[] = {
19639 (char *) "self",(char *) "angle", NULL
19640 };
19641
19642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19644 if (!SWIG_IsOK(res1)) {
19645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19646 }
19647 arg1 = reinterpret_cast< wxImage * >(argp1);
19648 ecode2 = SWIG_AsVal_double(obj1, &val2);
19649 if (!SWIG_IsOK(ecode2)) {
19650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19651 }
19652 arg2 = static_cast< double >(val2);
19653 {
19654 PyThreadState* __tstate = wxPyBeginAllowThreads();
19655 (arg1)->RotateHue(arg2);
19656 wxPyEndAllowThreads(__tstate);
19657 if (PyErr_Occurred()) SWIG_fail;
19658 }
19659 resultobj = SWIG_Py_Void();
19660 return resultobj;
19661fail:
19662 return NULL;
19663}
19664
19665
19666SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19667 PyObject *resultobj = 0;
19668 wxImage_RGBValue arg1 ;
19669 wxImage_HSVValue result;
19670 void *argp1 ;
19671 int res1 = 0 ;
19672 PyObject * obj0 = 0 ;
19673 char * kwnames[] = {
19674 (char *) "rgb", NULL
19675 };
19676
19677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19678 {
19679 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19680 if (!SWIG_IsOK(res1)) {
19681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19682 }
19683 if (!argp1) {
19684 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19685 } else {
19686 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19687 arg1 = *temp;
19688 if (SWIG_IsNewObj(res1)) delete temp;
d55e5bfc 19689 }
1bd55598
RD
19690 }
19691 {
19692 PyThreadState* __tstate = wxPyBeginAllowThreads();
19693 result = wxImage::RGBtoHSV(arg1);
19694 wxPyEndAllowThreads(__tstate);
19695 if (PyErr_Occurred()) SWIG_fail;
19696 }
19697 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19698 return resultobj;
19699fail:
19700 return NULL;
19701}
19702
19703
19704SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19705 PyObject *resultobj = 0;
19706 wxImage_HSVValue arg1 ;
19707 wxImage_RGBValue result;
19708 void *argp1 ;
19709 int res1 = 0 ;
19710 PyObject * obj0 = 0 ;
19711 char * kwnames[] = {
19712 (char *) "hsv", NULL
19713 };
19714
19715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19716 {
19717 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19718 if (!SWIG_IsOK(res1)) {
19719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19720 }
19721 if (!argp1) {
19722 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19723 } else {
19724 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19725 arg1 = *temp;
19726 if (SWIG_IsNewObj(res1)) delete temp;
d55e5bfc 19727 }
1bd55598
RD
19728 }
19729 {
19730 PyThreadState* __tstate = wxPyBeginAllowThreads();
19731 result = wxImage::HSVtoRGB(arg1);
19732 wxPyEndAllowThreads(__tstate);
19733 if (PyErr_Occurred()) SWIG_fail;
19734 }
19735 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19736 return resultobj;
19737fail:
19738 return NULL;
d55e5bfc
RD
19739}
19740
19741
1bd55598
RD
19742SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19743 PyObject *obj;
19744 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19745 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19746 return SWIG_Py_Void();
d55e5bfc 19747}
1bd55598
RD
19748
19749SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19750 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
19751}
19752
fc46b7f3
RD
19753SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19754 PyObject *resultobj = 0;
19755 int arg1 ;
19756 int arg2 ;
19757 buffer arg3 ;
19758 int arg4 ;
19759 buffer arg5 = (buffer) NULL ;
19760 int arg6 = (int) 0 ;
19761 wxImage *result = 0 ;
19762 int val1 ;
19763 int ecode1 = 0 ;
19764 int val2 ;
19765 int ecode2 = 0 ;
8c9c423b
RD
19766 Py_ssize_t temp3 ;
19767 Py_ssize_t temp5 ;
fc46b7f3
RD
19768 PyObject * obj0 = 0 ;
19769 PyObject * obj1 = 0 ;
19770 PyObject * obj2 = 0 ;
19771 PyObject * obj3 = 0 ;
19772 char * kwnames[] = {
19773 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19774 };
19775
19776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19777 ecode1 = SWIG_AsVal_int(obj0, &val1);
19778 if (!SWIG_IsOK(ecode1)) {
19779 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19780 }
19781 arg1 = static_cast< int >(val1);
19782 ecode2 = SWIG_AsVal_int(obj1, &val2);
19783 if (!SWIG_IsOK(ecode2)) {
19784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19785 }
19786 arg2 = static_cast< int >(val2);
19787 {
8c9c423b
RD
19788 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19789 arg4 = (int)temp3;
fc46b7f3
RD
19790 }
19791 if (obj3) {
19792 {
19793 if (obj3 != Py_None) {
8c9c423b
RD
19794 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19795 arg6 = (int)temp5;
fc46b7f3
RD
19796 }
19797 }
19798 }
19799 {
19800 PyThreadState* __tstate = wxPyBeginAllowThreads();
19801 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19802 wxPyEndAllowThreads(__tstate);
19803 if (PyErr_Occurred()) SWIG_fail;
19804 }
19805 {
19806 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19807 }
19808 return resultobj;
19809fail:
19810 return NULL;
19811}
19812
19813
1bd55598
RD
19814SWIGINTERN int NullImage_set(PyObject *) {
19815 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19816 return 1;
19817}
d55e5bfc 19818
1bd55598
RD
19819
19820SWIGINTERN PyObject *NullImage_get(void) {
19821 PyObject *pyobj = 0;
19822
19823 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19824 return pyobj;
d55e5bfc
RD
19825}
19826
19827
1bd55598
RD
19828SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19829 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19830 return 1;
d55e5bfc
RD
19831}
19832
19833
1bd55598
RD
19834SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19835 PyObject *pyobj = 0;
19836
19837 {
d55e5bfc 19838#if wxUSE_UNICODE
1bd55598 19839 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
d55e5bfc 19840#else
1bd55598 19841 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
d55e5bfc 19842#endif
1bd55598
RD
19843 }
19844 return pyobj;
d55e5bfc
RD
19845}
19846
19847
1bd55598
RD
19848SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19849 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19850 return 1;
d55e5bfc
RD
19851}
19852
19853
1bd55598
RD
19854SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19855 PyObject *pyobj = 0;
19856
19857 {
d55e5bfc 19858#if wxUSE_UNICODE
1bd55598 19859 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
d55e5bfc 19860#else
1bd55598 19861 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
d55e5bfc 19862#endif
1bd55598
RD
19863 }
19864 return pyobj;
d55e5bfc
RD
19865}
19866
19867
1bd55598
RD
19868SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19869 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19870 return 1;
19871}
19872
19873
19874SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19875 PyObject *pyobj = 0;
19876
19877 {
d55e5bfc 19878#if wxUSE_UNICODE
1bd55598 19879 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
d55e5bfc 19880#else
1bd55598 19881 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
d55e5bfc 19882#endif
1bd55598
RD
19883 }
19884 return pyobj;
d55e5bfc
RD
19885}
19886
19887
1bd55598
RD
19888SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19889 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19890 return 1;
d55e5bfc
RD
19891}
19892
19893
1bd55598
RD
19894SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19895 PyObject *pyobj = 0;
19896
19897 {
19898#if wxUSE_UNICODE
19899 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19900#else
19901 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19902#endif
19903 }
19904 return pyobj;
d55e5bfc
RD
19905}
19906
19907
1bd55598
RD
19908SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19909 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19910 return 1;
19911}
19912
19913
19914SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19915 PyObject *pyobj = 0;
19916
19917 {
d55e5bfc 19918#if wxUSE_UNICODE
1bd55598 19919 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
d55e5bfc 19920#else
1bd55598 19921 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
d55e5bfc 19922#endif
1bd55598
RD
19923 }
19924 return pyobj;
d55e5bfc
RD
19925}
19926
19927
1bd55598
RD
19928SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19929 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19930 return 1;
19931}
19932
19933
19934SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19935 PyObject *pyobj = 0;
19936
19937 {
d55e5bfc 19938#if wxUSE_UNICODE
1bd55598 19939 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
d55e5bfc 19940#else
1bd55598 19941 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
d55e5bfc 19942#endif
1bd55598
RD
19943 }
19944 return pyobj;
d55e5bfc
RD
19945}
19946
19947
1bd55598
RD
19948SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
19949 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
19950 return 1;
d55e5bfc
RD
19951}
19952
19953
1bd55598
RD
19954SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
19955 PyObject *pyobj = 0;
19956
19957 {
19958#if wxUSE_UNICODE
19959 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19960#else
19961 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19962#endif
19963 }
19964 return pyobj;
d55e5bfc
RD
19965}
19966
19967
1bd55598
RD
19968SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
19969 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
19970 return 1;
d55e5bfc
RD
19971}
19972
19973
1bd55598
RD
19974SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
19975 PyObject *pyobj = 0;
19976
19977 {
19978#if wxUSE_UNICODE
19979 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19980#else
19981 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19982#endif
19983 }
19984 return pyobj;
d55e5bfc 19985}
1bd55598
RD
19986
19987
19988SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
19989 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
19990 return 1;
d55e5bfc
RD
19991}
19992
19993
1bd55598
RD
19994SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
19995 PyObject *pyobj = 0;
19996
19997 {
19998#if wxUSE_UNICODE
19999 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20000#else
20001 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20002#endif
20003 }
20004 return pyobj;
d55e5bfc
RD
20005}
20006
20007
1bd55598
RD
20008SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20009 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20010 return 1;
d55e5bfc
RD
20011}
20012
20013
1bd55598
RD
20014SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20015 PyObject *pyobj = 0;
20016
20017 {
d55e5bfc 20018#if wxUSE_UNICODE
1bd55598 20019 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
d55e5bfc 20020#else
1bd55598 20021 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
d55e5bfc 20022#endif
1bd55598
RD
20023 }
20024 return pyobj;
d55e5bfc
RD
20025}
20026
20027
1bd55598
RD
20028SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20029 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20030 return 1;
20031}
20032
20033
20034SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20035 PyObject *pyobj = 0;
20036
20037 {
d55e5bfc 20038#if wxUSE_UNICODE
1bd55598 20039 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
d55e5bfc 20040#else
1bd55598 20041 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
d55e5bfc 20042#endif
1bd55598
RD
20043 }
20044 return pyobj;
d55e5bfc
RD
20045}
20046
20047
1bd55598
RD
20048SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20049 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20050 return 1;
d55e5bfc
RD
20051}
20052
20053
1bd55598
RD
20054SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20055 PyObject *pyobj = 0;
20056
20057 {
20058#if wxUSE_UNICODE
20059 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20060#else
20061 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20062#endif
20063 }
20064 return pyobj;
d55e5bfc
RD
20065}
20066
20067
1bd55598
RD
20068SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20069 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20070 return 1;
d55e5bfc
RD
20071}
20072
20073
1bd55598
RD
20074SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20075 PyObject *pyobj = 0;
20076
20077 {
20078#if wxUSE_UNICODE
20079 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20080#else
20081 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20082#endif
20083 }
20084 return pyobj;
d55e5bfc
RD
20085}
20086
20087
1bd55598
RD
20088SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20089 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20090 return 1;
d55e5bfc
RD
20091}
20092
20093
1bd55598
RD
20094SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20095 PyObject *pyobj = 0;
20096
20097 {
20098#if wxUSE_UNICODE
20099 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20100#else
20101 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20102#endif
20103 }
20104 return pyobj;
d55e5bfc
RD
20105}
20106
20107
1bd55598
RD
20108SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20109 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20110 return 1;
d55e5bfc
RD
20111}
20112
20113
1bd55598
RD
20114SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20115 PyObject *pyobj = 0;
20116
20117 {
d55e5bfc 20118#if wxUSE_UNICODE
1bd55598 20119 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
d55e5bfc 20120#else
1bd55598 20121 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
d55e5bfc 20122#endif
1bd55598
RD
20123 }
20124 return pyobj;
d55e5bfc
RD
20125}
20126
20127
1bd55598
RD
20128SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20129 PyObject *resultobj = 0;
20130 wxBMPHandler *result = 0 ;
20131
20132 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20133 {
20134 PyThreadState* __tstate = wxPyBeginAllowThreads();
20135 result = (wxBMPHandler *)new wxBMPHandler();
20136 wxPyEndAllowThreads(__tstate);
20137 if (PyErr_Occurred()) SWIG_fail;
20138 }
20139 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20140 return resultobj;
20141fail:
20142 return NULL;
d55e5bfc
RD
20143}
20144
20145
1bd55598
RD
20146SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20147 PyObject *obj;
20148 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20149 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20150 return SWIG_Py_Void();
d55e5bfc 20151}
1bd55598
RD
20152
20153SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20154 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
20155}
20156
1bd55598
RD
20157SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20158 PyObject *resultobj = 0;
20159 wxICOHandler *result = 0 ;
20160
20161 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20162 {
20163 PyThreadState* __tstate = wxPyBeginAllowThreads();
20164 result = (wxICOHandler *)new wxICOHandler();
20165 wxPyEndAllowThreads(__tstate);
20166 if (PyErr_Occurred()) SWIG_fail;
20167 }
20168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20169 return resultobj;
20170fail:
20171 return NULL;
20172}
d55e5bfc 20173
1bd55598
RD
20174
20175SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20176 PyObject *obj;
20177 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20178 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20179 return SWIG_Py_Void();
d55e5bfc
RD
20180}
20181
1bd55598
RD
20182SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20183 return SWIG_Python_InitShadowInstance(args);
20184}
d55e5bfc 20185
1bd55598
RD
20186SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20187 PyObject *resultobj = 0;
20188 wxCURHandler *result = 0 ;
20189
20190 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20191 {
20192 PyThreadState* __tstate = wxPyBeginAllowThreads();
20193 result = (wxCURHandler *)new wxCURHandler();
20194 wxPyEndAllowThreads(__tstate);
20195 if (PyErr_Occurred()) SWIG_fail;
20196 }
20197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20198 return resultobj;
20199fail:
20200 return NULL;
d55e5bfc
RD
20201}
20202
20203
1bd55598
RD
20204SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20205 PyObject *obj;
20206 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20207 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20208 return SWIG_Py_Void();
d55e5bfc
RD
20209}
20210
1bd55598
RD
20211SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20212 return SWIG_Python_InitShadowInstance(args);
20213}
d55e5bfc 20214
1bd55598
RD
20215SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20216 PyObject *resultobj = 0;
20217 wxANIHandler *result = 0 ;
20218
20219 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20220 {
20221 PyThreadState* __tstate = wxPyBeginAllowThreads();
20222 result = (wxANIHandler *)new wxANIHandler();
20223 wxPyEndAllowThreads(__tstate);
20224 if (PyErr_Occurred()) SWIG_fail;
20225 }
20226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20227 return resultobj;
20228fail:
20229 return NULL;
d55e5bfc
RD
20230}
20231
20232
1bd55598
RD
20233SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20234 PyObject *obj;
20235 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20236 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20237 return SWIG_Py_Void();
d55e5bfc
RD
20238}
20239
1bd55598
RD
20240SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20241 return SWIG_Python_InitShadowInstance(args);
20242}
d55e5bfc 20243
1bd55598
RD
20244SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20245 PyObject *resultobj = 0;
20246 wxPNGHandler *result = 0 ;
20247
20248 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20249 {
20250 PyThreadState* __tstate = wxPyBeginAllowThreads();
20251 result = (wxPNGHandler *)new wxPNGHandler();
20252 wxPyEndAllowThreads(__tstate);
20253 if (PyErr_Occurred()) SWIG_fail;
20254 }
20255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20256 return resultobj;
20257fail:
20258 return NULL;
d55e5bfc
RD
20259}
20260
20261
1bd55598
RD
20262SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20263 PyObject *obj;
20264 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20265 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20266 return SWIG_Py_Void();
d55e5bfc
RD
20267}
20268
1bd55598
RD
20269SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20270 return SWIG_Python_InitShadowInstance(args);
20271}
d55e5bfc 20272
1bd55598
RD
20273SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20274 PyObject *resultobj = 0;
20275 wxGIFHandler *result = 0 ;
20276
20277 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20278 {
20279 PyThreadState* __tstate = wxPyBeginAllowThreads();
20280 result = (wxGIFHandler *)new wxGIFHandler();
20281 wxPyEndAllowThreads(__tstate);
20282 if (PyErr_Occurred()) SWIG_fail;
20283 }
20284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20285 return resultobj;
20286fail:
20287 return NULL;
d55e5bfc
RD
20288}
20289
20290
1bd55598
RD
20291SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20292 PyObject *obj;
20293 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20294 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20295 return SWIG_Py_Void();
943e8dfd
RD
20296}
20297
1bd55598
RD
20298SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20299 return SWIG_Python_InitShadowInstance(args);
943e8dfd
RD
20300}
20301
1bd55598
RD
20302SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20303 PyObject *resultobj = 0;
20304 wxPCXHandler *result = 0 ;
20305
20306 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20307 {
20308 PyThreadState* __tstate = wxPyBeginAllowThreads();
20309 result = (wxPCXHandler *)new wxPCXHandler();
20310 wxPyEndAllowThreads(__tstate);
20311 if (PyErr_Occurred()) SWIG_fail;
20312 }
20313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20314 return resultobj;
20315fail:
20316 return NULL;
d55e5bfc
RD
20317}
20318
20319
1bd55598
RD
20320SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20321 PyObject *obj;
20322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20323 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20324 return SWIG_Py_Void();
d55e5bfc
RD
20325}
20326
1bd55598
RD
20327SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20328 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
20329}
20330
1bd55598
RD
20331SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20332 PyObject *resultobj = 0;
20333 wxJPEGHandler *result = 0 ;
20334
20335 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20336 {
20337 PyThreadState* __tstate = wxPyBeginAllowThreads();
20338 result = (wxJPEGHandler *)new wxJPEGHandler();
20339 wxPyEndAllowThreads(__tstate);
20340 if (PyErr_Occurred()) SWIG_fail;
20341 }
20342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20343 return resultobj;
20344fail:
20345 return NULL;
f1cbd8fa
RD
20346}
20347
20348
1bd55598
RD
20349SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20350 PyObject *obj;
20351 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20352 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20353 return SWIG_Py_Void();
f1cbd8fa
RD
20354}
20355
1bd55598
RD
20356SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20357 return SWIG_Python_InitShadowInstance(args);
f1cbd8fa
RD
20358}
20359
1bd55598
RD
20360SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20361 PyObject *resultobj = 0;
20362 wxPNMHandler *result = 0 ;
20363
20364 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20365 {
20366 PyThreadState* __tstate = wxPyBeginAllowThreads();
20367 result = (wxPNMHandler *)new wxPNMHandler();
20368 wxPyEndAllowThreads(__tstate);
20369 if (PyErr_Occurred()) SWIG_fail;
20370 }
20371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20372 return resultobj;
20373fail:
20374 return NULL;
943e8dfd
RD
20375}
20376
20377
1bd55598
RD
20378SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20379 PyObject *obj;
20380 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20381 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20382 return SWIG_Py_Void();
943e8dfd
RD
20383}
20384
1bd55598
RD
20385SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20386 return SWIG_Python_InitShadowInstance(args);
943e8dfd
RD
20387}
20388
1bd55598
RD
20389SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20390 PyObject *resultobj = 0;
20391 wxXPMHandler *result = 0 ;
20392
20393 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20394 {
20395 PyThreadState* __tstate = wxPyBeginAllowThreads();
20396 result = (wxXPMHandler *)new wxXPMHandler();
20397 wxPyEndAllowThreads(__tstate);
20398 if (PyErr_Occurred()) SWIG_fail;
20399 }
20400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20401 return resultobj;
20402fail:
20403 return NULL;
943e8dfd
RD
20404}
20405
20406
1bd55598
RD
20407SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20408 PyObject *obj;
20409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20410 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20411 return SWIG_Py_Void();
943e8dfd
RD
20412}
20413
1bd55598
RD
20414SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20415 return SWIG_Python_InitShadowInstance(args);
943e8dfd
RD
20416}
20417
1bd55598
RD
20418SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20419 PyObject *resultobj = 0;
20420 wxTIFFHandler *result = 0 ;
20421
20422 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20423 {
20424 PyThreadState* __tstate = wxPyBeginAllowThreads();
20425 result = (wxTIFFHandler *)new wxTIFFHandler();
20426 wxPyEndAllowThreads(__tstate);
20427 if (PyErr_Occurred()) SWIG_fail;
20428 }
20429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20430 return resultobj;
20431fail:
20432 return NULL;
20433}
20434
20435
20436SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20437 PyObject *obj;
20438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20439 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20440 return SWIG_Py_Void();
20441}
20442
20443SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20444 return SWIG_Python_InitShadowInstance(args);
20445}
20446
580080c5
RD
20447SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20448 PyObject *resultobj = 0;
20449 wxTGAHandler *result = 0 ;
20450
20451 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
20452 {
20453 PyThreadState* __tstate = wxPyBeginAllowThreads();
20454 result = (wxTGAHandler *)new wxTGAHandler();
20455 wxPyEndAllowThreads(__tstate);
20456 if (PyErr_Occurred()) SWIG_fail;
20457 }
20458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
20459 return resultobj;
20460fail:
20461 return NULL;
20462}
20463
20464
20465SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20466 PyObject *obj;
20467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20468 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
20469 return SWIG_Py_Void();
20470}
20471
20472SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20473 return SWIG_Python_InitShadowInstance(args);
20474}
20475
1bd55598
RD
20476SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20477 PyObject *resultobj = 0;
20478 wxImage *arg1 = 0 ;
20479 wxImage *arg2 = 0 ;
20480 int arg3 = (int) 236 ;
20481 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20482 bool result;
20483 void *argp1 = 0 ;
20484 int res1 = 0 ;
20485 void *argp2 = 0 ;
20486 int res2 = 0 ;
20487 int val3 ;
20488 int ecode3 = 0 ;
20489 int val4 ;
20490 int ecode4 = 0 ;
20491 PyObject * obj0 = 0 ;
20492 PyObject * obj1 = 0 ;
20493 PyObject * obj2 = 0 ;
20494 PyObject * obj3 = 0 ;
20495 char * kwnames[] = {
20496 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20497 };
20498
20499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20500 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20501 if (!SWIG_IsOK(res1)) {
20502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20503 }
20504 if (!argp1) {
20505 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20506 }
20507 arg1 = reinterpret_cast< wxImage * >(argp1);
20508 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20509 if (!SWIG_IsOK(res2)) {
20510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20511 }
20512 if (!argp2) {
20513 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20514 }
20515 arg2 = reinterpret_cast< wxImage * >(argp2);
20516 if (obj2) {
20517 ecode3 = SWIG_AsVal_int(obj2, &val3);
20518 if (!SWIG_IsOK(ecode3)) {
20519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20520 }
20521 arg3 = static_cast< int >(val3);
20522 }
20523 if (obj3) {
20524 ecode4 = SWIG_AsVal_int(obj3, &val4);
20525 if (!SWIG_IsOK(ecode4)) {
20526 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20527 }
20528 arg4 = static_cast< int >(val4);
20529 }
20530 {
20531 PyThreadState* __tstate = wxPyBeginAllowThreads();
20532 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20533 wxPyEndAllowThreads(__tstate);
20534 if (PyErr_Occurred()) SWIG_fail;
20535 }
20536 {
20537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20538 }
20539 return resultobj;
20540fail:
20541 return NULL;
943e8dfd
RD
20542}
20543
20544
1bd55598
RD
20545SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20546 PyObject *obj;
20547 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20548 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20549 return SWIG_Py_Void();
943e8dfd
RD
20550}
20551
1bd55598
RD
20552SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20553 PyObject *resultobj = 0;
20554 wxEvtHandler *result = 0 ;
20555
20556 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20557 {
20558 PyThreadState* __tstate = wxPyBeginAllowThreads();
20559 result = (wxEvtHandler *)new wxEvtHandler();
20560 wxPyEndAllowThreads(__tstate);
20561 if (PyErr_Occurred()) SWIG_fail;
20562 }
20563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20564 return resultobj;
20565fail:
20566 return NULL;
943e8dfd
RD
20567}
20568
20569
1bd55598
RD
20570SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20571 PyObject *resultobj = 0;
20572 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20573 wxEvtHandler *result = 0 ;
20574 void *argp1 = 0 ;
20575 int res1 = 0 ;
20576 PyObject *swig_obj[1] ;
20577
20578 if (!args) SWIG_fail;
20579 swig_obj[0] = args;
20580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20581 if (!SWIG_IsOK(res1)) {
20582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20583 }
20584 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20585 {
20586 PyThreadState* __tstate = wxPyBeginAllowThreads();
20587 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20588 wxPyEndAllowThreads(__tstate);
20589 if (PyErr_Occurred()) SWIG_fail;
20590 }
20591 {
20592 resultobj = wxPyMake_wxObject(result, 0);
20593 }
20594 return resultobj;
20595fail:
20596 return NULL;
943e8dfd
RD
20597}
20598
20599
1bd55598
RD
20600SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20601 PyObject *resultobj = 0;
20602 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20603 wxEvtHandler *result = 0 ;
20604 void *argp1 = 0 ;
20605 int res1 = 0 ;
20606 PyObject *swig_obj[1] ;
20607
20608 if (!args) SWIG_fail;
20609 swig_obj[0] = args;
20610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20611 if (!SWIG_IsOK(res1)) {
20612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20613 }
20614 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20615 {
20616 PyThreadState* __tstate = wxPyBeginAllowThreads();
20617 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20618 wxPyEndAllowThreads(__tstate);
20619 if (PyErr_Occurred()) SWIG_fail;
20620 }
20621 {
20622 resultobj = wxPyMake_wxObject(result, 0);
20623 }
20624 return resultobj;
20625fail:
20626 return NULL;
20627}
20628
20629
20630SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20631 PyObject *resultobj = 0;
20632 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20633 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20634 void *argp1 = 0 ;
20635 int res1 = 0 ;
20636 void *argp2 = 0 ;
20637 int res2 = 0 ;
20638 PyObject * obj0 = 0 ;
20639 PyObject * obj1 = 0 ;
20640 char * kwnames[] = {
20641 (char *) "self",(char *) "handler", NULL
20642 };
20643
20644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20646 if (!SWIG_IsOK(res1)) {
20647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20648 }
20649 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20650 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20651 if (!SWIG_IsOK(res2)) {
20652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20653 }
20654 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20655 {
20656 PyThreadState* __tstate = wxPyBeginAllowThreads();
20657 (arg1)->SetNextHandler(arg2);
20658 wxPyEndAllowThreads(__tstate);
20659 if (PyErr_Occurred()) SWIG_fail;
20660 }
20661 resultobj = SWIG_Py_Void();
20662 return resultobj;
20663fail:
20664 return NULL;
20665}
20666
20667
20668SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20669 PyObject *resultobj = 0;
20670 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20671 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20672 void *argp1 = 0 ;
20673 int res1 = 0 ;
20674 void *argp2 = 0 ;
20675 int res2 = 0 ;
20676 PyObject * obj0 = 0 ;
20677 PyObject * obj1 = 0 ;
20678 char * kwnames[] = {
20679 (char *) "self",(char *) "handler", NULL
20680 };
20681
20682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20684 if (!SWIG_IsOK(res1)) {
20685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20686 }
20687 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20688 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20689 if (!SWIG_IsOK(res2)) {
20690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20691 }
20692 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20693 {
20694 PyThreadState* __tstate = wxPyBeginAllowThreads();
20695 (arg1)->SetPreviousHandler(arg2);
20696 wxPyEndAllowThreads(__tstate);
20697 if (PyErr_Occurred()) SWIG_fail;
20698 }
20699 resultobj = SWIG_Py_Void();
20700 return resultobj;
20701fail:
20702 return NULL;
943e8dfd
RD
20703}
20704
20705
1bd55598
RD
20706SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20707 PyObject *resultobj = 0;
20708 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20709 bool result;
20710 void *argp1 = 0 ;
20711 int res1 = 0 ;
20712 PyObject *swig_obj[1] ;
20713
20714 if (!args) SWIG_fail;
20715 swig_obj[0] = args;
20716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20717 if (!SWIG_IsOK(res1)) {
20718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20719 }
20720 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20721 {
20722 PyThreadState* __tstate = wxPyBeginAllowThreads();
20723 result = (bool)(arg1)->GetEvtHandlerEnabled();
20724 wxPyEndAllowThreads(__tstate);
20725 if (PyErr_Occurred()) SWIG_fail;
20726 }
20727 {
20728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20729 }
20730 return resultobj;
20731fail:
20732 return NULL;
20733}
20734
20735
20736SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20737 PyObject *resultobj = 0;
20738 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20739 bool arg2 ;
20740 void *argp1 = 0 ;
20741 int res1 = 0 ;
20742 bool val2 ;
20743 int ecode2 = 0 ;
20744 PyObject * obj0 = 0 ;
20745 PyObject * obj1 = 0 ;
20746 char * kwnames[] = {
20747 (char *) "self",(char *) "enabled", NULL
20748 };
20749
20750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20752 if (!SWIG_IsOK(res1)) {
20753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20754 }
20755 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20756 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20757 if (!SWIG_IsOK(ecode2)) {
20758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20759 }
20760 arg2 = static_cast< bool >(val2);
20761 {
20762 PyThreadState* __tstate = wxPyBeginAllowThreads();
20763 (arg1)->SetEvtHandlerEnabled(arg2);
20764 wxPyEndAllowThreads(__tstate);
20765 if (PyErr_Occurred()) SWIG_fail;
20766 }
20767 resultobj = SWIG_Py_Void();
20768 return resultobj;
20769fail:
20770 return NULL;
20771}
20772
20773
20774SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20775 PyObject *resultobj = 0;
20776 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20777 wxEvent *arg2 = 0 ;
20778 bool result;
20779 void *argp1 = 0 ;
20780 int res1 = 0 ;
20781 void *argp2 = 0 ;
20782 int res2 = 0 ;
20783 PyObject * obj0 = 0 ;
20784 PyObject * obj1 = 0 ;
20785 char * kwnames[] = {
20786 (char *) "self",(char *) "event", NULL
20787 };
20788
20789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20791 if (!SWIG_IsOK(res1)) {
20792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20793 }
20794 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20795 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20796 if (!SWIG_IsOK(res2)) {
20797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20798 }
20799 if (!argp2) {
20800 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20801 }
20802 arg2 = reinterpret_cast< wxEvent * >(argp2);
20803 {
20804 PyThreadState* __tstate = wxPyBeginAllowThreads();
20805 result = (bool)(arg1)->ProcessEvent(*arg2);
20806 wxPyEndAllowThreads(__tstate);
20807 if (PyErr_Occurred()) SWIG_fail;
20808 }
20809 {
20810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20811 }
20812 return resultobj;
20813fail:
20814 return NULL;
20815}
20816
20817
20818SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20819 PyObject *resultobj = 0;
20820 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20821 wxEvent *arg2 = 0 ;
20822 void *argp1 = 0 ;
20823 int res1 = 0 ;
20824 void *argp2 = 0 ;
20825 int res2 = 0 ;
20826 PyObject * obj0 = 0 ;
20827 PyObject * obj1 = 0 ;
20828 char * kwnames[] = {
20829 (char *) "self",(char *) "event", NULL
20830 };
20831
20832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20834 if (!SWIG_IsOK(res1)) {
20835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20836 }
20837 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20838 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20839 if (!SWIG_IsOK(res2)) {
20840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20841 }
20842 if (!argp2) {
20843 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20844 }
20845 arg2 = reinterpret_cast< wxEvent * >(argp2);
20846 {
20847 PyThreadState* __tstate = wxPyBeginAllowThreads();
20848 (arg1)->AddPendingEvent(*arg2);
20849 wxPyEndAllowThreads(__tstate);
20850 if (PyErr_Occurred()) SWIG_fail;
20851 }
20852 resultobj = SWIG_Py_Void();
20853 return resultobj;
20854fail:
20855 return NULL;
943e8dfd
RD
20856}
20857
20858
1bd55598
RD
20859SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20860 PyObject *resultobj = 0;
20861 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
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_wxEvtHandler, 0 | 0 );
20869 if (!SWIG_IsOK(res1)) {
20870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20871 }
20872 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20873 {
20874 PyThreadState* __tstate = wxPyBeginAllowThreads();
20875 (arg1)->ProcessPendingEvents();
20876 wxPyEndAllowThreads(__tstate);
20877 if (PyErr_Occurred()) SWIG_fail;
20878 }
20879 resultobj = SWIG_Py_Void();
20880 return resultobj;
20881fail:
20882 return NULL;
20883}
20884
20885
20886SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20887 PyObject *resultobj = 0;
20888 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20889 int arg2 ;
20890 int arg3 ;
20891 int arg4 ;
20892 PyObject *arg5 = (PyObject *) 0 ;
20893 void *argp1 = 0 ;
20894 int res1 = 0 ;
20895 int val2 ;
20896 int ecode2 = 0 ;
20897 int val3 ;
20898 int ecode3 = 0 ;
20899 int val4 ;
20900 int ecode4 = 0 ;
20901 PyObject * obj0 = 0 ;
20902 PyObject * obj1 = 0 ;
20903 PyObject * obj2 = 0 ;
20904 PyObject * obj3 = 0 ;
20905 PyObject * obj4 = 0 ;
20906 char * kwnames[] = {
20907 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20908 };
20909
20910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20912 if (!SWIG_IsOK(res1)) {
20913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20914 }
20915 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20916 ecode2 = SWIG_AsVal_int(obj1, &val2);
20917 if (!SWIG_IsOK(ecode2)) {
20918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20919 }
20920 arg2 = static_cast< int >(val2);
20921 ecode3 = SWIG_AsVal_int(obj2, &val3);
20922 if (!SWIG_IsOK(ecode3)) {
20923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20924 }
20925 arg3 = static_cast< int >(val3);
20926 ecode4 = SWIG_AsVal_int(obj3, &val4);
20927 if (!SWIG_IsOK(ecode4)) {
20928 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
20929 }
20930 arg4 = static_cast< int >(val4);
20931 arg5 = obj4;
20932 {
20933 PyThreadState* __tstate = wxPyBeginAllowThreads();
20934 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
20935 wxPyEndAllowThreads(__tstate);
20936 if (PyErr_Occurred()) SWIG_fail;
20937 }
20938 resultobj = SWIG_Py_Void();
20939 return resultobj;
20940fail:
20941 return NULL;
20942}
20943
20944
20945SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20946 PyObject *resultobj = 0;
20947 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20948 int arg2 ;
20949 int arg3 = (int) -1 ;
20950 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
20951 bool result;
20952 void *argp1 = 0 ;
20953 int res1 = 0 ;
20954 int val2 ;
20955 int ecode2 = 0 ;
20956 int val3 ;
20957 int ecode3 = 0 ;
20958 int val4 ;
20959 int ecode4 = 0 ;
20960 PyObject * obj0 = 0 ;
20961 PyObject * obj1 = 0 ;
20962 PyObject * obj2 = 0 ;
20963 PyObject * obj3 = 0 ;
20964 char * kwnames[] = {
20965 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
20966 };
20967
20968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20970 if (!SWIG_IsOK(res1)) {
20971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20972 }
20973 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20974 ecode2 = SWIG_AsVal_int(obj1, &val2);
20975 if (!SWIG_IsOK(ecode2)) {
20976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
20977 }
20978 arg2 = static_cast< int >(val2);
20979 if (obj2) {
20980 ecode3 = SWIG_AsVal_int(obj2, &val3);
20981 if (!SWIG_IsOK(ecode3)) {
20982 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
20983 }
20984 arg3 = static_cast< int >(val3);
20985 }
20986 if (obj3) {
20987 ecode4 = SWIG_AsVal_int(obj3, &val4);
20988 if (!SWIG_IsOK(ecode4)) {
20989 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
20990 }
20991 arg4 = static_cast< wxEventType >(val4);
20992 }
20993 {
20994 PyThreadState* __tstate = wxPyBeginAllowThreads();
20995 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
20996 wxPyEndAllowThreads(__tstate);
20997 if (PyErr_Occurred()) SWIG_fail;
20998 }
20999 {
21000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21001 }
21002 return resultobj;
21003fail:
21004 return NULL;
21005}
21006
21007
21008SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21009 PyObject *resultobj = 0;
21010 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21011 PyObject *arg2 = (PyObject *) 0 ;
21012 bool arg3 = (bool) true ;
21013 void *argp1 = 0 ;
21014 int res1 = 0 ;
21015 bool val3 ;
21016 int ecode3 = 0 ;
21017 PyObject * obj0 = 0 ;
21018 PyObject * obj1 = 0 ;
21019 PyObject * obj2 = 0 ;
21020 char * kwnames[] = {
21021 (char *) "self",(char *) "_self",(char *) "incref", NULL
21022 };
21023
21024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21026 if (!SWIG_IsOK(res1)) {
21027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21028 }
21029 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21030 arg2 = obj1;
21031 if (obj2) {
21032 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21033 if (!SWIG_IsOK(ecode3)) {
21034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21035 }
21036 arg3 = static_cast< bool >(val3);
21037 }
21038 {
21039 PyThreadState* __tstate = wxPyBeginAllowThreads();
21040 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21041 wxPyEndAllowThreads(__tstate);
21042 if (PyErr_Occurred()) SWIG_fail;
21043 }
21044 resultobj = SWIG_Py_Void();
21045 return resultobj;
21046fail:
21047 return NULL;
943e8dfd
RD
21048}
21049
21050
1bd55598
RD
21051SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21052 PyObject *obj;
21053 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21054 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21055 return SWIG_Py_Void();
d55e5bfc
RD
21056}
21057
1bd55598
RD
21058SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21059 return SWIG_Python_InitShadowInstance(args);
21060}
d55e5bfc 21061
1bd55598
RD
21062SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21063 PyObject *resultobj = 0;
21064 wxEventType result;
21065
21066 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21067 {
21068 PyThreadState* __tstate = wxPyBeginAllowThreads();
21069 result = (wxEventType)wxNewEventType();
21070 wxPyEndAllowThreads(__tstate);
21071 if (PyErr_Occurred()) SWIG_fail;
21072 }
21073 resultobj = SWIG_From_int(static_cast< int >(result));
21074 return resultobj;
21075fail:
21076 return NULL;
d55e5bfc
RD
21077}
21078
21079
1bd55598
RD
21080SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21081 PyObject *resultobj = 0;
21082 wxEvent *arg1 = (wxEvent *) 0 ;
21083 void *argp1 = 0 ;
21084 int res1 = 0 ;
21085 PyObject *swig_obj[1] ;
21086
21087 if (!args) SWIG_fail;
21088 swig_obj[0] = args;
21089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21090 if (!SWIG_IsOK(res1)) {
21091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21092 }
21093 arg1 = reinterpret_cast< wxEvent * >(argp1);
21094 {
21095 PyThreadState* __tstate = wxPyBeginAllowThreads();
21096 delete arg1;
d55e5bfc 21097
1bd55598
RD
21098 wxPyEndAllowThreads(__tstate);
21099 if (PyErr_Occurred()) SWIG_fail;
21100 }
21101 resultobj = SWIG_Py_Void();
21102 return resultobj;
21103fail:
21104 return NULL;
21105}
21106
21107
21108SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21109 PyObject *resultobj = 0;
21110 wxEvent *arg1 = (wxEvent *) 0 ;
21111 wxEventType arg2 ;
21112 void *argp1 = 0 ;
21113 int res1 = 0 ;
21114 int val2 ;
21115 int ecode2 = 0 ;
21116 PyObject * obj0 = 0 ;
21117 PyObject * obj1 = 0 ;
21118 char * kwnames[] = {
21119 (char *) "self",(char *) "typ", NULL
21120 };
21121
21122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21124 if (!SWIG_IsOK(res1)) {
21125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21126 }
21127 arg1 = reinterpret_cast< wxEvent * >(argp1);
21128 ecode2 = SWIG_AsVal_int(obj1, &val2);
21129 if (!SWIG_IsOK(ecode2)) {
21130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21131 }
21132 arg2 = static_cast< wxEventType >(val2);
21133 {
21134 PyThreadState* __tstate = wxPyBeginAllowThreads();
21135 (arg1)->SetEventType(arg2);
21136 wxPyEndAllowThreads(__tstate);
21137 if (PyErr_Occurred()) SWIG_fail;
21138 }
21139 resultobj = SWIG_Py_Void();
21140 return resultobj;
21141fail:
21142 return NULL;
d55e5bfc
RD
21143}
21144
21145
1bd55598
RD
21146SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21147 PyObject *resultobj = 0;
21148 wxEvent *arg1 = (wxEvent *) 0 ;
21149 wxEventType result;
21150 void *argp1 = 0 ;
21151 int res1 = 0 ;
21152 PyObject *swig_obj[1] ;
21153
21154 if (!args) SWIG_fail;
21155 swig_obj[0] = args;
21156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21157 if (!SWIG_IsOK(res1)) {
21158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21159 }
21160 arg1 = reinterpret_cast< wxEvent * >(argp1);
21161 {
21162 PyThreadState* __tstate = wxPyBeginAllowThreads();
21163 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21164 wxPyEndAllowThreads(__tstate);
21165 if (PyErr_Occurred()) SWIG_fail;
21166 }
21167 resultobj = SWIG_From_int(static_cast< int >(result));
21168 return resultobj;
21169fail:
21170 return NULL;
d55e5bfc
RD
21171}
21172
21173
1bd55598
RD
21174SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21175 PyObject *resultobj = 0;
21176 wxEvent *arg1 = (wxEvent *) 0 ;
21177 wxObject *result = 0 ;
21178 void *argp1 = 0 ;
21179 int res1 = 0 ;
21180 PyObject *swig_obj[1] ;
21181
21182 if (!args) SWIG_fail;
21183 swig_obj[0] = args;
21184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21185 if (!SWIG_IsOK(res1)) {
21186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21187 }
21188 arg1 = reinterpret_cast< wxEvent * >(argp1);
21189 {
21190 PyThreadState* __tstate = wxPyBeginAllowThreads();
21191 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21192 wxPyEndAllowThreads(__tstate);
21193 if (PyErr_Occurred()) SWIG_fail;
21194 }
21195 {
21196 resultobj = wxPyMake_wxObject(result, (bool)0);
21197 }
21198 return resultobj;
21199fail:
21200 return NULL;
21201}
21202
21203
21204SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21205 PyObject *resultobj = 0;
21206 wxEvent *arg1 = (wxEvent *) 0 ;
21207 wxObject *arg2 = (wxObject *) 0 ;
21208 void *argp1 = 0 ;
21209 int res1 = 0 ;
21210 void *argp2 = 0 ;
21211 int res2 = 0 ;
21212 PyObject * obj0 = 0 ;
21213 PyObject * obj1 = 0 ;
21214 char * kwnames[] = {
21215 (char *) "self",(char *) "obj", NULL
21216 };
21217
21218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21220 if (!SWIG_IsOK(res1)) {
21221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21222 }
21223 arg1 = reinterpret_cast< wxEvent * >(argp1);
21224 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21225 if (!SWIG_IsOK(res2)) {
21226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21227 }
21228 arg2 = reinterpret_cast< wxObject * >(argp2);
21229 {
21230 PyThreadState* __tstate = wxPyBeginAllowThreads();
21231 (arg1)->SetEventObject(arg2);
21232 wxPyEndAllowThreads(__tstate);
21233 if (PyErr_Occurred()) SWIG_fail;
21234 }
21235 resultobj = SWIG_Py_Void();
21236 return resultobj;
21237fail:
21238 return NULL;
d55e5bfc
RD
21239}
21240
21241
1bd55598
RD
21242SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21243 PyObject *resultobj = 0;
21244 wxEvent *arg1 = (wxEvent *) 0 ;
21245 long result;
21246 void *argp1 = 0 ;
21247 int res1 = 0 ;
21248 PyObject *swig_obj[1] ;
21249
21250 if (!args) SWIG_fail;
21251 swig_obj[0] = args;
21252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21253 if (!SWIG_IsOK(res1)) {
21254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21255 }
21256 arg1 = reinterpret_cast< wxEvent * >(argp1);
21257 {
21258 PyThreadState* __tstate = wxPyBeginAllowThreads();
21259 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21260 wxPyEndAllowThreads(__tstate);
21261 if (PyErr_Occurred()) SWIG_fail;
21262 }
21263 resultobj = SWIG_From_long(static_cast< long >(result));
21264 return resultobj;
21265fail:
21266 return NULL;
21267}
21268
21269
21270SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21271 PyObject *resultobj = 0;
21272 wxEvent *arg1 = (wxEvent *) 0 ;
21273 long arg2 = (long) 0 ;
21274 void *argp1 = 0 ;
21275 int res1 = 0 ;
21276 long val2 ;
21277 int ecode2 = 0 ;
21278 PyObject * obj0 = 0 ;
21279 PyObject * obj1 = 0 ;
21280 char * kwnames[] = {
21281 (char *) "self",(char *) "ts", NULL
21282 };
21283
21284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21286 if (!SWIG_IsOK(res1)) {
21287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21288 }
21289 arg1 = reinterpret_cast< wxEvent * >(argp1);
21290 if (obj1) {
21291 ecode2 = SWIG_AsVal_long(obj1, &val2);
21292 if (!SWIG_IsOK(ecode2)) {
21293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21294 }
21295 arg2 = static_cast< long >(val2);
21296 }
21297 {
21298 PyThreadState* __tstate = wxPyBeginAllowThreads();
21299 (arg1)->SetTimestamp(arg2);
21300 wxPyEndAllowThreads(__tstate);
21301 if (PyErr_Occurred()) SWIG_fail;
21302 }
21303 resultobj = SWIG_Py_Void();
21304 return resultobj;
21305fail:
21306 return NULL;
d55e5bfc
RD
21307}
21308
21309
1bd55598
RD
21310SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21311 PyObject *resultobj = 0;
21312 wxEvent *arg1 = (wxEvent *) 0 ;
21313 int result;
21314 void *argp1 = 0 ;
21315 int res1 = 0 ;
21316 PyObject *swig_obj[1] ;
21317
21318 if (!args) SWIG_fail;
21319 swig_obj[0] = args;
21320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21321 if (!SWIG_IsOK(res1)) {
21322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21323 }
21324 arg1 = reinterpret_cast< wxEvent * >(argp1);
21325 {
21326 PyThreadState* __tstate = wxPyBeginAllowThreads();
21327 result = (int)((wxEvent const *)arg1)->GetId();
21328 wxPyEndAllowThreads(__tstate);
21329 if (PyErr_Occurred()) SWIG_fail;
21330 }
21331 resultobj = SWIG_From_int(static_cast< int >(result));
21332 return resultobj;
21333fail:
21334 return NULL;
21335}
21336
21337
21338SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21339 PyObject *resultobj = 0;
21340 wxEvent *arg1 = (wxEvent *) 0 ;
21341 int arg2 ;
21342 void *argp1 = 0 ;
21343 int res1 = 0 ;
21344 int val2 ;
21345 int ecode2 = 0 ;
21346 PyObject * obj0 = 0 ;
21347 PyObject * obj1 = 0 ;
21348 char * kwnames[] = {
21349 (char *) "self",(char *) "Id", NULL
21350 };
21351
21352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21354 if (!SWIG_IsOK(res1)) {
21355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21356 }
21357 arg1 = reinterpret_cast< wxEvent * >(argp1);
21358 ecode2 = SWIG_AsVal_int(obj1, &val2);
21359 if (!SWIG_IsOK(ecode2)) {
21360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21361 }
21362 arg2 = static_cast< int >(val2);
21363 {
21364 PyThreadState* __tstate = wxPyBeginAllowThreads();
21365 (arg1)->SetId(arg2);
21366 wxPyEndAllowThreads(__tstate);
21367 if (PyErr_Occurred()) SWIG_fail;
21368 }
21369 resultobj = SWIG_Py_Void();
21370 return resultobj;
21371fail:
21372 return NULL;
d55e5bfc
RD
21373}
21374
21375
1bd55598
RD
21376SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21377 PyObject *resultobj = 0;
21378 wxEvent *arg1 = (wxEvent *) 0 ;
21379 bool result;
21380 void *argp1 = 0 ;
21381 int res1 = 0 ;
21382 PyObject *swig_obj[1] ;
21383
21384 if (!args) SWIG_fail;
21385 swig_obj[0] = args;
21386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21387 if (!SWIG_IsOK(res1)) {
21388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21389 }
21390 arg1 = reinterpret_cast< wxEvent * >(argp1);
21391 {
21392 PyThreadState* __tstate = wxPyBeginAllowThreads();
21393 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21394 wxPyEndAllowThreads(__tstate);
21395 if (PyErr_Occurred()) SWIG_fail;
21396 }
21397 {
21398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21399 }
21400 return resultobj;
21401fail:
21402 return NULL;
21403}
21404
21405
21406SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21407 PyObject *resultobj = 0;
21408 wxEvent *arg1 = (wxEvent *) 0 ;
21409 bool arg2 = (bool) true ;
21410 void *argp1 = 0 ;
21411 int res1 = 0 ;
21412 bool val2 ;
21413 int ecode2 = 0 ;
21414 PyObject * obj0 = 0 ;
21415 PyObject * obj1 = 0 ;
21416 char * kwnames[] = {
21417 (char *) "self",(char *) "skip", NULL
21418 };
21419
21420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21422 if (!SWIG_IsOK(res1)) {
21423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21424 }
21425 arg1 = reinterpret_cast< wxEvent * >(argp1);
21426 if (obj1) {
21427 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21428 if (!SWIG_IsOK(ecode2)) {
21429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21430 }
21431 arg2 = static_cast< bool >(val2);
21432 }
21433 {
21434 PyThreadState* __tstate = wxPyBeginAllowThreads();
21435 (arg1)->Skip(arg2);
21436 wxPyEndAllowThreads(__tstate);
21437 if (PyErr_Occurred()) SWIG_fail;
21438 }
21439 resultobj = SWIG_Py_Void();
21440 return resultobj;
21441fail:
21442 return NULL;
d55e5bfc
RD
21443}
21444
21445
1bd55598
RD
21446SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21447 PyObject *resultobj = 0;
21448 wxEvent *arg1 = (wxEvent *) 0 ;
21449 bool result;
21450 void *argp1 = 0 ;
21451 int res1 = 0 ;
21452 PyObject *swig_obj[1] ;
21453
21454 if (!args) SWIG_fail;
21455 swig_obj[0] = args;
21456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21457 if (!SWIG_IsOK(res1)) {
21458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21459 }
21460 arg1 = reinterpret_cast< wxEvent * >(argp1);
21461 {
21462 PyThreadState* __tstate = wxPyBeginAllowThreads();
21463 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21464 wxPyEndAllowThreads(__tstate);
21465 if (PyErr_Occurred()) SWIG_fail;
21466 }
21467 {
21468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21469 }
21470 return resultobj;
21471fail:
21472 return NULL;
03e46024
RD
21473}
21474
21475
1bd55598
RD
21476SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21477 PyObject *resultobj = 0;
21478 wxEvent *arg1 = (wxEvent *) 0 ;
21479 bool result;
21480 void *argp1 = 0 ;
21481 int res1 = 0 ;
21482 PyObject *swig_obj[1] ;
21483
21484 if (!args) SWIG_fail;
21485 swig_obj[0] = args;
21486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21487 if (!SWIG_IsOK(res1)) {
21488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21489 }
21490 arg1 = reinterpret_cast< wxEvent * >(argp1);
21491 {
21492 PyThreadState* __tstate = wxPyBeginAllowThreads();
21493 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21494 wxPyEndAllowThreads(__tstate);
21495 if (PyErr_Occurred()) SWIG_fail;
21496 }
21497 {
21498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21499 }
21500 return resultobj;
21501fail:
21502 return NULL;
d55e5bfc
RD
21503}
21504
21505
1bd55598
RD
21506SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21507 PyObject *resultobj = 0;
21508 wxEvent *arg1 = (wxEvent *) 0 ;
21509 int result;
21510 void *argp1 = 0 ;
21511 int res1 = 0 ;
21512 PyObject *swig_obj[1] ;
21513
21514 if (!args) SWIG_fail;
21515 swig_obj[0] = args;
21516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21517 if (!SWIG_IsOK(res1)) {
21518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21519 }
21520 arg1 = reinterpret_cast< wxEvent * >(argp1);
21521 {
21522 PyThreadState* __tstate = wxPyBeginAllowThreads();
21523 result = (int)(arg1)->StopPropagation();
21524 wxPyEndAllowThreads(__tstate);
21525 if (PyErr_Occurred()) SWIG_fail;
21526 }
21527 resultobj = SWIG_From_int(static_cast< int >(result));
21528 return resultobj;
21529fail:
21530 return NULL;
21531}
21532
21533
21534SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21535 PyObject *resultobj = 0;
21536 wxEvent *arg1 = (wxEvent *) 0 ;
21537 int arg2 ;
21538 void *argp1 = 0 ;
21539 int res1 = 0 ;
21540 int val2 ;
21541 int ecode2 = 0 ;
21542 PyObject * obj0 = 0 ;
21543 PyObject * obj1 = 0 ;
21544 char * kwnames[] = {
21545 (char *) "self",(char *) "propagationLevel", NULL
21546 };
21547
21548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21550 if (!SWIG_IsOK(res1)) {
21551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21552 }
21553 arg1 = reinterpret_cast< wxEvent * >(argp1);
21554 ecode2 = SWIG_AsVal_int(obj1, &val2);
21555 if (!SWIG_IsOK(ecode2)) {
21556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21557 }
21558 arg2 = static_cast< int >(val2);
21559 {
21560 PyThreadState* __tstate = wxPyBeginAllowThreads();
21561 (arg1)->ResumePropagation(arg2);
21562 wxPyEndAllowThreads(__tstate);
21563 if (PyErr_Occurred()) SWIG_fail;
21564 }
21565 resultobj = SWIG_Py_Void();
21566 return resultobj;
21567fail:
21568 return NULL;
d55e5bfc
RD
21569}
21570
21571
1bd55598
RD
21572SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21573 PyObject *resultobj = 0;
21574 wxEvent *arg1 = (wxEvent *) 0 ;
21575 wxEvent *result = 0 ;
21576 void *argp1 = 0 ;
21577 int res1 = 0 ;
21578 PyObject *swig_obj[1] ;
21579
21580 if (!args) SWIG_fail;
21581 swig_obj[0] = args;
21582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21583 if (!SWIG_IsOK(res1)) {
21584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21585 }
21586 arg1 = reinterpret_cast< wxEvent * >(argp1);
21587 {
21588 PyThreadState* __tstate = wxPyBeginAllowThreads();
21589 result = (wxEvent *)(arg1)->Clone();
21590 wxPyEndAllowThreads(__tstate);
21591 if (PyErr_Occurred()) SWIG_fail;
21592 }
21593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21594 return resultobj;
21595fail:
21596 return NULL;
d55e5bfc
RD
21597}
21598
21599
1bd55598
RD
21600SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21601 PyObject *obj;
21602 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21603 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21604 return SWIG_Py_Void();
d55e5bfc
RD
21605}
21606
1bd55598
RD
21607SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21608 PyObject *resultobj = 0;
21609 wxEvent *arg1 = 0 ;
21610 wxPropagationDisabler *result = 0 ;
21611 void *argp1 = 0 ;
21612 int res1 = 0 ;
21613 PyObject * obj0 = 0 ;
21614 char * kwnames[] = {
21615 (char *) "event", NULL
21616 };
21617
21618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21619 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21620 if (!SWIG_IsOK(res1)) {
21621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21622 }
21623 if (!argp1) {
21624 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21625 }
21626 arg1 = reinterpret_cast< wxEvent * >(argp1);
21627 {
21628 PyThreadState* __tstate = wxPyBeginAllowThreads();
21629 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21630 wxPyEndAllowThreads(__tstate);
21631 if (PyErr_Occurred()) SWIG_fail;
21632 }
21633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21634 return resultobj;
21635fail:
21636 return NULL;
d55e5bfc
RD
21637}
21638
21639
1bd55598
RD
21640SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21641 PyObject *resultobj = 0;
21642 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21643 void *argp1 = 0 ;
21644 int res1 = 0 ;
21645 PyObject *swig_obj[1] ;
21646
21647 if (!args) SWIG_fail;
21648 swig_obj[0] = args;
21649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21650 if (!SWIG_IsOK(res1)) {
21651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21652 }
21653 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21654 {
21655 PyThreadState* __tstate = wxPyBeginAllowThreads();
21656 delete arg1;
aff4cc5c 21657
1bd55598
RD
21658 wxPyEndAllowThreads(__tstate);
21659 if (PyErr_Occurred()) SWIG_fail;
21660 }
21661 resultobj = SWIG_Py_Void();
21662 return resultobj;
21663fail:
21664 return NULL;
aff4cc5c
RD
21665}
21666
21667
1bd55598
RD
21668SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21669 PyObject *obj;
21670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21671 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21672 return SWIG_Py_Void();
d55e5bfc
RD
21673}
21674
1bd55598
RD
21675SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21676 return SWIG_Python_InitShadowInstance(args);
21677}
d55e5bfc 21678
1bd55598
RD
21679SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21680 PyObject *resultobj = 0;
21681 wxEvent *arg1 = 0 ;
21682 wxPropagateOnce *result = 0 ;
21683 void *argp1 = 0 ;
21684 int res1 = 0 ;
21685 PyObject * obj0 = 0 ;
21686 char * kwnames[] = {
21687 (char *) "event", NULL
21688 };
21689
21690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21691 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21692 if (!SWIG_IsOK(res1)) {
21693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21694 }
21695 if (!argp1) {
21696 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21697 }
21698 arg1 = reinterpret_cast< wxEvent * >(argp1);
21699 {
21700 PyThreadState* __tstate = wxPyBeginAllowThreads();
21701 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21702 wxPyEndAllowThreads(__tstate);
21703 if (PyErr_Occurred()) SWIG_fail;
21704 }
21705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21706 return resultobj;
21707fail:
21708 return NULL;
aff4cc5c
RD
21709}
21710
21711
1bd55598
RD
21712SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21713 PyObject *resultobj = 0;
21714 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21715 void *argp1 = 0 ;
21716 int res1 = 0 ;
21717 PyObject *swig_obj[1] ;
21718
21719 if (!args) SWIG_fail;
21720 swig_obj[0] = args;
21721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21722 if (!SWIG_IsOK(res1)) {
21723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21724 }
21725 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21726 {
21727 PyThreadState* __tstate = wxPyBeginAllowThreads();
21728 delete arg1;
d55e5bfc 21729
1bd55598
RD
21730 wxPyEndAllowThreads(__tstate);
21731 if (PyErr_Occurred()) SWIG_fail;
21732 }
21733 resultobj = SWIG_Py_Void();
21734 return resultobj;
21735fail:
21736 return NULL;
d55e5bfc
RD
21737}
21738
21739
1bd55598
RD
21740SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21741 PyObject *obj;
21742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21743 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21744 return SWIG_Py_Void();
d55e5bfc
RD
21745}
21746
1bd55598
RD
21747SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21748 return SWIG_Python_InitShadowInstance(args);
21749}
d55e5bfc 21750
1bd55598
RD
21751SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21752 PyObject *resultobj = 0;
21753 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21754 int arg2 = (int) 0 ;
21755 wxCommandEvent *result = 0 ;
21756 int val1 ;
21757 int ecode1 = 0 ;
21758 int val2 ;
21759 int ecode2 = 0 ;
21760 PyObject * obj0 = 0 ;
21761 PyObject * obj1 = 0 ;
21762 char * kwnames[] = {
21763 (char *) "commandType",(char *) "winid", NULL
21764 };
21765
21766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21767 if (obj0) {
21768 ecode1 = SWIG_AsVal_int(obj0, &val1);
21769 if (!SWIG_IsOK(ecode1)) {
21770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21771 }
21772 arg1 = static_cast< wxEventType >(val1);
21773 }
21774 if (obj1) {
21775 ecode2 = SWIG_AsVal_int(obj1, &val2);
21776 if (!SWIG_IsOK(ecode2)) {
21777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21778 }
21779 arg2 = static_cast< int >(val2);
21780 }
21781 {
21782 PyThreadState* __tstate = wxPyBeginAllowThreads();
21783 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21784 wxPyEndAllowThreads(__tstate);
21785 if (PyErr_Occurred()) SWIG_fail;
21786 }
21787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21788 return resultobj;
21789fail:
21790 return NULL;
d55e5bfc
RD
21791}
21792
21793
1bd55598
RD
21794SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21795 PyObject *resultobj = 0;
21796 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21797 int result;
21798 void *argp1 = 0 ;
21799 int res1 = 0 ;
21800 PyObject *swig_obj[1] ;
21801
21802 if (!args) SWIG_fail;
21803 swig_obj[0] = args;
21804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21805 if (!SWIG_IsOK(res1)) {
21806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21807 }
21808 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21809 {
21810 PyThreadState* __tstate = wxPyBeginAllowThreads();
21811 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21812 wxPyEndAllowThreads(__tstate);
21813 if (PyErr_Occurred()) SWIG_fail;
21814 }
21815 resultobj = SWIG_From_int(static_cast< int >(result));
21816 return resultobj;
21817fail:
21818 return NULL;
21819}
21820
21821
21822SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21823 PyObject *resultobj = 0;
21824 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21825 wxString *arg2 = 0 ;
21826 void *argp1 = 0 ;
21827 int res1 = 0 ;
21828 bool temp2 = false ;
21829 PyObject * obj0 = 0 ;
21830 PyObject * obj1 = 0 ;
21831 char * kwnames[] = {
21832 (char *) "self",(char *) "s", NULL
21833 };
21834
21835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21837 if (!SWIG_IsOK(res1)) {
21838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21839 }
21840 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21841 {
21842 arg2 = wxString_in_helper(obj1);
21843 if (arg2 == NULL) SWIG_fail;
21844 temp2 = true;
21845 }
21846 {
21847 PyThreadState* __tstate = wxPyBeginAllowThreads();
21848 (arg1)->SetString((wxString const &)*arg2);
21849 wxPyEndAllowThreads(__tstate);
21850 if (PyErr_Occurred()) SWIG_fail;
21851 }
21852 resultobj = SWIG_Py_Void();
21853 {
21854 if (temp2)
21855 delete arg2;
21856 }
21857 return resultobj;
21858fail:
21859 {
21860 if (temp2)
21861 delete arg2;
21862 }
21863 return NULL;
d55e5bfc
RD
21864}
21865
21866
1bd55598
RD
21867SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21868 PyObject *resultobj = 0;
21869 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21870 wxString result;
21871 void *argp1 = 0 ;
21872 int res1 = 0 ;
21873 PyObject *swig_obj[1] ;
21874
21875 if (!args) SWIG_fail;
21876 swig_obj[0] = args;
21877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21878 if (!SWIG_IsOK(res1)) {
21879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21880 }
21881 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21882 {
21883 PyThreadState* __tstate = wxPyBeginAllowThreads();
21884 result = ((wxCommandEvent const *)arg1)->GetString();
21885 wxPyEndAllowThreads(__tstate);
21886 if (PyErr_Occurred()) SWIG_fail;
21887 }
21888 {
21889#if wxUSE_UNICODE
21890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21891#else
21892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21893#endif
21894 }
21895 return resultobj;
21896fail:
21897 return NULL;
d55e5bfc
RD
21898}
21899
21900
1bd55598
RD
21901SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21902 PyObject *resultobj = 0;
21903 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21904 bool result;
21905 void *argp1 = 0 ;
21906 int res1 = 0 ;
21907 PyObject *swig_obj[1] ;
21908
21909 if (!args) SWIG_fail;
21910 swig_obj[0] = args;
21911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21912 if (!SWIG_IsOK(res1)) {
21913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21914 }
21915 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21916 {
21917 PyThreadState* __tstate = wxPyBeginAllowThreads();
21918 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21919 wxPyEndAllowThreads(__tstate);
21920 if (PyErr_Occurred()) SWIG_fail;
21921 }
21922 {
21923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21924 }
21925 return resultobj;
21926fail:
21927 return NULL;
d55e5bfc
RD
21928}
21929
21930
1bd55598
RD
21931SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21932 PyObject *resultobj = 0;
21933 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21934 bool result;
21935 void *argp1 = 0 ;
21936 int res1 = 0 ;
21937 PyObject *swig_obj[1] ;
21938
21939 if (!args) SWIG_fail;
21940 swig_obj[0] = args;
21941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21942 if (!SWIG_IsOK(res1)) {
21943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21944 }
21945 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21946 {
21947 PyThreadState* __tstate = wxPyBeginAllowThreads();
21948 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
21949 wxPyEndAllowThreads(__tstate);
21950 if (PyErr_Occurred()) SWIG_fail;
21951 }
21952 {
21953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21954 }
21955 return resultobj;
21956fail:
21957 return NULL;
21958}
21959
21960
21961SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21962 PyObject *resultobj = 0;
21963 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21964 long arg2 ;
21965 void *argp1 = 0 ;
21966 int res1 = 0 ;
21967 long val2 ;
21968 int ecode2 = 0 ;
21969 PyObject * obj0 = 0 ;
21970 PyObject * obj1 = 0 ;
21971 char * kwnames[] = {
21972 (char *) "self",(char *) "extraLong", NULL
21973 };
21974
21975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
21976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21977 if (!SWIG_IsOK(res1)) {
21978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21979 }
21980 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21981 ecode2 = SWIG_AsVal_long(obj1, &val2);
21982 if (!SWIG_IsOK(ecode2)) {
21983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
21984 }
21985 arg2 = static_cast< long >(val2);
21986 {
21987 PyThreadState* __tstate = wxPyBeginAllowThreads();
21988 (arg1)->SetExtraLong(arg2);
21989 wxPyEndAllowThreads(__tstate);
21990 if (PyErr_Occurred()) SWIG_fail;
21991 }
21992 resultobj = SWIG_Py_Void();
21993 return resultobj;
21994fail:
21995 return NULL;
68350608
RD
21996}
21997
21998
1bd55598
RD
21999SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22000 PyObject *resultobj = 0;
22001 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22002 long result;
22003 void *argp1 = 0 ;
22004 int res1 = 0 ;
22005 PyObject *swig_obj[1] ;
22006
22007 if (!args) SWIG_fail;
22008 swig_obj[0] = args;
22009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22010 if (!SWIG_IsOK(res1)) {
22011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22012 }
22013 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22014 {
22015 PyThreadState* __tstate = wxPyBeginAllowThreads();
22016 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22017 wxPyEndAllowThreads(__tstate);
22018 if (PyErr_Occurred()) SWIG_fail;
22019 }
22020 resultobj = SWIG_From_long(static_cast< long >(result));
22021 return resultobj;
22022fail:
22023 return NULL;
22024}
22025
22026
22027SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22028 PyObject *resultobj = 0;
22029 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22030 int arg2 ;
22031 void *argp1 = 0 ;
22032 int res1 = 0 ;
22033 int val2 ;
22034 int ecode2 = 0 ;
22035 PyObject * obj0 = 0 ;
22036 PyObject * obj1 = 0 ;
22037 char * kwnames[] = {
22038 (char *) "self",(char *) "i", NULL
22039 };
22040
22041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22043 if (!SWIG_IsOK(res1)) {
22044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22045 }
22046 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22047 ecode2 = SWIG_AsVal_int(obj1, &val2);
22048 if (!SWIG_IsOK(ecode2)) {
22049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22050 }
22051 arg2 = static_cast< int >(val2);
22052 {
22053 PyThreadState* __tstate = wxPyBeginAllowThreads();
22054 (arg1)->SetInt(arg2);
22055 wxPyEndAllowThreads(__tstate);
22056 if (PyErr_Occurred()) SWIG_fail;
22057 }
22058 resultobj = SWIG_Py_Void();
22059 return resultobj;
22060fail:
22061 return NULL;
5b5c9bc7
RD
22062}
22063
22064
1bd55598
RD
22065SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22066 PyObject *resultobj = 0;
22067 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
2131d850 22068 int result;
1bd55598
RD
22069 void *argp1 = 0 ;
22070 int res1 = 0 ;
22071 PyObject *swig_obj[1] ;
22072
22073 if (!args) SWIG_fail;
22074 swig_obj[0] = args;
22075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22076 if (!SWIG_IsOK(res1)) {
22077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22078 }
22079 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22080 {
22081 PyThreadState* __tstate = wxPyBeginAllowThreads();
2131d850 22082 result = (int)((wxCommandEvent const *)arg1)->GetInt();
1bd55598
RD
22083 wxPyEndAllowThreads(__tstate);
22084 if (PyErr_Occurred()) SWIG_fail;
22085 }
2131d850 22086 resultobj = SWIG_From_int(static_cast< int >(result));
1bd55598
RD
22087 return resultobj;
22088fail:
22089 return NULL;
d55e5bfc
RD
22090}
22091
22092
1bd55598
RD
22093SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22094 PyObject *resultobj = 0;
22095 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22096 PyObject *result = 0 ;
22097 void *argp1 = 0 ;
22098 int res1 = 0 ;
22099 PyObject *swig_obj[1] ;
22100
22101 if (!args) SWIG_fail;
22102 swig_obj[0] = args;
22103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22104 if (!SWIG_IsOK(res1)) {
22105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22106 }
22107 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22108 {
22109 PyThreadState* __tstate = wxPyBeginAllowThreads();
22110 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22111 wxPyEndAllowThreads(__tstate);
22112 if (PyErr_Occurred()) SWIG_fail;
22113 }
22114 resultobj = result;
22115 return resultobj;
22116fail:
22117 return NULL;
22118}
22119
22120
22121SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22122 PyObject *resultobj = 0;
22123 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22124 PyObject *arg2 = (PyObject *) 0 ;
22125 void *argp1 = 0 ;
22126 int res1 = 0 ;
22127 PyObject * obj0 = 0 ;
22128 PyObject * obj1 = 0 ;
22129 char * kwnames[] = {
22130 (char *) "self",(char *) "clientData", NULL
22131 };
22132
22133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22135 if (!SWIG_IsOK(res1)) {
22136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22137 }
22138 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22139 arg2 = obj1;
22140 {
22141 PyThreadState* __tstate = wxPyBeginAllowThreads();
22142 wxCommandEvent_SetClientData(arg1,arg2);
22143 wxPyEndAllowThreads(__tstate);
22144 if (PyErr_Occurred()) SWIG_fail;
22145 }
22146 resultobj = SWIG_Py_Void();
22147 return resultobj;
22148fail:
22149 return NULL;
4cf4100f
RD
22150}
22151
22152
1bd55598
RD
22153SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22154 PyObject *resultobj = 0;
22155 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22156 wxEvent *result = 0 ;
22157 void *argp1 = 0 ;
22158 int res1 = 0 ;
22159 PyObject *swig_obj[1] ;
22160
22161 if (!args) SWIG_fail;
22162 swig_obj[0] = args;
22163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22164 if (!SWIG_IsOK(res1)) {
22165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22166 }
22167 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22168 {
22169 PyThreadState* __tstate = wxPyBeginAllowThreads();
22170 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22171 wxPyEndAllowThreads(__tstate);
22172 if (PyErr_Occurred()) SWIG_fail;
22173 }
22174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22175 return resultobj;
22176fail:
22177 return NULL;
8fb0e70a
RD
22178}
22179
22180
1bd55598
RD
22181SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22182 PyObject *obj;
22183 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22184 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22185 return SWIG_Py_Void();
d55e5bfc
RD
22186}
22187
1bd55598
RD
22188SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22189 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
22190}
22191
1bd55598
RD
22192SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22193 PyObject *resultobj = 0;
22194 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22195 int arg2 = (int) 0 ;
22196 wxNotifyEvent *result = 0 ;
22197 int val1 ;
22198 int ecode1 = 0 ;
22199 int val2 ;
22200 int ecode2 = 0 ;
22201 PyObject * obj0 = 0 ;
22202 PyObject * obj1 = 0 ;
22203 char * kwnames[] = {
22204 (char *) "commandType",(char *) "winid", NULL
22205 };
22206
22207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22208 if (obj0) {
22209 ecode1 = SWIG_AsVal_int(obj0, &val1);
22210 if (!SWIG_IsOK(ecode1)) {
22211 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22212 }
22213 arg1 = static_cast< wxEventType >(val1);
22214 }
22215 if (obj1) {
22216 ecode2 = SWIG_AsVal_int(obj1, &val2);
22217 if (!SWIG_IsOK(ecode2)) {
22218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22219 }
22220 arg2 = static_cast< int >(val2);
22221 }
22222 {
22223 PyThreadState* __tstate = wxPyBeginAllowThreads();
22224 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22225 wxPyEndAllowThreads(__tstate);
22226 if (PyErr_Occurred()) SWIG_fail;
22227 }
22228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22229 return resultobj;
22230fail:
22231 return NULL;
d55e5bfc
RD
22232}
22233
22234
1bd55598
RD
22235SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22236 PyObject *resultobj = 0;
22237 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22238 void *argp1 = 0 ;
22239 int res1 = 0 ;
22240 PyObject *swig_obj[1] ;
22241
22242 if (!args) SWIG_fail;
22243 swig_obj[0] = args;
22244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22245 if (!SWIG_IsOK(res1)) {
22246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22247 }
22248 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22249 {
22250 PyThreadState* __tstate = wxPyBeginAllowThreads();
22251 (arg1)->Veto();
22252 wxPyEndAllowThreads(__tstate);
22253 if (PyErr_Occurred()) SWIG_fail;
22254 }
22255 resultobj = SWIG_Py_Void();
22256 return resultobj;
22257fail:
22258 return NULL;
d55e5bfc
RD
22259}
22260
22261
1bd55598
RD
22262SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22263 PyObject *resultobj = 0;
22264 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22265 void *argp1 = 0 ;
22266 int res1 = 0 ;
22267 PyObject *swig_obj[1] ;
22268
22269 if (!args) SWIG_fail;
22270 swig_obj[0] = args;
22271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22272 if (!SWIG_IsOK(res1)) {
22273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22274 }
22275 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22276 {
22277 PyThreadState* __tstate = wxPyBeginAllowThreads();
22278 (arg1)->Allow();
22279 wxPyEndAllowThreads(__tstate);
22280 if (PyErr_Occurred()) SWIG_fail;
22281 }
22282 resultobj = SWIG_Py_Void();
22283 return resultobj;
22284fail:
22285 return NULL;
d55e5bfc
RD
22286}
22287
22288
1bd55598
RD
22289SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22290 PyObject *resultobj = 0;
22291 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22292 bool result;
22293 void *argp1 = 0 ;
22294 int res1 = 0 ;
22295 PyObject *swig_obj[1] ;
22296
22297 if (!args) SWIG_fail;
22298 swig_obj[0] = args;
22299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22300 if (!SWIG_IsOK(res1)) {
22301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22302 }
22303 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22304 {
22305 PyThreadState* __tstate = wxPyBeginAllowThreads();
22306 result = (bool)(arg1)->IsAllowed();
22307 wxPyEndAllowThreads(__tstate);
22308 if (PyErr_Occurred()) SWIG_fail;
22309 }
22310 {
22311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22312 }
22313 return resultobj;
22314fail:
22315 return NULL;
22316}
22317
22318
22319SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22320 PyObject *obj;
22321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22322 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22323 return SWIG_Py_Void();
22324}
22325
22326SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22327 return SWIG_Python_InitShadowInstance(args);
22328}
22329
22330SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22331 PyObject *resultobj = 0;
22332 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22333 int arg2 = (int) 0 ;
22334 int arg3 = (int) 0 ;
22335 int arg4 = (int) 0 ;
22336 wxScrollEvent *result = 0 ;
22337 int val1 ;
22338 int ecode1 = 0 ;
22339 int val2 ;
22340 int ecode2 = 0 ;
22341 int val3 ;
22342 int ecode3 = 0 ;
22343 int val4 ;
22344 int ecode4 = 0 ;
22345 PyObject * obj0 = 0 ;
22346 PyObject * obj1 = 0 ;
22347 PyObject * obj2 = 0 ;
22348 PyObject * obj3 = 0 ;
22349 char * kwnames[] = {
22350 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22351 };
22352
22353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22354 if (obj0) {
22355 ecode1 = SWIG_AsVal_int(obj0, &val1);
22356 if (!SWIG_IsOK(ecode1)) {
22357 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22358 }
22359 arg1 = static_cast< wxEventType >(val1);
22360 }
22361 if (obj1) {
22362 ecode2 = SWIG_AsVal_int(obj1, &val2);
22363 if (!SWIG_IsOK(ecode2)) {
22364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22365 }
22366 arg2 = static_cast< int >(val2);
22367 }
22368 if (obj2) {
22369 ecode3 = SWIG_AsVal_int(obj2, &val3);
22370 if (!SWIG_IsOK(ecode3)) {
22371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22372 }
22373 arg3 = static_cast< int >(val3);
22374 }
22375 if (obj3) {
22376 ecode4 = SWIG_AsVal_int(obj3, &val4);
22377 if (!SWIG_IsOK(ecode4)) {
22378 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22379 }
22380 arg4 = static_cast< int >(val4);
22381 }
22382 {
22383 PyThreadState* __tstate = wxPyBeginAllowThreads();
22384 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22385 wxPyEndAllowThreads(__tstate);
22386 if (PyErr_Occurred()) SWIG_fail;
22387 }
22388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22389 return resultobj;
22390fail:
22391 return NULL;
d55e5bfc
RD
22392}
22393
22394
1bd55598
RD
22395SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22396 PyObject *resultobj = 0;
22397 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22398 int result;
22399 void *argp1 = 0 ;
22400 int res1 = 0 ;
22401 PyObject *swig_obj[1] ;
22402
22403 if (!args) SWIG_fail;
22404 swig_obj[0] = args;
22405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22406 if (!SWIG_IsOK(res1)) {
22407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22408 }
22409 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22410 {
22411 PyThreadState* __tstate = wxPyBeginAllowThreads();
22412 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22413 wxPyEndAllowThreads(__tstate);
22414 if (PyErr_Occurred()) SWIG_fail;
22415 }
22416 resultobj = SWIG_From_int(static_cast< int >(result));
22417 return resultobj;
22418fail:
22419 return NULL;
d55e5bfc
RD
22420}
22421
22422
1bd55598
RD
22423SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22424 PyObject *resultobj = 0;
22425 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22426 int result;
22427 void *argp1 = 0 ;
22428 int res1 = 0 ;
22429 PyObject *swig_obj[1] ;
22430
22431 if (!args) SWIG_fail;
22432 swig_obj[0] = args;
22433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22434 if (!SWIG_IsOK(res1)) {
22435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22436 }
22437 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22438 {
22439 PyThreadState* __tstate = wxPyBeginAllowThreads();
22440 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22441 wxPyEndAllowThreads(__tstate);
22442 if (PyErr_Occurred()) SWIG_fail;
22443 }
22444 resultobj = SWIG_From_int(static_cast< int >(result));
22445 return resultobj;
22446fail:
22447 return NULL;
22448}
22449
22450
22451SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22452 PyObject *resultobj = 0;
22453 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22454 int arg2 ;
22455 void *argp1 = 0 ;
22456 int res1 = 0 ;
22457 int val2 ;
22458 int ecode2 = 0 ;
22459 PyObject * obj0 = 0 ;
22460 PyObject * obj1 = 0 ;
22461 char * kwnames[] = {
22462 (char *) "self",(char *) "orient", NULL
22463 };
22464
22465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22467 if (!SWIG_IsOK(res1)) {
22468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22469 }
22470 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22471 ecode2 = SWIG_AsVal_int(obj1, &val2);
22472 if (!SWIG_IsOK(ecode2)) {
22473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22474 }
22475 arg2 = static_cast< int >(val2);
22476 {
22477 PyThreadState* __tstate = wxPyBeginAllowThreads();
22478 (arg1)->SetOrientation(arg2);
22479 wxPyEndAllowThreads(__tstate);
22480 if (PyErr_Occurred()) SWIG_fail;
22481 }
22482 resultobj = SWIG_Py_Void();
22483 return resultobj;
22484fail:
22485 return NULL;
22486}
22487
22488
22489SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22490 PyObject *resultobj = 0;
22491 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22492 int arg2 ;
22493 void *argp1 = 0 ;
22494 int res1 = 0 ;
22495 int val2 ;
22496 int ecode2 = 0 ;
22497 PyObject * obj0 = 0 ;
22498 PyObject * obj1 = 0 ;
22499 char * kwnames[] = {
22500 (char *) "self",(char *) "pos", NULL
22501 };
22502
22503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22505 if (!SWIG_IsOK(res1)) {
22506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22507 }
22508 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22509 ecode2 = SWIG_AsVal_int(obj1, &val2);
22510 if (!SWIG_IsOK(ecode2)) {
22511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22512 }
22513 arg2 = static_cast< int >(val2);
22514 {
22515 PyThreadState* __tstate = wxPyBeginAllowThreads();
22516 (arg1)->SetPosition(arg2);
22517 wxPyEndAllowThreads(__tstate);
22518 if (PyErr_Occurred()) SWIG_fail;
22519 }
22520 resultobj = SWIG_Py_Void();
22521 return resultobj;
22522fail:
22523 return NULL;
22524}
22525
22526
22527SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22528 PyObject *obj;
22529 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22530 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22531 return SWIG_Py_Void();
22532}
22533
22534SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22535 return SWIG_Python_InitShadowInstance(args);
22536}
22537
22538SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22539 PyObject *resultobj = 0;
22540 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22541 int arg2 = (int) 0 ;
22542 int arg3 = (int) 0 ;
22543 wxScrollWinEvent *result = 0 ;
22544 int val1 ;
22545 int ecode1 = 0 ;
22546 int val2 ;
22547 int ecode2 = 0 ;
22548 int val3 ;
22549 int ecode3 = 0 ;
22550 PyObject * obj0 = 0 ;
22551 PyObject * obj1 = 0 ;
22552 PyObject * obj2 = 0 ;
22553 char * kwnames[] = {
22554 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22555 };
22556
22557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22558 if (obj0) {
22559 ecode1 = SWIG_AsVal_int(obj0, &val1);
22560 if (!SWIG_IsOK(ecode1)) {
22561 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22562 }
22563 arg1 = static_cast< wxEventType >(val1);
22564 }
22565 if (obj1) {
22566 ecode2 = SWIG_AsVal_int(obj1, &val2);
22567 if (!SWIG_IsOK(ecode2)) {
22568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22569 }
22570 arg2 = static_cast< int >(val2);
22571 }
22572 if (obj2) {
22573 ecode3 = SWIG_AsVal_int(obj2, &val3);
22574 if (!SWIG_IsOK(ecode3)) {
22575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22576 }
22577 arg3 = static_cast< int >(val3);
22578 }
22579 {
22580 PyThreadState* __tstate = wxPyBeginAllowThreads();
22581 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22582 wxPyEndAllowThreads(__tstate);
22583 if (PyErr_Occurred()) SWIG_fail;
22584 }
22585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22586 return resultobj;
22587fail:
22588 return NULL;
d55e5bfc
RD
22589}
22590
22591
1bd55598
RD
22592SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22593 PyObject *resultobj = 0;
22594 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22595 int result;
22596 void *argp1 = 0 ;
22597 int res1 = 0 ;
22598 PyObject *swig_obj[1] ;
22599
22600 if (!args) SWIG_fail;
22601 swig_obj[0] = args;
22602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22603 if (!SWIG_IsOK(res1)) {
22604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22605 }
22606 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22607 {
22608 PyThreadState* __tstate = wxPyBeginAllowThreads();
22609 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22610 wxPyEndAllowThreads(__tstate);
22611 if (PyErr_Occurred()) SWIG_fail;
22612 }
22613 resultobj = SWIG_From_int(static_cast< int >(result));
22614 return resultobj;
22615fail:
22616 return NULL;
d55e5bfc
RD
22617}
22618
22619
1bd55598
RD
22620SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22621 PyObject *resultobj = 0;
22622 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22623 int result;
22624 void *argp1 = 0 ;
22625 int res1 = 0 ;
22626 PyObject *swig_obj[1] ;
22627
22628 if (!args) SWIG_fail;
22629 swig_obj[0] = args;
22630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22631 if (!SWIG_IsOK(res1)) {
22632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22633 }
22634 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22635 {
22636 PyThreadState* __tstate = wxPyBeginAllowThreads();
22637 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22638 wxPyEndAllowThreads(__tstate);
22639 if (PyErr_Occurred()) SWIG_fail;
22640 }
22641 resultobj = SWIG_From_int(static_cast< int >(result));
22642 return resultobj;
22643fail:
22644 return NULL;
22645}
22646
22647
22648SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22649 PyObject *resultobj = 0;
22650 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22651 int arg2 ;
22652 void *argp1 = 0 ;
22653 int res1 = 0 ;
22654 int val2 ;
22655 int ecode2 = 0 ;
22656 PyObject * obj0 = 0 ;
22657 PyObject * obj1 = 0 ;
22658 char * kwnames[] = {
22659 (char *) "self",(char *) "orient", NULL
22660 };
22661
22662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22664 if (!SWIG_IsOK(res1)) {
22665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22666 }
22667 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22668 ecode2 = SWIG_AsVal_int(obj1, &val2);
22669 if (!SWIG_IsOK(ecode2)) {
22670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22671 }
22672 arg2 = static_cast< int >(val2);
22673 {
22674 PyThreadState* __tstate = wxPyBeginAllowThreads();
22675 (arg1)->SetOrientation(arg2);
22676 wxPyEndAllowThreads(__tstate);
22677 if (PyErr_Occurred()) SWIG_fail;
22678 }
22679 resultobj = SWIG_Py_Void();
22680 return resultobj;
22681fail:
22682 return NULL;
22683}
22684
22685
22686SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22687 PyObject *resultobj = 0;
22688 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22689 int arg2 ;
22690 void *argp1 = 0 ;
22691 int res1 = 0 ;
22692 int val2 ;
22693 int ecode2 = 0 ;
22694 PyObject * obj0 = 0 ;
22695 PyObject * obj1 = 0 ;
22696 char * kwnames[] = {
22697 (char *) "self",(char *) "pos", NULL
22698 };
22699
22700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22702 if (!SWIG_IsOK(res1)) {
22703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22704 }
22705 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22706 ecode2 = SWIG_AsVal_int(obj1, &val2);
22707 if (!SWIG_IsOK(ecode2)) {
22708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22709 }
22710 arg2 = static_cast< int >(val2);
22711 {
22712 PyThreadState* __tstate = wxPyBeginAllowThreads();
22713 (arg1)->SetPosition(arg2);
22714 wxPyEndAllowThreads(__tstate);
22715 if (PyErr_Occurred()) SWIG_fail;
22716 }
22717 resultobj = SWIG_Py_Void();
22718 return resultobj;
22719fail:
22720 return NULL;
d55e5bfc
RD
22721}
22722
22723
1bd55598
RD
22724SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22725 PyObject *obj;
22726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22727 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22728 return SWIG_Py_Void();
d55e5bfc
RD
22729}
22730
1bd55598
RD
22731SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22732 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
22733}
22734
1bd55598
RD
22735SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22736 PyObject *resultobj = 0;
22737 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22738 wxMouseEvent *result = 0 ;
22739 int val1 ;
22740 int ecode1 = 0 ;
22741 PyObject * obj0 = 0 ;
22742 char * kwnames[] = {
22743 (char *) "mouseType", NULL
22744 };
22745
22746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22747 if (obj0) {
22748 ecode1 = SWIG_AsVal_int(obj0, &val1);
22749 if (!SWIG_IsOK(ecode1)) {
22750 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22751 }
22752 arg1 = static_cast< wxEventType >(val1);
22753 }
22754 {
22755 PyThreadState* __tstate = wxPyBeginAllowThreads();
22756 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22757 wxPyEndAllowThreads(__tstate);
22758 if (PyErr_Occurred()) SWIG_fail;
22759 }
3ecece7e 22760 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
1bd55598
RD
22761 return resultobj;
22762fail:
22763 return NULL;
d55e5bfc
RD
22764}
22765
22766
1bd55598
RD
22767SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22768 PyObject *resultobj = 0;
22769 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22770 bool result;
22771 void *argp1 = 0 ;
22772 int res1 = 0 ;
22773 PyObject *swig_obj[1] ;
22774
22775 if (!args) SWIG_fail;
22776 swig_obj[0] = args;
22777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22778 if (!SWIG_IsOK(res1)) {
22779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22780 }
22781 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22782 {
22783 PyThreadState* __tstate = wxPyBeginAllowThreads();
22784 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22785 wxPyEndAllowThreads(__tstate);
22786 if (PyErr_Occurred()) SWIG_fail;
22787 }
22788 {
22789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22790 }
22791 return resultobj;
22792fail:
22793 return NULL;
22794}
22795
22796
22797SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22798 PyObject *resultobj = 0;
22799 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22800 int arg2 = (int) wxMOUSE_BTN_ANY ;
22801 bool result;
22802 void *argp1 = 0 ;
22803 int res1 = 0 ;
22804 int val2 ;
22805 int ecode2 = 0 ;
22806 PyObject * obj0 = 0 ;
22807 PyObject * obj1 = 0 ;
22808 char * kwnames[] = {
22809 (char *) "self",(char *) "but", NULL
22810 };
22811
22812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22814 if (!SWIG_IsOK(res1)) {
22815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22816 }
22817 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22818 if (obj1) {
22819 ecode2 = SWIG_AsVal_int(obj1, &val2);
22820 if (!SWIG_IsOK(ecode2)) {
22821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22822 }
22823 arg2 = static_cast< int >(val2);
22824 }
22825 {
22826 PyThreadState* __tstate = wxPyBeginAllowThreads();
22827 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22828 wxPyEndAllowThreads(__tstate);
22829 if (PyErr_Occurred()) SWIG_fail;
22830 }
22831 {
22832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22833 }
22834 return resultobj;
22835fail:
22836 return NULL;
22837}
22838
22839
22840SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22841 PyObject *resultobj = 0;
22842 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22843 int arg2 = (int) wxMOUSE_BTN_ANY ;
22844 bool result;
22845 void *argp1 = 0 ;
22846 int res1 = 0 ;
22847 int val2 ;
22848 int ecode2 = 0 ;
22849 PyObject * obj0 = 0 ;
22850 PyObject * obj1 = 0 ;
22851 char * kwnames[] = {
22852 (char *) "self",(char *) "but", NULL
22853 };
22854
22855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22857 if (!SWIG_IsOK(res1)) {
22858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22859 }
22860 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22861 if (obj1) {
22862 ecode2 = SWIG_AsVal_int(obj1, &val2);
22863 if (!SWIG_IsOK(ecode2)) {
22864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22865 }
22866 arg2 = static_cast< int >(val2);
22867 }
22868 {
22869 PyThreadState* __tstate = wxPyBeginAllowThreads();
22870 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22871 wxPyEndAllowThreads(__tstate);
22872 if (PyErr_Occurred()) SWIG_fail;
22873 }
22874 {
22875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22876 }
22877 return resultobj;
22878fail:
22879 return NULL;
22880}
22881
22882
22883SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22884 PyObject *resultobj = 0;
22885 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22886 int arg2 = (int) wxMOUSE_BTN_ANY ;
22887 bool result;
22888 void *argp1 = 0 ;
22889 int res1 = 0 ;
22890 int val2 ;
22891 int ecode2 = 0 ;
22892 PyObject * obj0 = 0 ;
22893 PyObject * obj1 = 0 ;
22894 char * kwnames[] = {
22895 (char *) "self",(char *) "but", NULL
22896 };
22897
22898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22900 if (!SWIG_IsOK(res1)) {
22901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22902 }
22903 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22904 if (obj1) {
22905 ecode2 = SWIG_AsVal_int(obj1, &val2);
22906 if (!SWIG_IsOK(ecode2)) {
22907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22908 }
22909 arg2 = static_cast< int >(val2);
22910 }
22911 {
22912 PyThreadState* __tstate = wxPyBeginAllowThreads();
22913 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22914 wxPyEndAllowThreads(__tstate);
22915 if (PyErr_Occurred()) SWIG_fail;
22916 }
22917 {
22918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22919 }
22920 return resultobj;
22921fail:
22922 return NULL;
22923}
22924
22925
22926SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22927 PyObject *resultobj = 0;
22928 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22929 int arg2 ;
22930 bool result;
22931 void *argp1 = 0 ;
22932 int res1 = 0 ;
22933 int val2 ;
22934 int ecode2 = 0 ;
22935 PyObject * obj0 = 0 ;
22936 PyObject * obj1 = 0 ;
22937 char * kwnames[] = {
22938 (char *) "self",(char *) "button", NULL
22939 };
22940
22941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
22942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22943 if (!SWIG_IsOK(res1)) {
22944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22945 }
22946 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22947 ecode2 = SWIG_AsVal_int(obj1, &val2);
22948 if (!SWIG_IsOK(ecode2)) {
22949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
22950 }
22951 arg2 = static_cast< int >(val2);
22952 {
22953 PyThreadState* __tstate = wxPyBeginAllowThreads();
22954 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
22955 wxPyEndAllowThreads(__tstate);
22956 if (PyErr_Occurred()) SWIG_fail;
22957 }
22958 {
22959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22960 }
22961 return resultobj;
22962fail:
22963 return NULL;
22964}
22965
22966
22967SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22968 PyObject *resultobj = 0;
22969 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22970 int arg2 ;
22971 bool result;
22972 void *argp1 = 0 ;
22973 int res1 = 0 ;
22974 int val2 ;
22975 int ecode2 = 0 ;
22976 PyObject * obj0 = 0 ;
22977 PyObject * obj1 = 0 ;
22978 char * kwnames[] = {
22979 (char *) "self",(char *) "but", NULL
22980 };
22981
22982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
22983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22984 if (!SWIG_IsOK(res1)) {
22985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22986 }
22987 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22988 ecode2 = SWIG_AsVal_int(obj1, &val2);
22989 if (!SWIG_IsOK(ecode2)) {
22990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
22991 }
22992 arg2 = static_cast< int >(val2);
22993 {
22994 PyThreadState* __tstate = wxPyBeginAllowThreads();
22995 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
22996 wxPyEndAllowThreads(__tstate);
22997 if (PyErr_Occurred()) SWIG_fail;
22998 }
22999 {
23000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23001 }
23002 return resultobj;
23003fail:
23004 return NULL;
d55e5bfc
RD
23005}
23006
23007
1bd55598
RD
23008SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23009 PyObject *resultobj = 0;
23010 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23011 int result;
23012 void *argp1 = 0 ;
23013 int res1 = 0 ;
23014 PyObject *swig_obj[1] ;
23015
23016 if (!args) SWIG_fail;
23017 swig_obj[0] = args;
23018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23019 if (!SWIG_IsOK(res1)) {
23020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23021 }
23022 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23023 {
23024 PyThreadState* __tstate = wxPyBeginAllowThreads();
23025 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23026 wxPyEndAllowThreads(__tstate);
23027 if (PyErr_Occurred()) SWIG_fail;
23028 }
23029 resultobj = SWIG_From_int(static_cast< int >(result));
23030 return resultobj;
23031fail:
23032 return NULL;
d55e5bfc
RD
23033}
23034
23035
1bd55598
RD
23036SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23037 PyObject *resultobj = 0;
23038 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23039 bool result;
23040 void *argp1 = 0 ;
23041 int res1 = 0 ;
23042 PyObject *swig_obj[1] ;
23043
23044 if (!args) SWIG_fail;
23045 swig_obj[0] = args;
23046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23047 if (!SWIG_IsOK(res1)) {
23048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23049 }
23050 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23051 {
23052 PyThreadState* __tstate = wxPyBeginAllowThreads();
23053 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23054 wxPyEndAllowThreads(__tstate);
23055 if (PyErr_Occurred()) SWIG_fail;
23056 }
23057 {
23058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23059 }
23060 return resultobj;
23061fail:
23062 return NULL;
aff4cc5c
RD
23063}
23064
23065
1bd55598
RD
23066SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23067 PyObject *resultobj = 0;
23068 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23069 bool result;
23070 void *argp1 = 0 ;
23071 int res1 = 0 ;
23072 PyObject *swig_obj[1] ;
23073
23074 if (!args) SWIG_fail;
23075 swig_obj[0] = args;
23076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23077 if (!SWIG_IsOK(res1)) {
23078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23079 }
23080 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23081 {
23082 PyThreadState* __tstate = wxPyBeginAllowThreads();
23083 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23084 wxPyEndAllowThreads(__tstate);
23085 if (PyErr_Occurred()) SWIG_fail;
23086 }
23087 {
23088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23089 }
23090 return resultobj;
23091fail:
23092 return NULL;
d55e5bfc
RD
23093}
23094
23095
1bd55598
RD
23096SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23097 PyObject *resultobj = 0;
23098 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23099 bool result;
23100 void *argp1 = 0 ;
23101 int res1 = 0 ;
23102 PyObject *swig_obj[1] ;
23103
23104 if (!args) SWIG_fail;
23105 swig_obj[0] = args;
23106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23107 if (!SWIG_IsOK(res1)) {
23108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23109 }
23110 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23111 {
23112 PyThreadState* __tstate = wxPyBeginAllowThreads();
23113 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23114 wxPyEndAllowThreads(__tstate);
23115 if (PyErr_Occurred()) SWIG_fail;
23116 }
23117 {
23118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23119 }
23120 return resultobj;
23121fail:
23122 return NULL;
d55e5bfc
RD
23123}
23124
23125
1bd55598
RD
23126SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23127 PyObject *resultobj = 0;
23128 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23129 bool result;
23130 void *argp1 = 0 ;
23131 int res1 = 0 ;
23132 PyObject *swig_obj[1] ;
23133
23134 if (!args) SWIG_fail;
23135 swig_obj[0] = args;
23136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23137 if (!SWIG_IsOK(res1)) {
23138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23139 }
23140 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23141 {
23142 PyThreadState* __tstate = wxPyBeginAllowThreads();
23143 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23144 wxPyEndAllowThreads(__tstate);
23145 if (PyErr_Occurred()) SWIG_fail;
23146 }
23147 {
23148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23149 }
23150 return resultobj;
23151fail:
23152 return NULL;
d55e5bfc
RD
23153}
23154
23155
1bd55598
RD
23156SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23157 PyObject *resultobj = 0;
23158 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23159 bool result;
23160 void *argp1 = 0 ;
23161 int res1 = 0 ;
23162 PyObject *swig_obj[1] ;
23163
23164 if (!args) SWIG_fail;
23165 swig_obj[0] = args;
23166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23167 if (!SWIG_IsOK(res1)) {
23168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23169 }
23170 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23171 {
23172 PyThreadState* __tstate = wxPyBeginAllowThreads();
23173 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23174 wxPyEndAllowThreads(__tstate);
23175 if (PyErr_Occurred()) SWIG_fail;
23176 }
23177 {
23178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23179 }
23180 return resultobj;
23181fail:
23182 return NULL;
d55e5bfc
RD
23183}
23184
23185
1bd55598
RD
23186SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23187 PyObject *resultobj = 0;
23188 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23189 bool result;
23190 void *argp1 = 0 ;
23191 int res1 = 0 ;
23192 PyObject *swig_obj[1] ;
23193
23194 if (!args) SWIG_fail;
23195 swig_obj[0] = args;
23196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23197 if (!SWIG_IsOK(res1)) {
23198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23199 }
23200 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23201 {
23202 PyThreadState* __tstate = wxPyBeginAllowThreads();
23203 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23204 wxPyEndAllowThreads(__tstate);
23205 if (PyErr_Occurred()) SWIG_fail;
23206 }
23207 {
23208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23209 }
23210 return resultobj;
23211fail:
23212 return NULL;
d55e5bfc
RD
23213}
23214
23215
1bd55598
RD
23216SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23217 PyObject *resultobj = 0;
23218 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23219 bool result;
23220 void *argp1 = 0 ;
23221 int res1 = 0 ;
23222 PyObject *swig_obj[1] ;
23223
23224 if (!args) SWIG_fail;
23225 swig_obj[0] = args;
23226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23227 if (!SWIG_IsOK(res1)) {
23228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23229 }
23230 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23231 {
23232 PyThreadState* __tstate = wxPyBeginAllowThreads();
23233 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23234 wxPyEndAllowThreads(__tstate);
23235 if (PyErr_Occurred()) SWIG_fail;
23236 }
23237 {
23238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23239 }
23240 return resultobj;
23241fail:
23242 return NULL;
d55e5bfc
RD
23243}
23244
23245
1bd55598
RD
23246SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23247 PyObject *resultobj = 0;
23248 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23249 bool result;
23250 void *argp1 = 0 ;
23251 int res1 = 0 ;
23252 PyObject *swig_obj[1] ;
23253
23254 if (!args) SWIG_fail;
23255 swig_obj[0] = args;
23256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23257 if (!SWIG_IsOK(res1)) {
23258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23259 }
23260 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23261 {
23262 PyThreadState* __tstate = wxPyBeginAllowThreads();
23263 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23264 wxPyEndAllowThreads(__tstate);
23265 if (PyErr_Occurred()) SWIG_fail;
23266 }
23267 {
23268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23269 }
23270 return resultobj;
23271fail:
23272 return NULL;
d55e5bfc
RD
23273}
23274
23275
1bd55598
RD
23276SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23277 PyObject *resultobj = 0;
23278 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23279 bool result;
23280 void *argp1 = 0 ;
23281 int res1 = 0 ;
23282 PyObject *swig_obj[1] ;
23283
23284 if (!args) SWIG_fail;
23285 swig_obj[0] = args;
23286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23287 if (!SWIG_IsOK(res1)) {
23288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23289 }
23290 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23291 {
23292 PyThreadState* __tstate = wxPyBeginAllowThreads();
23293 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23294 wxPyEndAllowThreads(__tstate);
23295 if (PyErr_Occurred()) SWIG_fail;
23296 }
23297 {
23298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23299 }
23300 return resultobj;
23301fail:
23302 return NULL;
d55e5bfc
RD
23303}
23304
23305
1bd55598
RD
23306SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23307 PyObject *resultobj = 0;
23308 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23309 bool result;
23310 void *argp1 = 0 ;
23311 int res1 = 0 ;
23312 PyObject *swig_obj[1] ;
23313
23314 if (!args) SWIG_fail;
23315 swig_obj[0] = args;
23316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23317 if (!SWIG_IsOK(res1)) {
23318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23319 }
23320 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23321 {
23322 PyThreadState* __tstate = wxPyBeginAllowThreads();
23323 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23324 wxPyEndAllowThreads(__tstate);
23325 if (PyErr_Occurred()) SWIG_fail;
23326 }
23327 {
23328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23329 }
23330 return resultobj;
23331fail:
23332 return NULL;
d55e5bfc
RD
23333}
23334
23335
1bd55598
RD
23336SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23337 PyObject *resultobj = 0;
23338 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23339 bool result;
23340 void *argp1 = 0 ;
23341 int res1 = 0 ;
23342 PyObject *swig_obj[1] ;
23343
23344 if (!args) SWIG_fail;
23345 swig_obj[0] = args;
23346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23347 if (!SWIG_IsOK(res1)) {
23348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23349 }
23350 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23351 {
23352 PyThreadState* __tstate = wxPyBeginAllowThreads();
23353 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23354 wxPyEndAllowThreads(__tstate);
23355 if (PyErr_Occurred()) SWIG_fail;
23356 }
23357 {
23358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23359 }
23360 return resultobj;
23361fail:
23362 return NULL;
d55e5bfc
RD
23363}
23364
23365
1bd55598
RD
23366SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23367 PyObject *resultobj = 0;
23368 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23369 bool result;
23370 void *argp1 = 0 ;
23371 int res1 = 0 ;
23372 PyObject *swig_obj[1] ;
23373
23374 if (!args) SWIG_fail;
23375 swig_obj[0] = args;
23376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23377 if (!SWIG_IsOK(res1)) {
23378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23379 }
23380 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23381 {
23382 PyThreadState* __tstate = wxPyBeginAllowThreads();
23383 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23384 wxPyEndAllowThreads(__tstate);
23385 if (PyErr_Occurred()) SWIG_fail;
23386 }
23387 {
23388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23389 }
23390 return resultobj;
23391fail:
23392 return NULL;
d55e5bfc
RD
23393}
23394
23395
1bd55598
RD
23396SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23397 PyObject *resultobj = 0;
23398 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23399 bool result;
23400 void *argp1 = 0 ;
23401 int res1 = 0 ;
23402 PyObject *swig_obj[1] ;
23403
23404 if (!args) SWIG_fail;
23405 swig_obj[0] = args;
23406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23407 if (!SWIG_IsOK(res1)) {
23408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23409 }
23410 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23411 {
23412 PyThreadState* __tstate = wxPyBeginAllowThreads();
23413 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23414 wxPyEndAllowThreads(__tstate);
23415 if (PyErr_Occurred()) SWIG_fail;
23416 }
23417 {
23418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23419 }
23420 return resultobj;
23421fail:
23422 return NULL;
aff4cc5c
RD
23423}
23424
23425
1bd55598
RD
23426SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23427 PyObject *resultobj = 0;
23428 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23429 bool result;
23430 void *argp1 = 0 ;
23431 int res1 = 0 ;
23432 PyObject *swig_obj[1] ;
23433
23434 if (!args) SWIG_fail;
23435 swig_obj[0] = args;
23436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23437 if (!SWIG_IsOK(res1)) {
23438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23439 }
23440 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23441 {
23442 PyThreadState* __tstate = wxPyBeginAllowThreads();
23443 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23444 wxPyEndAllowThreads(__tstate);
23445 if (PyErr_Occurred()) SWIG_fail;
23446 }
23447 {
23448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23449 }
23450 return resultobj;
23451fail:
23452 return NULL;
d55e5bfc
RD
23453}
23454
23455
1bd55598
RD
23456SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23457 PyObject *resultobj = 0;
23458 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23459 bool result;
23460 void *argp1 = 0 ;
23461 int res1 = 0 ;
23462 PyObject *swig_obj[1] ;
23463
23464 if (!args) SWIG_fail;
23465 swig_obj[0] = args;
23466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23467 if (!SWIG_IsOK(res1)) {
23468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23469 }
23470 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23471 {
23472 PyThreadState* __tstate = wxPyBeginAllowThreads();
23473 result = (bool)(arg1)->LeftIsDown();
23474 wxPyEndAllowThreads(__tstate);
23475 if (PyErr_Occurred()) SWIG_fail;
23476 }
23477 {
23478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23479 }
23480 return resultobj;
23481fail:
23482 return NULL;
d55e5bfc
RD
23483}
23484
23485
1bd55598
RD
23486SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23487 PyObject *resultobj = 0;
23488 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23489 bool result;
23490 void *argp1 = 0 ;
23491 int res1 = 0 ;
23492 PyObject *swig_obj[1] ;
23493
23494 if (!args) SWIG_fail;
23495 swig_obj[0] = args;
23496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23497 if (!SWIG_IsOK(res1)) {
23498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23499 }
23500 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23501 {
23502 PyThreadState* __tstate = wxPyBeginAllowThreads();
23503 result = (bool)(arg1)->MiddleIsDown();
23504 wxPyEndAllowThreads(__tstate);
23505 if (PyErr_Occurred()) SWIG_fail;
23506 }
23507 {
23508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23509 }
23510 return resultobj;
23511fail:
23512 return NULL;
d55e5bfc
RD
23513}
23514
23515
1bd55598
RD
23516SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23517 PyObject *resultobj = 0;
23518 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23519 bool result;
23520 void *argp1 = 0 ;
23521 int res1 = 0 ;
23522 PyObject *swig_obj[1] ;
23523
23524 if (!args) SWIG_fail;
23525 swig_obj[0] = args;
23526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23527 if (!SWIG_IsOK(res1)) {
23528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23529 }
23530 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23531 {
23532 PyThreadState* __tstate = wxPyBeginAllowThreads();
23533 result = (bool)(arg1)->RightIsDown();
23534 wxPyEndAllowThreads(__tstate);
23535 if (PyErr_Occurred()) SWIG_fail;
23536 }
23537 {
23538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23539 }
23540 return resultobj;
23541fail:
23542 return NULL;
d55e5bfc
RD
23543}
23544
23545
1bd55598
RD
23546SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23547 PyObject *resultobj = 0;
23548 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23549 bool result;
23550 void *argp1 = 0 ;
23551 int res1 = 0 ;
23552 PyObject *swig_obj[1] ;
23553
23554 if (!args) SWIG_fail;
23555 swig_obj[0] = args;
23556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23557 if (!SWIG_IsOK(res1)) {
23558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23559 }
23560 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23561 {
23562 PyThreadState* __tstate = wxPyBeginAllowThreads();
23563 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23564 wxPyEndAllowThreads(__tstate);
23565 if (PyErr_Occurred()) SWIG_fail;
23566 }
23567 {
23568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23569 }
23570 return resultobj;
23571fail:
23572 return NULL;
d55e5bfc
RD
23573}
23574
23575
1bd55598
RD
23576SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23577 PyObject *resultobj = 0;
23578 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23579 bool result;
23580 void *argp1 = 0 ;
23581 int res1 = 0 ;
23582 PyObject *swig_obj[1] ;
23583
23584 if (!args) SWIG_fail;
23585 swig_obj[0] = args;
23586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23587 if (!SWIG_IsOK(res1)) {
23588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23589 }
23590 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23591 {
23592 PyThreadState* __tstate = wxPyBeginAllowThreads();
23593 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23594 wxPyEndAllowThreads(__tstate);
23595 if (PyErr_Occurred()) SWIG_fail;
23596 }
23597 {
23598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23599 }
23600 return resultobj;
23601fail:
23602 return NULL;
d55e5bfc
RD
23603}
23604
23605
1bd55598
RD
23606SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23607 PyObject *resultobj = 0;
23608 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23609 bool result;
23610 void *argp1 = 0 ;
23611 int res1 = 0 ;
23612 PyObject *swig_obj[1] ;
23613
23614 if (!args) SWIG_fail;
23615 swig_obj[0] = args;
23616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23617 if (!SWIG_IsOK(res1)) {
23618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23619 }
23620 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23621 {
23622 PyThreadState* __tstate = wxPyBeginAllowThreads();
23623 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23624 wxPyEndAllowThreads(__tstate);
23625 if (PyErr_Occurred()) SWIG_fail;
23626 }
23627 {
23628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23629 }
23630 return resultobj;
23631fail:
23632 return NULL;
d55e5bfc
RD
23633}
23634
23635
1bd55598
RD
23636SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23637 PyObject *resultobj = 0;
23638 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23639 bool result;
23640 void *argp1 = 0 ;
23641 int res1 = 0 ;
23642 PyObject *swig_obj[1] ;
23643
23644 if (!args) SWIG_fail;
23645 swig_obj[0] = args;
23646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23647 if (!SWIG_IsOK(res1)) {
23648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23649 }
23650 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23651 {
23652 PyThreadState* __tstate = wxPyBeginAllowThreads();
23653 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23654 wxPyEndAllowThreads(__tstate);
23655 if (PyErr_Occurred()) SWIG_fail;
23656 }
23657 {
23658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23659 }
23660 return resultobj;
23661fail:
23662 return NULL;
d55e5bfc
RD
23663}
23664
23665
1bd55598
RD
23666SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23667 PyObject *resultobj = 0;
23668 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23669 wxPoint result;
23670 void *argp1 = 0 ;
23671 int res1 = 0 ;
23672 PyObject *swig_obj[1] ;
23673
23674 if (!args) SWIG_fail;
23675 swig_obj[0] = args;
23676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23677 if (!SWIG_IsOK(res1)) {
23678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23679 }
23680 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23681 {
23682 PyThreadState* __tstate = wxPyBeginAllowThreads();
23683 result = (arg1)->GetPosition();
23684 wxPyEndAllowThreads(__tstate);
23685 if (PyErr_Occurred()) SWIG_fail;
23686 }
23687 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23688 return resultobj;
23689fail:
23690 return NULL;
23691}
23692
23693
23694SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23695 PyObject *resultobj = 0;
23696 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23697 long *arg2 = (long *) 0 ;
23698 long *arg3 = (long *) 0 ;
23699 void *argp1 = 0 ;
23700 int res1 = 0 ;
23701 long temp2 ;
23702 int res2 = SWIG_TMPOBJ ;
23703 long temp3 ;
23704 int res3 = SWIG_TMPOBJ ;
23705 PyObject *swig_obj[1] ;
23706
23707 arg2 = &temp2;
23708 arg3 = &temp3;
23709 if (!args) SWIG_fail;
23710 swig_obj[0] = args;
23711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23712 if (!SWIG_IsOK(res1)) {
23713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23714 }
23715 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23716 {
23717 PyThreadState* __tstate = wxPyBeginAllowThreads();
23718 (arg1)->GetPosition(arg2,arg3);
23719 wxPyEndAllowThreads(__tstate);
23720 if (PyErr_Occurred()) SWIG_fail;
23721 }
23722 resultobj = SWIG_Py_Void();
23723 if (SWIG_IsTmpObj(res2)) {
23724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23725 } else {
23726 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23727 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23728 }
23729 if (SWIG_IsTmpObj(res3)) {
23730 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23731 } else {
23732 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23733 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23734 }
23735 return resultobj;
23736fail:
23737 return NULL;
23738}
23739
23740
23741SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23742 PyObject *resultobj = 0;
23743 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23744 wxDC *arg2 = 0 ;
23745 wxPoint result;
23746 void *argp1 = 0 ;
23747 int res1 = 0 ;
23748 void *argp2 = 0 ;
23749 int res2 = 0 ;
23750 PyObject * obj0 = 0 ;
23751 PyObject * obj1 = 0 ;
23752 char * kwnames[] = {
23753 (char *) "self",(char *) "dc", NULL
23754 };
23755
23756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23758 if (!SWIG_IsOK(res1)) {
23759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23760 }
23761 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23762 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23763 if (!SWIG_IsOK(res2)) {
23764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23765 }
23766 if (!argp2) {
23767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23768 }
23769 arg2 = reinterpret_cast< wxDC * >(argp2);
23770 {
23771 PyThreadState* __tstate = wxPyBeginAllowThreads();
23772 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23773 wxPyEndAllowThreads(__tstate);
23774 if (PyErr_Occurred()) SWIG_fail;
23775 }
23776 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23777 return resultobj;
23778fail:
23779 return NULL;
d55e5bfc
RD
23780}
23781
23782
1bd55598
RD
23783SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23784 PyObject *resultobj = 0;
23785 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23786 int result;
23787 void *argp1 = 0 ;
23788 int res1 = 0 ;
23789 PyObject *swig_obj[1] ;
23790
23791 if (!args) SWIG_fail;
23792 swig_obj[0] = args;
23793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23794 if (!SWIG_IsOK(res1)) {
23795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23796 }
23797 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23798 {
23799 PyThreadState* __tstate = wxPyBeginAllowThreads();
23800 result = (int)((wxMouseEvent const *)arg1)->GetX();
23801 wxPyEndAllowThreads(__tstate);
23802 if (PyErr_Occurred()) SWIG_fail;
23803 }
23804 resultobj = SWIG_From_int(static_cast< int >(result));
23805 return resultobj;
23806fail:
23807 return NULL;
32fe5131
RD
23808}
23809
23810
1bd55598
RD
23811SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23812 PyObject *resultobj = 0;
23813 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23814 int result;
23815 void *argp1 = 0 ;
23816 int res1 = 0 ;
23817 PyObject *swig_obj[1] ;
23818
23819 if (!args) SWIG_fail;
23820 swig_obj[0] = args;
23821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23822 if (!SWIG_IsOK(res1)) {
23823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23824 }
23825 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23826 {
23827 PyThreadState* __tstate = wxPyBeginAllowThreads();
23828 result = (int)((wxMouseEvent const *)arg1)->GetY();
23829 wxPyEndAllowThreads(__tstate);
23830 if (PyErr_Occurred()) SWIG_fail;
23831 }
23832 resultobj = SWIG_From_int(static_cast< int >(result));
23833 return resultobj;
23834fail:
23835 return NULL;
d55e5bfc
RD
23836}
23837
23838
1bd55598
RD
23839SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23840 PyObject *resultobj = 0;
23841 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23842 int result;
23843 void *argp1 = 0 ;
23844 int res1 = 0 ;
23845 PyObject *swig_obj[1] ;
23846
23847 if (!args) SWIG_fail;
23848 swig_obj[0] = args;
23849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23850 if (!SWIG_IsOK(res1)) {
23851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23852 }
23853 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23854 {
23855 PyThreadState* __tstate = wxPyBeginAllowThreads();
23856 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23857 wxPyEndAllowThreads(__tstate);
23858 if (PyErr_Occurred()) SWIG_fail;
23859 }
23860 resultobj = SWIG_From_int(static_cast< int >(result));
23861 return resultobj;
23862fail:
23863 return NULL;
d55e5bfc
RD
23864}
23865
23866
1bd55598
RD
23867SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23868 PyObject *resultobj = 0;
23869 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23870 int result;
23871 void *argp1 = 0 ;
23872 int res1 = 0 ;
23873 PyObject *swig_obj[1] ;
23874
23875 if (!args) SWIG_fail;
23876 swig_obj[0] = args;
23877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23878 if (!SWIG_IsOK(res1)) {
23879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23880 }
23881 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23882 {
23883 PyThreadState* __tstate = wxPyBeginAllowThreads();
23884 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23885 wxPyEndAllowThreads(__tstate);
23886 if (PyErr_Occurred()) SWIG_fail;
23887 }
23888 resultobj = SWIG_From_int(static_cast< int >(result));
23889 return resultobj;
23890fail:
23891 return NULL;
d55e5bfc
RD
23892}
23893
23894
1bd55598
RD
23895SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23896 PyObject *resultobj = 0;
23897 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23898 int result;
23899 void *argp1 = 0 ;
23900 int res1 = 0 ;
23901 PyObject *swig_obj[1] ;
23902
23903 if (!args) SWIG_fail;
23904 swig_obj[0] = args;
23905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23906 if (!SWIG_IsOK(res1)) {
23907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23908 }
23909 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23910 {
23911 PyThreadState* __tstate = wxPyBeginAllowThreads();
23912 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23913 wxPyEndAllowThreads(__tstate);
23914 if (PyErr_Occurred()) SWIG_fail;
23915 }
23916 resultobj = SWIG_From_int(static_cast< int >(result));
23917 return resultobj;
23918fail:
23919 return NULL;
d55e5bfc
RD
23920}
23921
23922
1bd55598
RD
23923SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23924 PyObject *resultobj = 0;
23925 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23926 bool result;
23927 void *argp1 = 0 ;
23928 int res1 = 0 ;
23929 PyObject *swig_obj[1] ;
23930
23931 if (!args) SWIG_fail;
23932 swig_obj[0] = args;
23933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23934 if (!SWIG_IsOK(res1)) {
23935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23936 }
23937 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23938 {
23939 PyThreadState* __tstate = wxPyBeginAllowThreads();
23940 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
23941 wxPyEndAllowThreads(__tstate);
23942 if (PyErr_Occurred()) SWIG_fail;
23943 }
23944 {
23945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23946 }
23947 return resultobj;
23948fail:
23949 return NULL;
d55e5bfc
RD
23950}
23951
23952
1bd55598
RD
23953SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23954 PyObject *resultobj = 0;
23955 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23956 int arg2 ;
23957 void *argp1 = 0 ;
23958 int res1 = 0 ;
23959 int val2 ;
23960 int ecode2 = 0 ;
23961 PyObject *swig_obj[2] ;
23962
23963 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23965 if (!SWIG_IsOK(res1)) {
23966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23967 }
23968 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23969 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23970 if (!SWIG_IsOK(ecode2)) {
23971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23972 }
23973 arg2 = static_cast< int >(val2);
23974 if (arg1) (arg1)->m_x = arg2;
23975
23976 resultobj = SWIG_Py_Void();
23977 return resultobj;
23978fail:
23979 return NULL;
d55e5bfc
RD
23980}
23981
23982
1bd55598
RD
23983SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23984 PyObject *resultobj = 0;
23985 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23986 int result;
23987 void *argp1 = 0 ;
23988 int res1 = 0 ;
23989 PyObject *swig_obj[1] ;
23990
23991 if (!args) SWIG_fail;
23992 swig_obj[0] = args;
23993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23994 if (!SWIG_IsOK(res1)) {
23995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23996 }
23997 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23998 result = (int) ((arg1)->m_x);
23999 resultobj = SWIG_From_int(static_cast< int >(result));
24000 return resultobj;
24001fail:
24002 return NULL;
24003}
24004
24005
24006SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24007 PyObject *resultobj = 0;
24008 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24009 int arg2 ;
24010 void *argp1 = 0 ;
24011 int res1 = 0 ;
24012 int val2 ;
24013 int ecode2 = 0 ;
24014 PyObject *swig_obj[2] ;
24015
24016 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24018 if (!SWIG_IsOK(res1)) {
24019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24020 }
24021 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24022 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24023 if (!SWIG_IsOK(ecode2)) {
24024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24025 }
24026 arg2 = static_cast< int >(val2);
24027 if (arg1) (arg1)->m_y = arg2;
24028
24029 resultobj = SWIG_Py_Void();
24030 return resultobj;
24031fail:
24032 return NULL;
d55e5bfc
RD
24033}
24034
24035
1bd55598
RD
24036SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24037 PyObject *resultobj = 0;
24038 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24039 int result;
24040 void *argp1 = 0 ;
24041 int res1 = 0 ;
24042 PyObject *swig_obj[1] ;
24043
24044 if (!args) SWIG_fail;
24045 swig_obj[0] = args;
24046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24047 if (!SWIG_IsOK(res1)) {
24048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24049 }
24050 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24051 result = (int) ((arg1)->m_y);
24052 resultobj = SWIG_From_int(static_cast< int >(result));
24053 return resultobj;
24054fail:
24055 return NULL;
24056}
24057
24058
24059SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24060 PyObject *resultobj = 0;
24061 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24062 bool arg2 ;
24063 void *argp1 = 0 ;
24064 int res1 = 0 ;
24065 bool val2 ;
24066 int ecode2 = 0 ;
24067 PyObject *swig_obj[2] ;
24068
24069 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24071 if (!SWIG_IsOK(res1)) {
24072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24073 }
24074 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24075 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24076 if (!SWIG_IsOK(ecode2)) {
24077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24078 }
24079 arg2 = static_cast< bool >(val2);
24080 if (arg1) (arg1)->m_leftDown = arg2;
24081
24082 resultobj = SWIG_Py_Void();
24083 return resultobj;
24084fail:
24085 return NULL;
d55e5bfc
RD
24086}
24087
24088
1bd55598
RD
24089SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24090 PyObject *resultobj = 0;
24091 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24092 bool result;
24093 void *argp1 = 0 ;
24094 int res1 = 0 ;
24095 PyObject *swig_obj[1] ;
24096
24097 if (!args) SWIG_fail;
24098 swig_obj[0] = args;
24099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24100 if (!SWIG_IsOK(res1)) {
24101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24102 }
24103 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24104 result = (bool) ((arg1)->m_leftDown);
24105 {
24106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24107 }
24108 return resultobj;
24109fail:
24110 return NULL;
d55e5bfc
RD
24111}
24112
24113
1bd55598
RD
24114SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24115 PyObject *resultobj = 0;
24116 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24117 bool arg2 ;
24118 void *argp1 = 0 ;
24119 int res1 = 0 ;
24120 bool val2 ;
24121 int ecode2 = 0 ;
24122 PyObject *swig_obj[2] ;
24123
24124 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24126 if (!SWIG_IsOK(res1)) {
24127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24128 }
24129 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24130 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24131 if (!SWIG_IsOK(ecode2)) {
24132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24133 }
24134 arg2 = static_cast< bool >(val2);
24135 if (arg1) (arg1)->m_middleDown = arg2;
24136
24137 resultobj = SWIG_Py_Void();
24138 return resultobj;
24139fail:
24140 return NULL;
d55e5bfc
RD
24141}
24142
24143
1bd55598
RD
24144SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24145 PyObject *resultobj = 0;
24146 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24147 bool result;
24148 void *argp1 = 0 ;
24149 int res1 = 0 ;
24150 PyObject *swig_obj[1] ;
24151
24152 if (!args) SWIG_fail;
24153 swig_obj[0] = args;
24154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24155 if (!SWIG_IsOK(res1)) {
24156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24157 }
24158 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24159 result = (bool) ((arg1)->m_middleDown);
24160 {
24161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24162 }
24163 return resultobj;
24164fail:
24165 return NULL;
d55e5bfc
RD
24166}
24167
24168
1bd55598
RD
24169SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24170 PyObject *resultobj = 0;
24171 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24172 bool arg2 ;
24173 void *argp1 = 0 ;
24174 int res1 = 0 ;
24175 bool val2 ;
24176 int ecode2 = 0 ;
24177 PyObject *swig_obj[2] ;
24178
24179 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24181 if (!SWIG_IsOK(res1)) {
24182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24183 }
24184 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24185 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24186 if (!SWIG_IsOK(ecode2)) {
24187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24188 }
24189 arg2 = static_cast< bool >(val2);
24190 if (arg1) (arg1)->m_rightDown = arg2;
24191
24192 resultobj = SWIG_Py_Void();
24193 return resultobj;
24194fail:
24195 return NULL;
d55e5bfc
RD
24196}
24197
24198
1bd55598
RD
24199SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24200 PyObject *resultobj = 0;
24201 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24202 bool result;
24203 void *argp1 = 0 ;
24204 int res1 = 0 ;
24205 PyObject *swig_obj[1] ;
24206
24207 if (!args) SWIG_fail;
24208 swig_obj[0] = args;
24209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24210 if (!SWIG_IsOK(res1)) {
24211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24212 }
24213 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24214 result = (bool) ((arg1)->m_rightDown);
24215 {
24216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24217 }
24218 return resultobj;
24219fail:
24220 return NULL;
d55e5bfc
RD
24221}
24222
24223
1bd55598
RD
24224SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24225 PyObject *resultobj = 0;
24226 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24227 bool arg2 ;
24228 void *argp1 = 0 ;
24229 int res1 = 0 ;
24230 bool val2 ;
24231 int ecode2 = 0 ;
24232 PyObject *swig_obj[2] ;
24233
24234 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24236 if (!SWIG_IsOK(res1)) {
24237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24238 }
24239 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24240 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24241 if (!SWIG_IsOK(ecode2)) {
24242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24243 }
24244 arg2 = static_cast< bool >(val2);
24245 if (arg1) (arg1)->m_controlDown = arg2;
24246
24247 resultobj = SWIG_Py_Void();
24248 return resultobj;
24249fail:
24250 return NULL;
d55e5bfc
RD
24251}
24252
24253
1bd55598
RD
24254SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24255 PyObject *resultobj = 0;
24256 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24257 bool result;
24258 void *argp1 = 0 ;
24259 int res1 = 0 ;
24260 PyObject *swig_obj[1] ;
24261
24262 if (!args) SWIG_fail;
24263 swig_obj[0] = args;
24264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24265 if (!SWIG_IsOK(res1)) {
24266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24267 }
24268 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24269 result = (bool) ((arg1)->m_controlDown);
24270 {
24271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24272 }
24273 return resultobj;
24274fail:
24275 return NULL;
943e8dfd
RD
24276}
24277
24278
1bd55598
RD
24279SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24280 PyObject *resultobj = 0;
24281 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24282 bool arg2 ;
24283 void *argp1 = 0 ;
24284 int res1 = 0 ;
24285 bool val2 ;
24286 int ecode2 = 0 ;
24287 PyObject *swig_obj[2] ;
24288
24289 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24291 if (!SWIG_IsOK(res1)) {
24292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24293 }
24294 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24295 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24296 if (!SWIG_IsOK(ecode2)) {
24297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24298 }
24299 arg2 = static_cast< bool >(val2);
24300 if (arg1) (arg1)->m_shiftDown = arg2;
24301
24302 resultobj = SWIG_Py_Void();
24303 return resultobj;
24304fail:
24305 return NULL;
943e8dfd
RD
24306}
24307
24308
1bd55598
RD
24309SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24310 PyObject *resultobj = 0;
24311 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24312 bool result;
24313 void *argp1 = 0 ;
24314 int res1 = 0 ;
24315 PyObject *swig_obj[1] ;
24316
24317 if (!args) SWIG_fail;
24318 swig_obj[0] = args;
24319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24320 if (!SWIG_IsOK(res1)) {
24321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24322 }
24323 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24324 result = (bool) ((arg1)->m_shiftDown);
24325 {
24326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24327 }
24328 return resultobj;
24329fail:
24330 return NULL;
943e8dfd
RD
24331}
24332
24333
1bd55598
RD
24334SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24335 PyObject *resultobj = 0;
24336 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24337 bool arg2 ;
24338 void *argp1 = 0 ;
24339 int res1 = 0 ;
24340 bool val2 ;
24341 int ecode2 = 0 ;
24342 PyObject *swig_obj[2] ;
24343
24344 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24346 if (!SWIG_IsOK(res1)) {
24347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24348 }
24349 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24350 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24351 if (!SWIG_IsOK(ecode2)) {
24352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24353 }
24354 arg2 = static_cast< bool >(val2);
24355 if (arg1) (arg1)->m_altDown = arg2;
24356
24357 resultobj = SWIG_Py_Void();
24358 return resultobj;
24359fail:
24360 return NULL;
d55e5bfc
RD
24361}
24362
24363
1bd55598
RD
24364SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24365 PyObject *resultobj = 0;
24366 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24367 bool result;
24368 void *argp1 = 0 ;
24369 int res1 = 0 ;
24370 PyObject *swig_obj[1] ;
24371
24372 if (!args) SWIG_fail;
24373 swig_obj[0] = args;
24374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24375 if (!SWIG_IsOK(res1)) {
24376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24377 }
24378 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24379 result = (bool) ((arg1)->m_altDown);
24380 {
24381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24382 }
24383 return resultobj;
24384fail:
24385 return NULL;
d55e5bfc
RD
24386}
24387
24388
1bd55598
RD
24389SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24390 PyObject *resultobj = 0;
24391 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24392 bool arg2 ;
24393 void *argp1 = 0 ;
24394 int res1 = 0 ;
24395 bool val2 ;
24396 int ecode2 = 0 ;
24397 PyObject *swig_obj[2] ;
24398
24399 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24401 if (!SWIG_IsOK(res1)) {
24402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24403 }
24404 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24405 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24406 if (!SWIG_IsOK(ecode2)) {
24407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24408 }
24409 arg2 = static_cast< bool >(val2);
24410 if (arg1) (arg1)->m_metaDown = arg2;
24411
24412 resultobj = SWIG_Py_Void();
24413 return resultobj;
24414fail:
24415 return NULL;
68350608
RD
24416}
24417
24418
1bd55598
RD
24419SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24420 PyObject *resultobj = 0;
24421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24422 bool result;
24423 void *argp1 = 0 ;
24424 int res1 = 0 ;
24425 PyObject *swig_obj[1] ;
24426
24427 if (!args) SWIG_fail;
24428 swig_obj[0] = args;
24429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24430 if (!SWIG_IsOK(res1)) {
24431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24432 }
24433 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24434 result = (bool) ((arg1)->m_metaDown);
24435 {
24436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24437 }
24438 return resultobj;
24439fail:
24440 return NULL;
68350608
RD
24441}
24442
24443
1bd55598
RD
24444SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24445 PyObject *resultobj = 0;
24446 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24447 int arg2 ;
24448 void *argp1 = 0 ;
24449 int res1 = 0 ;
24450 int val2 ;
24451 int ecode2 = 0 ;
24452 PyObject *swig_obj[2] ;
24453
24454 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24456 if (!SWIG_IsOK(res1)) {
24457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24458 }
24459 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24460 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24461 if (!SWIG_IsOK(ecode2)) {
24462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24463 }
24464 arg2 = static_cast< int >(val2);
24465 if (arg1) (arg1)->m_wheelRotation = arg2;
24466
24467 resultobj = SWIG_Py_Void();
24468 return resultobj;
24469fail:
24470 return NULL;
d55e5bfc
RD
24471}
24472
24473
1bd55598
RD
24474SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24475 PyObject *resultobj = 0;
24476 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24477 int result;
24478 void *argp1 = 0 ;
24479 int res1 = 0 ;
24480 PyObject *swig_obj[1] ;
24481
24482 if (!args) SWIG_fail;
24483 swig_obj[0] = args;
24484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24485 if (!SWIG_IsOK(res1)) {
24486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24487 }
24488 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24489 result = (int) ((arg1)->m_wheelRotation);
24490 resultobj = SWIG_From_int(static_cast< int >(result));
24491 return resultobj;
24492fail:
24493 return NULL;
24494}
24495
24496
24497SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24498 PyObject *resultobj = 0;
24499 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24500 int arg2 ;
24501 void *argp1 = 0 ;
24502 int res1 = 0 ;
24503 int val2 ;
24504 int ecode2 = 0 ;
24505 PyObject *swig_obj[2] ;
24506
24507 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24509 if (!SWIG_IsOK(res1)) {
24510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24511 }
24512 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24513 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24514 if (!SWIG_IsOK(ecode2)) {
24515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24516 }
24517 arg2 = static_cast< int >(val2);
24518 if (arg1) (arg1)->m_wheelDelta = arg2;
24519
24520 resultobj = SWIG_Py_Void();
24521 return resultobj;
24522fail:
24523 return NULL;
d55e5bfc
RD
24524}
24525
24526
1bd55598
RD
24527SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24528 PyObject *resultobj = 0;
24529 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24530 int result;
24531 void *argp1 = 0 ;
24532 int res1 = 0 ;
24533 PyObject *swig_obj[1] ;
24534
24535 if (!args) SWIG_fail;
24536 swig_obj[0] = args;
24537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24538 if (!SWIG_IsOK(res1)) {
24539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24540 }
24541 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24542 result = (int) ((arg1)->m_wheelDelta);
24543 resultobj = SWIG_From_int(static_cast< int >(result));
24544 return resultobj;
24545fail:
24546 return NULL;
24547}
24548
24549
24550SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24551 PyObject *resultobj = 0;
24552 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24553 int arg2 ;
24554 void *argp1 = 0 ;
24555 int res1 = 0 ;
24556 int val2 ;
24557 int ecode2 = 0 ;
24558 PyObject *swig_obj[2] ;
24559
24560 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24562 if (!SWIG_IsOK(res1)) {
24563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24564 }
24565 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24566 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24567 if (!SWIG_IsOK(ecode2)) {
24568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24569 }
24570 arg2 = static_cast< int >(val2);
24571 if (arg1) (arg1)->m_linesPerAction = arg2;
24572
24573 resultobj = SWIG_Py_Void();
24574 return resultobj;
24575fail:
24576 return NULL;
d55e5bfc
RD
24577}
24578
24579
1bd55598
RD
24580SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24581 PyObject *resultobj = 0;
24582 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24583 int result;
24584 void *argp1 = 0 ;
24585 int res1 = 0 ;
24586 PyObject *swig_obj[1] ;
24587
24588 if (!args) SWIG_fail;
24589 swig_obj[0] = args;
24590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24591 if (!SWIG_IsOK(res1)) {
24592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24593 }
24594 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24595 result = (int) ((arg1)->m_linesPerAction);
24596 resultobj = SWIG_From_int(static_cast< int >(result));
24597 return resultobj;
24598fail:
24599 return NULL;
24600}
24601
24602
24603SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24604 PyObject *obj;
24605 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24606 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24607 return SWIG_Py_Void();
24608}
24609
24610SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24611 return SWIG_Python_InitShadowInstance(args);
24612}
24613
24614SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24615 PyObject *resultobj = 0;
24616 int arg1 = (int) 0 ;
24617 int arg2 = (int) 0 ;
24618 wxSetCursorEvent *result = 0 ;
24619 int val1 ;
24620 int ecode1 = 0 ;
24621 int val2 ;
24622 int ecode2 = 0 ;
24623 PyObject * obj0 = 0 ;
24624 PyObject * obj1 = 0 ;
24625 char * kwnames[] = {
24626 (char *) "x",(char *) "y", NULL
24627 };
24628
24629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24630 if (obj0) {
24631 ecode1 = SWIG_AsVal_int(obj0, &val1);
24632 if (!SWIG_IsOK(ecode1)) {
24633 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24634 }
24635 arg1 = static_cast< int >(val1);
24636 }
24637 if (obj1) {
24638 ecode2 = SWIG_AsVal_int(obj1, &val2);
24639 if (!SWIG_IsOK(ecode2)) {
24640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24641 }
24642 arg2 = static_cast< int >(val2);
24643 }
24644 {
24645 PyThreadState* __tstate = wxPyBeginAllowThreads();
24646 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24647 wxPyEndAllowThreads(__tstate);
24648 if (PyErr_Occurred()) SWIG_fail;
24649 }
24650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24651 return resultobj;
24652fail:
24653 return NULL;
d55e5bfc
RD
24654}
24655
24656
1bd55598
RD
24657SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24658 PyObject *resultobj = 0;
24659 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 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_wxSetCursorEvent, 0 | 0 );
24668 if (!SWIG_IsOK(res1)) {
24669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24670 }
24671 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24672 {
24673 PyThreadState* __tstate = wxPyBeginAllowThreads();
24674 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24675 wxPyEndAllowThreads(__tstate);
24676 if (PyErr_Occurred()) SWIG_fail;
24677 }
24678 resultobj = SWIG_From_int(static_cast< int >(result));
24679 return resultobj;
24680fail:
24681 return NULL;
d55e5bfc
RD
24682}
24683
24684
1bd55598
RD
24685SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24686 PyObject *resultobj = 0;
24687 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24688 int result;
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_wxSetCursorEvent, 0 | 0 );
24696 if (!SWIG_IsOK(res1)) {
24697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24698 }
24699 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24700 {
24701 PyThreadState* __tstate = wxPyBeginAllowThreads();
24702 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24703 wxPyEndAllowThreads(__tstate);
24704 if (PyErr_Occurred()) SWIG_fail;
24705 }
24706 resultobj = SWIG_From_int(static_cast< int >(result));
24707 return resultobj;
24708fail:
24709 return NULL;
24710}
24711
24712
24713SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24714 PyObject *resultobj = 0;
24715 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24716 wxCursor *arg2 = 0 ;
24717 void *argp1 = 0 ;
24718 int res1 = 0 ;
24719 void *argp2 = 0 ;
24720 int res2 = 0 ;
24721 PyObject * obj0 = 0 ;
24722 PyObject * obj1 = 0 ;
24723 char * kwnames[] = {
24724 (char *) "self",(char *) "cursor", NULL
24725 };
24726
24727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24729 if (!SWIG_IsOK(res1)) {
24730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24731 }
24732 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24733 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24734 if (!SWIG_IsOK(res2)) {
24735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24736 }
24737 if (!argp2) {
24738 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24739 }
24740 arg2 = reinterpret_cast< wxCursor * >(argp2);
24741 {
24742 PyThreadState* __tstate = wxPyBeginAllowThreads();
24743 (arg1)->SetCursor((wxCursor const &)*arg2);
24744 wxPyEndAllowThreads(__tstate);
24745 if (PyErr_Occurred()) SWIG_fail;
24746 }
24747 resultobj = SWIG_Py_Void();
24748 return resultobj;
24749fail:
24750 return NULL;
d55e5bfc
RD
24751}
24752
24753
1bd55598
RD
24754SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24755 PyObject *resultobj = 0;
24756 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24757 wxCursor *result = 0 ;
24758 void *argp1 = 0 ;
24759 int res1 = 0 ;
24760 PyObject *swig_obj[1] ;
24761
24762 if (!args) SWIG_fail;
24763 swig_obj[0] = args;
24764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24765 if (!SWIG_IsOK(res1)) {
24766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24767 }
24768 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24769 {
24770 PyThreadState* __tstate = wxPyBeginAllowThreads();
d55e5bfc 24771 {
1bd55598
RD
24772 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24773 result = (wxCursor *) &_result_ref;
d55e5bfc 24774 }
1bd55598
RD
24775 wxPyEndAllowThreads(__tstate);
24776 if (PyErr_Occurred()) SWIG_fail;
24777 }
24778 {
24779 wxCursor* resultptr = new wxCursor(*result);
24780 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24781 }
24782 return resultobj;
24783fail:
24784 return NULL;
d55e5bfc
RD
24785}
24786
24787
1bd55598
RD
24788SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24789 PyObject *resultobj = 0;
24790 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24791 bool result;
24792 void *argp1 = 0 ;
24793 int res1 = 0 ;
24794 PyObject *swig_obj[1] ;
24795
24796 if (!args) SWIG_fail;
24797 swig_obj[0] = args;
24798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24799 if (!SWIG_IsOK(res1)) {
24800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24801 }
24802 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24803 {
24804 PyThreadState* __tstate = wxPyBeginAllowThreads();
24805 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24806 wxPyEndAllowThreads(__tstate);
24807 if (PyErr_Occurred()) SWIG_fail;
24808 }
24809 {
24810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24811 }
24812 return resultobj;
24813fail:
24814 return NULL;
68350608
RD
24815}
24816
24817
1bd55598
RD
24818SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24819 PyObject *obj;
24820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24821 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24822 return SWIG_Py_Void();
68350608
RD
24823}
24824
1bd55598
RD
24825SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24826 return SWIG_Python_InitShadowInstance(args);
24827}
68350608 24828
1bd55598
RD
24829SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24830 PyObject *resultobj = 0;
24831 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24832 wxKeyEvent *result = 0 ;
24833 int val1 ;
24834 int ecode1 = 0 ;
24835 PyObject * obj0 = 0 ;
24836 char * kwnames[] = {
24837 (char *) "eventType", NULL
24838 };
24839
24840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24841 if (obj0) {
24842 ecode1 = SWIG_AsVal_int(obj0, &val1);
24843 if (!SWIG_IsOK(ecode1)) {
24844 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24845 }
24846 arg1 = static_cast< wxEventType >(val1);
24847 }
24848 {
24849 PyThreadState* __tstate = wxPyBeginAllowThreads();
24850 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24851 wxPyEndAllowThreads(__tstate);
24852 if (PyErr_Occurred()) SWIG_fail;
24853 }
24854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24855 return resultobj;
24856fail:
24857 return NULL;
68350608
RD
24858}
24859
24860
1bd55598
RD
24861SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24862 PyObject *resultobj = 0;
24863 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24864 int result;
24865 void *argp1 = 0 ;
24866 int res1 = 0 ;
24867 PyObject *swig_obj[1] ;
24868
24869 if (!args) SWIG_fail;
24870 swig_obj[0] = args;
24871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24872 if (!SWIG_IsOK(res1)) {
24873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24874 }
24875 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24876 {
24877 PyThreadState* __tstate = wxPyBeginAllowThreads();
24878 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24879 wxPyEndAllowThreads(__tstate);
24880 if (PyErr_Occurred()) SWIG_fail;
24881 }
24882 resultobj = SWIG_From_int(static_cast< int >(result));
24883 return resultobj;
24884fail:
24885 return NULL;
68350608
RD
24886}
24887
24888
1bd55598
RD
24889SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24890 PyObject *resultobj = 0;
24891 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24892 bool result;
24893 void *argp1 = 0 ;
24894 int res1 = 0 ;
24895 PyObject *swig_obj[1] ;
24896
24897 if (!args) SWIG_fail;
24898 swig_obj[0] = args;
24899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24900 if (!SWIG_IsOK(res1)) {
24901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24902 }
24903 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24904 {
24905 PyThreadState* __tstate = wxPyBeginAllowThreads();
24906 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24907 wxPyEndAllowThreads(__tstate);
24908 if (PyErr_Occurred()) SWIG_fail;
24909 }
24910 {
24911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24912 }
24913 return resultobj;
24914fail:
24915 return NULL;
d55e5bfc
RD
24916}
24917
24918
1bd55598
RD
24919SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24920 PyObject *resultobj = 0;
24921 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24922 bool result;
24923 void *argp1 = 0 ;
24924 int res1 = 0 ;
24925 PyObject *swig_obj[1] ;
24926
24927 if (!args) SWIG_fail;
24928 swig_obj[0] = args;
24929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24930 if (!SWIG_IsOK(res1)) {
24931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24932 }
24933 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24934 {
24935 PyThreadState* __tstate = wxPyBeginAllowThreads();
24936 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
24937 wxPyEndAllowThreads(__tstate);
24938 if (PyErr_Occurred()) SWIG_fail;
24939 }
24940 {
24941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24942 }
24943 return resultobj;
24944fail:
24945 return NULL;
d55e5bfc
RD
24946}
24947
24948
1bd55598
RD
24949SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24950 PyObject *resultobj = 0;
24951 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24952 bool result;
24953 void *argp1 = 0 ;
24954 int res1 = 0 ;
24955 PyObject *swig_obj[1] ;
24956
24957 if (!args) SWIG_fail;
24958 swig_obj[0] = args;
24959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24960 if (!SWIG_IsOK(res1)) {
24961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24962 }
24963 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24964 {
24965 PyThreadState* __tstate = wxPyBeginAllowThreads();
24966 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
24967 wxPyEndAllowThreads(__tstate);
24968 if (PyErr_Occurred()) SWIG_fail;
24969 }
24970 {
24971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24972 }
24973 return resultobj;
24974fail:
24975 return NULL;
24d7cbea
RD
24976}
24977
24978
1bd55598
RD
24979SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24980 PyObject *resultobj = 0;
24981 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24982 bool result;
24983 void *argp1 = 0 ;
24984 int res1 = 0 ;
24985 PyObject *swig_obj[1] ;
24986
24987 if (!args) SWIG_fail;
24988 swig_obj[0] = args;
24989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24990 if (!SWIG_IsOK(res1)) {
24991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24992 }
24993 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24994 {
24995 PyThreadState* __tstate = wxPyBeginAllowThreads();
24996 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
24997 wxPyEndAllowThreads(__tstate);
24998 if (PyErr_Occurred()) SWIG_fail;
24999 }
25000 {
25001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25002 }
25003 return resultobj;
25004fail:
25005 return NULL;
24d7cbea
RD
25006}
25007
25008
1bd55598
RD
25009SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25010 PyObject *resultobj = 0;
25011 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25012 bool result;
25013 void *argp1 = 0 ;
25014 int res1 = 0 ;
25015 PyObject *swig_obj[1] ;
25016
25017 if (!args) SWIG_fail;
25018 swig_obj[0] = args;
25019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25020 if (!SWIG_IsOK(res1)) {
25021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25022 }
25023 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25024 {
25025 PyThreadState* __tstate = wxPyBeginAllowThreads();
25026 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25027 wxPyEndAllowThreads(__tstate);
25028 if (PyErr_Occurred()) SWIG_fail;
25029 }
25030 {
25031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25032 }
25033 return resultobj;
25034fail:
25035 return NULL;
68350608
RD
25036}
25037
25038
1bd55598
RD
25039SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25040 PyObject *resultobj = 0;
25041 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25042 bool result;
25043 void *argp1 = 0 ;
25044 int res1 = 0 ;
25045 PyObject *swig_obj[1] ;
25046
25047 if (!args) SWIG_fail;
25048 swig_obj[0] = args;
25049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25050 if (!SWIG_IsOK(res1)) {
25051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25052 }
25053 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25054 {
25055 PyThreadState* __tstate = wxPyBeginAllowThreads();
25056 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25057 wxPyEndAllowThreads(__tstate);
25058 if (PyErr_Occurred()) SWIG_fail;
25059 }
25060 {
25061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25062 }
25063 return resultobj;
25064fail:
25065 return NULL;
68350608
RD
25066}
25067
25068
1bd55598
RD
25069SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25070 PyObject *resultobj = 0;
25071 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25072 int result;
25073 void *argp1 = 0 ;
25074 int res1 = 0 ;
25075 PyObject *swig_obj[1] ;
25076
25077 if (!args) SWIG_fail;
25078 swig_obj[0] = args;
25079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25080 if (!SWIG_IsOK(res1)) {
25081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25082 }
25083 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25084 {
25085 PyThreadState* __tstate = wxPyBeginAllowThreads();
25086 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25087 wxPyEndAllowThreads(__tstate);
25088 if (PyErr_Occurred()) SWIG_fail;
25089 }
25090 resultobj = SWIG_From_int(static_cast< int >(result));
25091 return resultobj;
25092fail:
25093 return NULL;
68350608
RD
25094}
25095
25096
1bd55598
RD
25097SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25098 PyObject *resultobj = 0;
25099 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25100 int result;
25101 void *argp1 = 0 ;
25102 int res1 = 0 ;
25103 PyObject *swig_obj[1] ;
25104
25105 if (!args) SWIG_fail;
25106 swig_obj[0] = args;
25107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25108 if (!SWIG_IsOK(res1)) {
25109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25110 }
25111 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25112 {
25113 PyThreadState* __tstate = wxPyBeginAllowThreads();
25114 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25115 wxPyEndAllowThreads(__tstate);
25116 if (PyErr_Occurred()) SWIG_fail;
25117 }
25118 resultobj = SWIG_From_int(static_cast< int >(result));
25119 return resultobj;
25120fail:
25121 return NULL;
68350608
RD
25122}
25123
25124
b850e7f3
RD
25125SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25126 PyObject *resultobj = 0;
25127 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25128 int arg2 ;
25129 void *argp1 = 0 ;
25130 int res1 = 0 ;
25131 int val2 ;
25132 int ecode2 = 0 ;
25133 PyObject * obj0 = 0 ;
25134 PyObject * obj1 = 0 ;
25135 char * kwnames[] = {
25136 (char *) "self",(char *) "uniChar", NULL
25137 };
25138
25139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25141 if (!SWIG_IsOK(res1)) {
25142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25143 }
25144 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25145 ecode2 = SWIG_AsVal_int(obj1, &val2);
25146 if (!SWIG_IsOK(ecode2)) {
25147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25148 }
25149 arg2 = static_cast< int >(val2);
25150 {
25151 PyThreadState* __tstate = wxPyBeginAllowThreads();
25152 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25153 wxPyEndAllowThreads(__tstate);
25154 if (PyErr_Occurred()) SWIG_fail;
25155 }
25156 resultobj = SWIG_Py_Void();
25157 return resultobj;
25158fail:
25159 return NULL;
25160}
25161
25162
1bd55598
RD
25163SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25164 PyObject *resultobj = 0;
25165 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25166 unsigned int result;
25167 void *argp1 = 0 ;
25168 int res1 = 0 ;
25169 PyObject *swig_obj[1] ;
25170
25171 if (!args) SWIG_fail;
25172 swig_obj[0] = args;
25173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25174 if (!SWIG_IsOK(res1)) {
25175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25176 }
25177 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25178 {
25179 PyThreadState* __tstate = wxPyBeginAllowThreads();
25180 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25181 wxPyEndAllowThreads(__tstate);
25182 if (PyErr_Occurred()) SWIG_fail;
25183 }
25184 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25185 return resultobj;
25186fail:
25187 return NULL;
68350608
RD
25188}
25189
25190
1bd55598
RD
25191SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25192 PyObject *resultobj = 0;
25193 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25194 unsigned int result;
25195 void *argp1 = 0 ;
25196 int res1 = 0 ;
25197 PyObject *swig_obj[1] ;
25198
25199 if (!args) SWIG_fail;
25200 swig_obj[0] = args;
25201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25202 if (!SWIG_IsOK(res1)) {
25203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25204 }
25205 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25206 {
25207 PyThreadState* __tstate = wxPyBeginAllowThreads();
25208 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25209 wxPyEndAllowThreads(__tstate);
25210 if (PyErr_Occurred()) SWIG_fail;
25211 }
25212 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25213 return resultobj;
25214fail:
25215 return NULL;
68350608
RD
25216}
25217
25218
1bd55598
RD
25219SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25220 PyObject *resultobj = 0;
25221 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25222 wxPoint result;
25223 void *argp1 = 0 ;
25224 int res1 = 0 ;
25225 PyObject *swig_obj[1] ;
25226
25227 if (!args) SWIG_fail;
25228 swig_obj[0] = args;
25229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25230 if (!SWIG_IsOK(res1)) {
25231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25232 }
25233 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25234 {
25235 PyThreadState* __tstate = wxPyBeginAllowThreads();
25236 result = (arg1)->GetPosition();
25237 wxPyEndAllowThreads(__tstate);
25238 if (PyErr_Occurred()) SWIG_fail;
25239 }
25240 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25241 return resultobj;
25242fail:
25243 return NULL;
25244}
25245
25246
25247SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25248 PyObject *resultobj = 0;
25249 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25250 long *arg2 = (long *) 0 ;
25251 long *arg3 = (long *) 0 ;
25252 void *argp1 = 0 ;
25253 int res1 = 0 ;
25254 long temp2 ;
25255 int res2 = SWIG_TMPOBJ ;
25256 long temp3 ;
25257 int res3 = SWIG_TMPOBJ ;
25258 PyObject *swig_obj[1] ;
25259
25260 arg2 = &temp2;
25261 arg3 = &temp3;
25262 if (!args) SWIG_fail;
25263 swig_obj[0] = args;
25264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25265 if (!SWIG_IsOK(res1)) {
25266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25267 }
25268 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25269 {
25270 PyThreadState* __tstate = wxPyBeginAllowThreads();
25271 (arg1)->GetPosition(arg2,arg3);
25272 wxPyEndAllowThreads(__tstate);
25273 if (PyErr_Occurred()) SWIG_fail;
25274 }
25275 resultobj = SWIG_Py_Void();
25276 if (SWIG_IsTmpObj(res2)) {
25277 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25278 } else {
25279 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25280 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25281 }
25282 if (SWIG_IsTmpObj(res3)) {
25283 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25284 } else {
25285 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25286 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25287 }
25288 return resultobj;
25289fail:
25290 return NULL;
68350608
RD
25291}
25292
25293
1bd55598
RD
25294SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25295 PyObject *resultobj = 0;
25296 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25297 int result;
25298 void *argp1 = 0 ;
25299 int res1 = 0 ;
25300 PyObject *swig_obj[1] ;
25301
25302 if (!args) SWIG_fail;
25303 swig_obj[0] = args;
25304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25305 if (!SWIG_IsOK(res1)) {
25306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25307 }
25308 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25309 {
25310 PyThreadState* __tstate = wxPyBeginAllowThreads();
25311 result = (int)((wxKeyEvent const *)arg1)->GetX();
25312 wxPyEndAllowThreads(__tstate);
25313 if (PyErr_Occurred()) SWIG_fail;
25314 }
25315 resultobj = SWIG_From_int(static_cast< int >(result));
25316 return resultobj;
25317fail:
25318 return NULL;
68350608
RD
25319}
25320
25321
1bd55598
RD
25322SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25323 PyObject *resultobj = 0;
25324 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25325 int result;
25326 void *argp1 = 0 ;
25327 int res1 = 0 ;
25328 PyObject *swig_obj[1] ;
25329
25330 if (!args) SWIG_fail;
25331 swig_obj[0] = args;
25332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25333 if (!SWIG_IsOK(res1)) {
25334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25335 }
25336 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25337 {
25338 PyThreadState* __tstate = wxPyBeginAllowThreads();
25339 result = (int)((wxKeyEvent const *)arg1)->GetY();
25340 wxPyEndAllowThreads(__tstate);
25341 if (PyErr_Occurred()) SWIG_fail;
25342 }
25343 resultobj = SWIG_From_int(static_cast< int >(result));
25344 return resultobj;
25345fail:
25346 return NULL;
25347}
25348
25349
25350SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25351 PyObject *resultobj = 0;
25352 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25353 int arg2 ;
25354 void *argp1 = 0 ;
25355 int res1 = 0 ;
25356 int val2 ;
25357 int ecode2 = 0 ;
25358 PyObject *swig_obj[2] ;
25359
25360 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25362 if (!SWIG_IsOK(res1)) {
25363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25364 }
25365 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25366 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25367 if (!SWIG_IsOK(ecode2)) {
25368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25369 }
25370 arg2 = static_cast< int >(val2);
25371 if (arg1) (arg1)->m_x = arg2;
25372
25373 resultobj = SWIG_Py_Void();
25374 return resultobj;
25375fail:
25376 return NULL;
7fbf8399
RD
25377}
25378
25379
1bd55598
RD
25380SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25381 PyObject *resultobj = 0;
25382 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25383 int result;
25384 void *argp1 = 0 ;
25385 int res1 = 0 ;
25386 PyObject *swig_obj[1] ;
25387
25388 if (!args) SWIG_fail;
25389 swig_obj[0] = args;
25390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25391 if (!SWIG_IsOK(res1)) {
25392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25393 }
25394 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25395 result = (int) ((arg1)->m_x);
25396 resultobj = SWIG_From_int(static_cast< int >(result));
25397 return resultobj;
25398fail:
25399 return NULL;
25400}
25401
25402
25403SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25404 PyObject *resultobj = 0;
25405 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25406 int arg2 ;
25407 void *argp1 = 0 ;
25408 int res1 = 0 ;
25409 int val2 ;
25410 int ecode2 = 0 ;
25411 PyObject *swig_obj[2] ;
25412
25413 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25415 if (!SWIG_IsOK(res1)) {
25416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25417 }
25418 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25419 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25420 if (!SWIG_IsOK(ecode2)) {
25421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25422 }
25423 arg2 = static_cast< int >(val2);
25424 if (arg1) (arg1)->m_y = arg2;
25425
25426 resultobj = SWIG_Py_Void();
25427 return resultobj;
25428fail:
25429 return NULL;
7fbf8399
RD
25430}
25431
25432
1bd55598
RD
25433SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25434 PyObject *resultobj = 0;
25435 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25436 int result;
25437 void *argp1 = 0 ;
25438 int res1 = 0 ;
25439 PyObject *swig_obj[1] ;
25440
25441 if (!args) SWIG_fail;
25442 swig_obj[0] = args;
25443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25444 if (!SWIG_IsOK(res1)) {
25445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25446 }
25447 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25448 result = (int) ((arg1)->m_y);
25449 resultobj = SWIG_From_int(static_cast< int >(result));
25450 return resultobj;
25451fail:
25452 return NULL;
25453}
25454
25455
25456SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25457 PyObject *resultobj = 0;
25458 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25459 long arg2 ;
25460 void *argp1 = 0 ;
25461 int res1 = 0 ;
25462 long val2 ;
25463 int ecode2 = 0 ;
25464 PyObject *swig_obj[2] ;
25465
25466 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25468 if (!SWIG_IsOK(res1)) {
25469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25470 }
25471 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25472 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25473 if (!SWIG_IsOK(ecode2)) {
25474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25475 }
25476 arg2 = static_cast< long >(val2);
25477 if (arg1) (arg1)->m_keyCode = arg2;
25478
25479 resultobj = SWIG_Py_Void();
25480 return resultobj;
25481fail:
25482 return NULL;
7fbf8399
RD
25483}
25484
25485
1bd55598
RD
25486SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25487 PyObject *resultobj = 0;
25488 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25489 long result;
25490 void *argp1 = 0 ;
25491 int res1 = 0 ;
25492 PyObject *swig_obj[1] ;
25493
25494 if (!args) SWIG_fail;
25495 swig_obj[0] = args;
25496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25497 if (!SWIG_IsOK(res1)) {
25498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25499 }
25500 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25501 result = (long) ((arg1)->m_keyCode);
25502 resultobj = SWIG_From_long(static_cast< long >(result));
25503 return resultobj;
25504fail:
25505 return NULL;
25506}
25507
25508
25509SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25510 PyObject *resultobj = 0;
25511 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25512 bool arg2 ;
25513 void *argp1 = 0 ;
25514 int res1 = 0 ;
25515 bool val2 ;
25516 int ecode2 = 0 ;
25517 PyObject *swig_obj[2] ;
25518
25519 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25521 if (!SWIG_IsOK(res1)) {
25522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25523 }
25524 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25525 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25526 if (!SWIG_IsOK(ecode2)) {
25527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25528 }
25529 arg2 = static_cast< bool >(val2);
25530 if (arg1) (arg1)->m_controlDown = arg2;
25531
25532 resultobj = SWIG_Py_Void();
25533 return resultobj;
25534fail:
25535 return NULL;
7fbf8399
RD
25536}
25537
25538
1bd55598
RD
25539SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25540 PyObject *resultobj = 0;
25541 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25542 bool result;
25543 void *argp1 = 0 ;
25544 int res1 = 0 ;
25545 PyObject *swig_obj[1] ;
25546
25547 if (!args) SWIG_fail;
25548 swig_obj[0] = args;
25549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25550 if (!SWIG_IsOK(res1)) {
25551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25552 }
25553 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25554 result = (bool) ((arg1)->m_controlDown);
25555 {
25556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25557 }
25558 return resultobj;
25559fail:
25560 return NULL;
d55e5bfc
RD
25561}
25562
25563
1bd55598
RD
25564SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25565 PyObject *resultobj = 0;
25566 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25567 bool arg2 ;
25568 void *argp1 = 0 ;
25569 int res1 = 0 ;
25570 bool val2 ;
25571 int ecode2 = 0 ;
25572 PyObject *swig_obj[2] ;
25573
25574 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25576 if (!SWIG_IsOK(res1)) {
25577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25578 }
25579 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25580 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25581 if (!SWIG_IsOK(ecode2)) {
25582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25583 }
25584 arg2 = static_cast< bool >(val2);
25585 if (arg1) (arg1)->m_shiftDown = arg2;
25586
25587 resultobj = SWIG_Py_Void();
25588 return resultobj;
25589fail:
25590 return NULL;
d55e5bfc
RD
25591}
25592
25593
1bd55598
RD
25594SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25595 PyObject *resultobj = 0;
25596 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25597 bool result;
25598 void *argp1 = 0 ;
25599 int res1 = 0 ;
25600 PyObject *swig_obj[1] ;
25601
25602 if (!args) SWIG_fail;
25603 swig_obj[0] = args;
25604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25605 if (!SWIG_IsOK(res1)) {
25606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25607 }
25608 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25609 result = (bool) ((arg1)->m_shiftDown);
25610 {
25611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25612 }
25613 return resultobj;
25614fail:
25615 return NULL;
d55e5bfc
RD
25616}
25617
25618
1bd55598
RD
25619SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25620 PyObject *resultobj = 0;
25621 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25622 bool arg2 ;
25623 void *argp1 = 0 ;
25624 int res1 = 0 ;
25625 bool val2 ;
25626 int ecode2 = 0 ;
25627 PyObject *swig_obj[2] ;
25628
25629 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25631 if (!SWIG_IsOK(res1)) {
25632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25633 }
25634 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25635 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25636 if (!SWIG_IsOK(ecode2)) {
25637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25638 }
25639 arg2 = static_cast< bool >(val2);
25640 if (arg1) (arg1)->m_altDown = arg2;
25641
25642 resultobj = SWIG_Py_Void();
25643 return resultobj;
25644fail:
25645 return NULL;
d55e5bfc
RD
25646}
25647
25648
1bd55598
RD
25649SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25650 PyObject *resultobj = 0;
25651 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25652 bool result;
25653 void *argp1 = 0 ;
25654 int res1 = 0 ;
25655 PyObject *swig_obj[1] ;
25656
25657 if (!args) SWIG_fail;
25658 swig_obj[0] = args;
25659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25660 if (!SWIG_IsOK(res1)) {
25661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25662 }
25663 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25664 result = (bool) ((arg1)->m_altDown);
25665 {
25666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25667 }
25668 return resultobj;
25669fail:
25670 return NULL;
d55e5bfc
RD
25671}
25672
25673
1bd55598
RD
25674SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25675 PyObject *resultobj = 0;
25676 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25677 bool arg2 ;
25678 void *argp1 = 0 ;
25679 int res1 = 0 ;
25680 bool val2 ;
25681 int ecode2 = 0 ;
25682 PyObject *swig_obj[2] ;
25683
25684 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25686 if (!SWIG_IsOK(res1)) {
25687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25688 }
25689 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25690 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25691 if (!SWIG_IsOK(ecode2)) {
25692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25693 }
25694 arg2 = static_cast< bool >(val2);
25695 if (arg1) (arg1)->m_metaDown = arg2;
25696
25697 resultobj = SWIG_Py_Void();
25698 return resultobj;
25699fail:
25700 return NULL;
d55e5bfc
RD
25701}
25702
25703
1bd55598
RD
25704SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25705 PyObject *resultobj = 0;
25706 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25707 bool result;
25708 void *argp1 = 0 ;
25709 int res1 = 0 ;
25710 PyObject *swig_obj[1] ;
25711
25712 if (!args) SWIG_fail;
25713 swig_obj[0] = args;
25714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25715 if (!SWIG_IsOK(res1)) {
25716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25717 }
25718 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25719 result = (bool) ((arg1)->m_metaDown);
25720 {
25721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25722 }
25723 return resultobj;
25724fail:
25725 return NULL;
d55e5bfc
RD
25726}
25727
25728
1bd55598
RD
25729SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25730 PyObject *resultobj = 0;
25731 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25732 bool arg2 ;
25733 void *argp1 = 0 ;
25734 int res1 = 0 ;
25735 bool val2 ;
25736 int ecode2 = 0 ;
25737 PyObject *swig_obj[2] ;
25738
25739 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25741 if (!SWIG_IsOK(res1)) {
25742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25743 }
25744 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25745 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25746 if (!SWIG_IsOK(ecode2)) {
25747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25748 }
25749 arg2 = static_cast< bool >(val2);
25750 if (arg1) (arg1)->m_scanCode = arg2;
25751
25752 resultobj = SWIG_Py_Void();
25753 return resultobj;
25754fail:
25755 return NULL;
d55e5bfc
RD
25756}
25757
25758
1bd55598
RD
25759SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25760 PyObject *resultobj = 0;
25761 wxKeyEvent *arg1 = (wxKeyEvent *) 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_wxKeyEvent, 0 | 0 );
25770 if (!SWIG_IsOK(res1)) {
25771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25772 }
25773 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25774 result = (bool) ((arg1)->m_scanCode);
25775 {
25776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25777 }
25778 return resultobj;
25779fail:
25780 return NULL;
d55e5bfc
RD
25781}
25782
25783
1bd55598
RD
25784SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25785 PyObject *resultobj = 0;
25786 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25787 unsigned int arg2 ;
25788 void *argp1 = 0 ;
25789 int res1 = 0 ;
25790 unsigned int val2 ;
25791 int ecode2 = 0 ;
25792 PyObject *swig_obj[2] ;
25793
25794 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25796 if (!SWIG_IsOK(res1)) {
25797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25798 }
25799 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25800 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25801 if (!SWIG_IsOK(ecode2)) {
25802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25803 }
25804 arg2 = static_cast< unsigned int >(val2);
25805 if (arg1) (arg1)->m_rawCode = arg2;
25806
25807 resultobj = SWIG_Py_Void();
25808 return resultobj;
25809fail:
25810 return NULL;
d55e5bfc
RD
25811}
25812
25813
1bd55598
RD
25814SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25815 PyObject *resultobj = 0;
25816 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25817 unsigned int result;
25818 void *argp1 = 0 ;
25819 int res1 = 0 ;
25820 PyObject *swig_obj[1] ;
25821
25822 if (!args) SWIG_fail;
25823 swig_obj[0] = args;
25824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25825 if (!SWIG_IsOK(res1)) {
25826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25827 }
25828 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25829 result = (unsigned int) ((arg1)->m_rawCode);
25830 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25831 return resultobj;
25832fail:
25833 return NULL;
25834}
25835
25836
25837SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25838 PyObject *resultobj = 0;
25839 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25840 unsigned int arg2 ;
25841 void *argp1 = 0 ;
25842 int res1 = 0 ;
25843 unsigned int val2 ;
25844 int ecode2 = 0 ;
25845 PyObject *swig_obj[2] ;
25846
25847 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25849 if (!SWIG_IsOK(res1)) {
25850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25851 }
25852 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25853 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25854 if (!SWIG_IsOK(ecode2)) {
25855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25856 }
25857 arg2 = static_cast< unsigned int >(val2);
25858 if (arg1) (arg1)->m_rawFlags = arg2;
25859
25860 resultobj = SWIG_Py_Void();
25861 return resultobj;
25862fail:
25863 return NULL;
d55e5bfc
RD
25864}
25865
25866
1bd55598
RD
25867SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25868 PyObject *resultobj = 0;
25869 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25870 unsigned int result;
25871 void *argp1 = 0 ;
25872 int res1 = 0 ;
25873 PyObject *swig_obj[1] ;
25874
25875 if (!args) SWIG_fail;
25876 swig_obj[0] = args;
25877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25878 if (!SWIG_IsOK(res1)) {
25879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25880 }
25881 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25882 result = (unsigned int) ((arg1)->m_rawFlags);
25883 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25884 return resultobj;
25885fail:
25886 return NULL;
25887}
25888
25889
25890SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25891 PyObject *obj;
25892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25893 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25894 return SWIG_Py_Void();
25895}
25896
25897SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25898 return SWIG_Python_InitShadowInstance(args);
25899}
25900
25901SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25902 PyObject *resultobj = 0;
25903 wxSize const &arg1_defvalue = wxDefaultSize ;
25904 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25905 int arg2 = (int) 0 ;
25906 wxSizeEvent *result = 0 ;
25907 wxSize temp1 ;
25908 int val2 ;
25909 int ecode2 = 0 ;
25910 PyObject * obj0 = 0 ;
25911 PyObject * obj1 = 0 ;
25912 char * kwnames[] = {
25913 (char *) "sz",(char *) "winid", NULL
25914 };
25915
25916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25917 if (obj0) {
c0de73ae 25918 {
1bd55598
RD
25919 arg1 = &temp1;
25920 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
c0de73ae 25921 }
1bd55598
RD
25922 }
25923 if (obj1) {
25924 ecode2 = SWIG_AsVal_int(obj1, &val2);
25925 if (!SWIG_IsOK(ecode2)) {
25926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
25927 }
25928 arg2 = static_cast< int >(val2);
25929 }
25930 {
25931 PyThreadState* __tstate = wxPyBeginAllowThreads();
25932 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
25933 wxPyEndAllowThreads(__tstate);
25934 if (PyErr_Occurred()) SWIG_fail;
25935 }
25936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
25937 return resultobj;
25938fail:
25939 return NULL;
c0de73ae
RD
25940}
25941
25942
1bd55598
RD
25943SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25944 PyObject *resultobj = 0;
25945 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25946 wxSize result;
25947 void *argp1 = 0 ;
25948 int res1 = 0 ;
25949 PyObject *swig_obj[1] ;
25950
25951 if (!args) SWIG_fail;
25952 swig_obj[0] = args;
25953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25954 if (!SWIG_IsOK(res1)) {
25955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25956 }
25957 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25958 {
25959 PyThreadState* __tstate = wxPyBeginAllowThreads();
25960 result = ((wxSizeEvent const *)arg1)->GetSize();
25961 wxPyEndAllowThreads(__tstate);
25962 if (PyErr_Occurred()) SWIG_fail;
25963 }
25964 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
25965 return resultobj;
25966fail:
25967 return NULL;
d55e5bfc
RD
25968}
25969
25970
1bd55598
RD
25971SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25972 PyObject *resultobj = 0;
25973 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25974 wxRect result;
25975 void *argp1 = 0 ;
25976 int res1 = 0 ;
25977 PyObject *swig_obj[1] ;
25978
25979 if (!args) SWIG_fail;
25980 swig_obj[0] = args;
25981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25982 if (!SWIG_IsOK(res1)) {
25983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25984 }
25985 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25986 {
25987 PyThreadState* __tstate = wxPyBeginAllowThreads();
25988 result = ((wxSizeEvent const *)arg1)->GetRect();
25989 wxPyEndAllowThreads(__tstate);
25990 if (PyErr_Occurred()) SWIG_fail;
25991 }
25992 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
25993 return resultobj;
25994fail:
25995 return NULL;
25996}
25997
25998
25999SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26000 PyObject *resultobj = 0;
26001 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26002 wxRect arg2 ;
26003 void *argp1 = 0 ;
26004 int res1 = 0 ;
26005 void *argp2 ;
26006 int res2 = 0 ;
26007 PyObject * obj0 = 0 ;
26008 PyObject * obj1 = 0 ;
26009 char * kwnames[] = {
26010 (char *) "self",(char *) "rect", NULL
26011 };
26012
26013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26015 if (!SWIG_IsOK(res1)) {
26016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26017 }
26018 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26019 {
26020 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26021 if (!SWIG_IsOK(res2)) {
26022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26023 }
26024 if (!argp2) {
26025 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26026 } else {
26027 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26028 arg2 = *temp;
26029 if (SWIG_IsNewObj(res2)) delete temp;
d55e5bfc 26030 }
1bd55598
RD
26031 }
26032 {
26033 PyThreadState* __tstate = wxPyBeginAllowThreads();
26034 (arg1)->SetRect(arg2);
26035 wxPyEndAllowThreads(__tstate);
26036 if (PyErr_Occurred()) SWIG_fail;
26037 }
26038 resultobj = SWIG_Py_Void();
26039 return resultobj;
26040fail:
26041 return NULL;
26042}
26043
26044
26045SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26046 PyObject *resultobj = 0;
26047 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26048 wxSize arg2 ;
26049 void *argp1 = 0 ;
26050 int res1 = 0 ;
26051 void *argp2 ;
26052 int res2 = 0 ;
26053 PyObject * obj0 = 0 ;
26054 PyObject * obj1 = 0 ;
26055 char * kwnames[] = {
26056 (char *) "self",(char *) "size", NULL
26057 };
26058
26059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26061 if (!SWIG_IsOK(res1)) {
26062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26063 }
26064 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26065 {
26066 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26067 if (!SWIG_IsOK(res2)) {
26068 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26069 }
26070 if (!argp2) {
26071 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26072 } else {
26073 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26074 arg2 = *temp;
26075 if (SWIG_IsNewObj(res2)) delete temp;
d55e5bfc 26076 }
1bd55598
RD
26077 }
26078 {
26079 PyThreadState* __tstate = wxPyBeginAllowThreads();
26080 wxSizeEvent_SetSize(arg1,arg2);
26081 wxPyEndAllowThreads(__tstate);
26082 if (PyErr_Occurred()) SWIG_fail;
26083 }
26084 resultobj = SWIG_Py_Void();
26085 return resultobj;
26086fail:
26087 return NULL;
26088}
26089
26090
26091SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26092 PyObject *resultobj = 0;
26093 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26094 wxSize *arg2 = (wxSize *) 0 ;
26095 void *argp1 = 0 ;
26096 int res1 = 0 ;
26097 void *argp2 = 0 ;
26098 int res2 = 0 ;
26099 PyObject *swig_obj[2] ;
26100
26101 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26103 if (!SWIG_IsOK(res1)) {
26104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26105 }
26106 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26107 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26108 if (!SWIG_IsOK(res2)) {
26109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26110 }
26111 arg2 = reinterpret_cast< wxSize * >(argp2);
26112 if (arg1) (arg1)->m_size = *arg2;
26113
26114 resultobj = SWIG_Py_Void();
26115 return resultobj;
26116fail:
26117 return NULL;
d55e5bfc
RD
26118}
26119
26120
1bd55598
RD
26121SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26122 PyObject *resultobj = 0;
26123 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26124 wxSize *result = 0 ;
26125 void *argp1 = 0 ;
26126 int res1 = 0 ;
26127 PyObject *swig_obj[1] ;
26128
26129 if (!args) SWIG_fail;
26130 swig_obj[0] = args;
26131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26132 if (!SWIG_IsOK(res1)) {
26133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26134 }
26135 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26136 result = (wxSize *)& ((arg1)->m_size);
26137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26138 return resultobj;
26139fail:
26140 return NULL;
26141}
26142
26143
26144SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26145 PyObject *resultobj = 0;
26146 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26147 wxRect *arg2 = (wxRect *) 0 ;
26148 void *argp1 = 0 ;
26149 int res1 = 0 ;
26150 void *argp2 = 0 ;
26151 int res2 = 0 ;
26152 PyObject *swig_obj[2] ;
26153
26154 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26156 if (!SWIG_IsOK(res1)) {
26157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26158 }
26159 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26160 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26161 if (!SWIG_IsOK(res2)) {
26162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26163 }
26164 arg2 = reinterpret_cast< wxRect * >(argp2);
26165 if (arg1) (arg1)->m_rect = *arg2;
26166
26167 resultobj = SWIG_Py_Void();
26168 return resultobj;
26169fail:
26170 return NULL;
d55e5bfc
RD
26171}
26172
26173
1bd55598
RD
26174SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26175 PyObject *resultobj = 0;
26176 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26177 wxRect *result = 0 ;
26178 void *argp1 = 0 ;
26179 int res1 = 0 ;
26180 PyObject *swig_obj[1] ;
26181
26182 if (!args) SWIG_fail;
26183 swig_obj[0] = args;
26184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26185 if (!SWIG_IsOK(res1)) {
26186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26187 }
26188 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26189 result = (wxRect *)& ((arg1)->m_rect);
26190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26191 return resultobj;
26192fail:
26193 return NULL;
26194}
26195
26196
26197SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26198 PyObject *obj;
26199 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26200 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26201 return SWIG_Py_Void();
26202}
26203
26204SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26205 return SWIG_Python_InitShadowInstance(args);
26206}
26207
26208SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26209 PyObject *resultobj = 0;
26210 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26211 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26212 int arg2 = (int) 0 ;
26213 wxMoveEvent *result = 0 ;
26214 wxPoint temp1 ;
26215 int val2 ;
26216 int ecode2 = 0 ;
26217 PyObject * obj0 = 0 ;
26218 PyObject * obj1 = 0 ;
26219 char * kwnames[] = {
26220 (char *) "pos",(char *) "winid", NULL
26221 };
26222
26223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26224 if (obj0) {
d55e5bfc 26225 {
1bd55598
RD
26226 arg1 = &temp1;
26227 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
d55e5bfc 26228 }
1bd55598
RD
26229 }
26230 if (obj1) {
26231 ecode2 = SWIG_AsVal_int(obj1, &val2);
26232 if (!SWIG_IsOK(ecode2)) {
26233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26234 }
26235 arg2 = static_cast< int >(val2);
26236 }
26237 {
26238 PyThreadState* __tstate = wxPyBeginAllowThreads();
26239 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26240 wxPyEndAllowThreads(__tstate);
26241 if (PyErr_Occurred()) SWIG_fail;
26242 }
26243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26244 return resultobj;
26245fail:
26246 return NULL;
d55e5bfc
RD
26247}
26248
26249
1bd55598
RD
26250SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26251 PyObject *resultobj = 0;
26252 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26253 wxPoint result;
26254 void *argp1 = 0 ;
26255 int res1 = 0 ;
26256 PyObject *swig_obj[1] ;
26257
26258 if (!args) SWIG_fail;
26259 swig_obj[0] = args;
26260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26261 if (!SWIG_IsOK(res1)) {
26262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26263 }
26264 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26265 {
26266 PyThreadState* __tstate = wxPyBeginAllowThreads();
26267 result = ((wxMoveEvent const *)arg1)->GetPosition();
26268 wxPyEndAllowThreads(__tstate);
26269 if (PyErr_Occurred()) SWIG_fail;
26270 }
26271 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26272 return resultobj;
26273fail:
26274 return NULL;
d55e5bfc
RD
26275}
26276
26277
1bd55598
RD
26278SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26279 PyObject *resultobj = 0;
26280 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26281 wxRect result;
26282 void *argp1 = 0 ;
26283 int res1 = 0 ;
26284 PyObject *swig_obj[1] ;
26285
26286 if (!args) SWIG_fail;
26287 swig_obj[0] = args;
26288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26289 if (!SWIG_IsOK(res1)) {
26290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26291 }
26292 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26293 {
26294 PyThreadState* __tstate = wxPyBeginAllowThreads();
26295 result = ((wxMoveEvent const *)arg1)->GetRect();
26296 wxPyEndAllowThreads(__tstate);
26297 if (PyErr_Occurred()) SWIG_fail;
26298 }
26299 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26300 return resultobj;
26301fail:
26302 return NULL;
26303}
26304
26305
26306SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26307 PyObject *resultobj = 0;
26308 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26309 wxRect *arg2 = 0 ;
26310 void *argp1 = 0 ;
26311 int res1 = 0 ;
26312 wxRect temp2 ;
26313 PyObject * obj0 = 0 ;
26314 PyObject * obj1 = 0 ;
26315 char * kwnames[] = {
26316 (char *) "self",(char *) "rect", NULL
26317 };
26318
26319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26321 if (!SWIG_IsOK(res1)) {
26322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26323 }
26324 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26325 {
26326 arg2 = &temp2;
26327 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26328 }
26329 {
26330 PyThreadState* __tstate = wxPyBeginAllowThreads();
26331 (arg1)->SetRect((wxRect const &)*arg2);
26332 wxPyEndAllowThreads(__tstate);
26333 if (PyErr_Occurred()) SWIG_fail;
26334 }
26335 resultobj = SWIG_Py_Void();
26336 return resultobj;
26337fail:
26338 return NULL;
26339}
26340
26341
26342SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26343 PyObject *resultobj = 0;
26344 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26345 wxPoint *arg2 = 0 ;
26346 void *argp1 = 0 ;
26347 int res1 = 0 ;
26348 wxPoint temp2 ;
26349 PyObject * obj0 = 0 ;
26350 PyObject * obj1 = 0 ;
26351 char * kwnames[] = {
26352 (char *) "self",(char *) "pos", NULL
26353 };
26354
26355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26357 if (!SWIG_IsOK(res1)) {
26358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26359 }
26360 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26361 {
26362 arg2 = &temp2;
26363 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26364 }
26365 {
26366 PyThreadState* __tstate = wxPyBeginAllowThreads();
26367 (arg1)->SetPosition((wxPoint const &)*arg2);
26368 wxPyEndAllowThreads(__tstate);
26369 if (PyErr_Occurred()) SWIG_fail;
26370 }
26371 resultobj = SWIG_Py_Void();
26372 return resultobj;
26373fail:
26374 return NULL;
d55e5bfc
RD
26375}
26376
26377
1bd55598
RD
26378SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26379 PyObject *obj;
26380 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26381 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26382 return SWIG_Py_Void();
d55e5bfc
RD
26383}
26384
1bd55598
RD
26385SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26386 return SWIG_Python_InitShadowInstance(args);
26387}
d55e5bfc 26388
1bd55598
RD
26389SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26390 PyObject *resultobj = 0;
26391 int arg1 = (int) 0 ;
26392 wxPaintEvent *result = 0 ;
26393 int val1 ;
26394 int ecode1 = 0 ;
26395 PyObject * obj0 = 0 ;
26396 char * kwnames[] = {
26397 (char *) "Id", NULL
26398 };
26399
26400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26401 if (obj0) {
26402 ecode1 = SWIG_AsVal_int(obj0, &val1);
26403 if (!SWIG_IsOK(ecode1)) {
26404 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26405 }
26406 arg1 = static_cast< int >(val1);
26407 }
26408 {
26409 PyThreadState* __tstate = wxPyBeginAllowThreads();
26410 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26411 wxPyEndAllowThreads(__tstate);
26412 if (PyErr_Occurred()) SWIG_fail;
26413 }
26414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26415 return resultobj;
26416fail:
26417 return NULL;
d55e5bfc
RD
26418}
26419
26420
1bd55598
RD
26421SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26422 PyObject *obj;
26423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26424 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26425 return SWIG_Py_Void();
d55e5bfc
RD
26426}
26427
1bd55598
RD
26428SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26429 return SWIG_Python_InitShadowInstance(args);
26430}
d55e5bfc 26431
1bd55598
RD
26432SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26433 PyObject *resultobj = 0;
26434 int arg1 = (int) 0 ;
26435 wxNcPaintEvent *result = 0 ;
26436 int val1 ;
26437 int ecode1 = 0 ;
26438 PyObject * obj0 = 0 ;
26439 char * kwnames[] = {
26440 (char *) "winid", NULL
26441 };
26442
26443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26444 if (obj0) {
26445 ecode1 = SWIG_AsVal_int(obj0, &val1);
26446 if (!SWIG_IsOK(ecode1)) {
26447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26448 }
26449 arg1 = static_cast< int >(val1);
26450 }
26451 {
26452 PyThreadState* __tstate = wxPyBeginAllowThreads();
26453 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26454 wxPyEndAllowThreads(__tstate);
26455 if (PyErr_Occurred()) SWIG_fail;
26456 }
26457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26458 return resultobj;
26459fail:
26460 return NULL;
d55e5bfc
RD
26461}
26462
26463
1bd55598
RD
26464SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26465 PyObject *obj;
26466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26467 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26468 return SWIG_Py_Void();
d55e5bfc
RD
26469}
26470
1bd55598
RD
26471SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26472 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
26473}
26474
1bd55598
RD
26475SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26476 PyObject *resultobj = 0;
26477 int arg1 = (int) 0 ;
26478 wxDC *arg2 = (wxDC *) NULL ;
26479 wxEraseEvent *result = 0 ;
26480 int val1 ;
26481 int ecode1 = 0 ;
26482 void *argp2 = 0 ;
26483 int res2 = 0 ;
26484 PyObject * obj0 = 0 ;
26485 PyObject * obj1 = 0 ;
26486 char * kwnames[] = {
26487 (char *) "Id",(char *) "dc", NULL
26488 };
26489
26490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26491 if (obj0) {
26492 ecode1 = SWIG_AsVal_int(obj0, &val1);
26493 if (!SWIG_IsOK(ecode1)) {
26494 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26495 }
26496 arg1 = static_cast< int >(val1);
26497 }
26498 if (obj1) {
26499 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26500 if (!SWIG_IsOK(res2)) {
26501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
d55e5bfc 26502 }
1bd55598
RD
26503 arg2 = reinterpret_cast< wxDC * >(argp2);
26504 }
26505 {
26506 PyThreadState* __tstate = wxPyBeginAllowThreads();
26507 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26508 wxPyEndAllowThreads(__tstate);
26509 if (PyErr_Occurred()) SWIG_fail;
26510 }
26511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26512 return resultobj;
26513fail:
26514 return NULL;
d55e5bfc
RD
26515}
26516
26517
1bd55598
RD
26518SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26519 PyObject *resultobj = 0;
26520 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26521 wxDC *result = 0 ;
26522 void *argp1 = 0 ;
26523 int res1 = 0 ;
26524 PyObject *swig_obj[1] ;
26525
26526 if (!args) SWIG_fail;
26527 swig_obj[0] = args;
26528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26529 if (!SWIG_IsOK(res1)) {
26530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26531 }
26532 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26533 {
26534 PyThreadState* __tstate = wxPyBeginAllowThreads();
26535 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26536 wxPyEndAllowThreads(__tstate);
26537 if (PyErr_Occurred()) SWIG_fail;
26538 }
26539 {
26540 resultobj = wxPyMake_wxObject(result, (bool)0);
26541 }
26542 return resultobj;
26543fail:
26544 return NULL;
d55e5bfc
RD
26545}
26546
26547
1bd55598
RD
26548SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26549 PyObject *obj;
26550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26551 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26552 return SWIG_Py_Void();
d55e5bfc
RD
26553}
26554
1bd55598
RD
26555SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26556 return SWIG_Python_InitShadowInstance(args);
26557}
d55e5bfc 26558
1bd55598
RD
26559SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26560 PyObject *resultobj = 0;
26561 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26562 int arg2 = (int) 0 ;
26563 wxFocusEvent *result = 0 ;
26564 int val1 ;
26565 int ecode1 = 0 ;
26566 int val2 ;
26567 int ecode2 = 0 ;
26568 PyObject * obj0 = 0 ;
26569 PyObject * obj1 = 0 ;
26570 char * kwnames[] = {
26571 (char *) "type",(char *) "winid", NULL
26572 };
26573
26574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26575 if (obj0) {
26576 ecode1 = SWIG_AsVal_int(obj0, &val1);
26577 if (!SWIG_IsOK(ecode1)) {
26578 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26579 }
26580 arg1 = static_cast< wxEventType >(val1);
26581 }
26582 if (obj1) {
26583 ecode2 = SWIG_AsVal_int(obj1, &val2);
26584 if (!SWIG_IsOK(ecode2)) {
26585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26586 }
26587 arg2 = static_cast< int >(val2);
26588 }
26589 {
26590 PyThreadState* __tstate = wxPyBeginAllowThreads();
26591 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26592 wxPyEndAllowThreads(__tstate);
26593 if (PyErr_Occurred()) SWIG_fail;
26594 }
26595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26596 return resultobj;
26597fail:
26598 return NULL;
d55e5bfc
RD
26599}
26600
26601
1bd55598
RD
26602SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26603 PyObject *resultobj = 0;
26604 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26605 wxWindow *result = 0 ;
26606 void *argp1 = 0 ;
26607 int res1 = 0 ;
26608 PyObject *swig_obj[1] ;
26609
26610 if (!args) SWIG_fail;
26611 swig_obj[0] = args;
26612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26613 if (!SWIG_IsOK(res1)) {
26614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26615 }
26616 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26617 {
26618 PyThreadState* __tstate = wxPyBeginAllowThreads();
26619 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26620 wxPyEndAllowThreads(__tstate);
26621 if (PyErr_Occurred()) SWIG_fail;
26622 }
26623 {
26624 resultobj = wxPyMake_wxObject(result, (bool)0);
26625 }
26626 return resultobj;
26627fail:
26628 return NULL;
26629}
26630
26631
26632SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26633 PyObject *resultobj = 0;
26634 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26635 wxWindow *arg2 = (wxWindow *) 0 ;
26636 void *argp1 = 0 ;
26637 int res1 = 0 ;
26638 void *argp2 = 0 ;
26639 int res2 = 0 ;
26640 PyObject * obj0 = 0 ;
26641 PyObject * obj1 = 0 ;
26642 char * kwnames[] = {
26643 (char *) "self",(char *) "win", NULL
26644 };
26645
26646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26648 if (!SWIG_IsOK(res1)) {
26649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26650 }
26651 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26652 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26653 if (!SWIG_IsOK(res2)) {
26654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26655 }
26656 arg2 = reinterpret_cast< wxWindow * >(argp2);
26657 {
26658 PyThreadState* __tstate = wxPyBeginAllowThreads();
26659 (arg1)->SetWindow(arg2);
26660 wxPyEndAllowThreads(__tstate);
26661 if (PyErr_Occurred()) SWIG_fail;
26662 }
26663 resultobj = SWIG_Py_Void();
26664 return resultobj;
26665fail:
26666 return NULL;
d55e5bfc
RD
26667}
26668
26669
1bd55598
RD
26670SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26671 PyObject *obj;
26672 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26673 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26674 return SWIG_Py_Void();
d55e5bfc
RD
26675}
26676
1bd55598
RD
26677SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26678 return SWIG_Python_InitShadowInstance(args);
26679}
d55e5bfc 26680
1bd55598
RD
26681SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26682 PyObject *resultobj = 0;
26683 wxWindow *arg1 = (wxWindow *) NULL ;
26684 wxChildFocusEvent *result = 0 ;
26685 void *argp1 = 0 ;
26686 int res1 = 0 ;
26687 PyObject * obj0 = 0 ;
26688 char * kwnames[] = {
26689 (char *) "win", NULL
26690 };
26691
26692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26693 if (obj0) {
26694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26695 if (!SWIG_IsOK(res1)) {
26696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
d55e5bfc 26697 }
1bd55598
RD
26698 arg1 = reinterpret_cast< wxWindow * >(argp1);
26699 }
26700 {
26701 PyThreadState* __tstate = wxPyBeginAllowThreads();
26702 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26703 wxPyEndAllowThreads(__tstate);
26704 if (PyErr_Occurred()) SWIG_fail;
26705 }
26706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26707 return resultobj;
26708fail:
26709 return NULL;
d55e5bfc
RD
26710}
26711
26712
1bd55598
RD
26713SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26714 PyObject *resultobj = 0;
26715 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26716 wxWindow *result = 0 ;
26717 void *argp1 = 0 ;
26718 int res1 = 0 ;
26719 PyObject *swig_obj[1] ;
26720
26721 if (!args) SWIG_fail;
26722 swig_obj[0] = args;
26723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26724 if (!SWIG_IsOK(res1)) {
26725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26726 }
26727 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26728 {
26729 PyThreadState* __tstate = wxPyBeginAllowThreads();
26730 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26731 wxPyEndAllowThreads(__tstate);
26732 if (PyErr_Occurred()) SWIG_fail;
26733 }
26734 {
26735 resultobj = wxPyMake_wxObject(result, (bool)0);
26736 }
26737 return resultobj;
26738fail:
26739 return NULL;
26740}
26741
26742
26743SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26744 PyObject *obj;
26745 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26746 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26747 return SWIG_Py_Void();
26748}
26749
26750SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26751 return SWIG_Python_InitShadowInstance(args);
26752}
26753
26754SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26755 PyObject *resultobj = 0;
26756 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26757 bool arg2 = (bool) true ;
26758 int arg3 = (int) 0 ;
26759 wxActivateEvent *result = 0 ;
26760 int val1 ;
26761 int ecode1 = 0 ;
26762 bool val2 ;
26763 int ecode2 = 0 ;
26764 int val3 ;
26765 int ecode3 = 0 ;
26766 PyObject * obj0 = 0 ;
26767 PyObject * obj1 = 0 ;
26768 PyObject * obj2 = 0 ;
26769 char * kwnames[] = {
26770 (char *) "type",(char *) "active",(char *) "Id", NULL
26771 };
26772
26773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26774 if (obj0) {
26775 ecode1 = SWIG_AsVal_int(obj0, &val1);
26776 if (!SWIG_IsOK(ecode1)) {
26777 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26778 }
26779 arg1 = static_cast< wxEventType >(val1);
26780 }
26781 if (obj1) {
26782 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26783 if (!SWIG_IsOK(ecode2)) {
26784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26785 }
26786 arg2 = static_cast< bool >(val2);
26787 }
26788 if (obj2) {
26789 ecode3 = SWIG_AsVal_int(obj2, &val3);
26790 if (!SWIG_IsOK(ecode3)) {
26791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26792 }
26793 arg3 = static_cast< int >(val3);
26794 }
26795 {
26796 PyThreadState* __tstate = wxPyBeginAllowThreads();
26797 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26798 wxPyEndAllowThreads(__tstate);
26799 if (PyErr_Occurred()) SWIG_fail;
26800 }
26801 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26802 return resultobj;
26803fail:
26804 return NULL;
d55e5bfc
RD
26805}
26806
26807
1bd55598
RD
26808SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26809 PyObject *resultobj = 0;
26810 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26811 bool result;
26812 void *argp1 = 0 ;
26813 int res1 = 0 ;
26814 PyObject *swig_obj[1] ;
26815
26816 if (!args) SWIG_fail;
26817 swig_obj[0] = args;
26818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26819 if (!SWIG_IsOK(res1)) {
26820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26821 }
26822 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26823 {
26824 PyThreadState* __tstate = wxPyBeginAllowThreads();
26825 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26826 wxPyEndAllowThreads(__tstate);
26827 if (PyErr_Occurred()) SWIG_fail;
26828 }
26829 {
26830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26831 }
26832 return resultobj;
26833fail:
26834 return NULL;
d55e5bfc
RD
26835}
26836
26837
1bd55598
RD
26838SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26839 PyObject *obj;
26840 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26841 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26842 return SWIG_Py_Void();
d55e5bfc
RD
26843}
26844
1bd55598
RD
26845SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26846 return SWIG_Python_InitShadowInstance(args);
26847}
d55e5bfc 26848
1bd55598
RD
26849SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26850 PyObject *resultobj = 0;
26851 int arg1 = (int) 0 ;
26852 wxInitDialogEvent *result = 0 ;
26853 int val1 ;
26854 int ecode1 = 0 ;
26855 PyObject * obj0 = 0 ;
26856 char * kwnames[] = {
26857 (char *) "Id", NULL
26858 };
26859
26860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26861 if (obj0) {
26862 ecode1 = SWIG_AsVal_int(obj0, &val1);
26863 if (!SWIG_IsOK(ecode1)) {
26864 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26865 }
26866 arg1 = static_cast< int >(val1);
26867 }
26868 {
26869 PyThreadState* __tstate = wxPyBeginAllowThreads();
26870 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26871 wxPyEndAllowThreads(__tstate);
26872 if (PyErr_Occurred()) SWIG_fail;
26873 }
26874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26875 return resultobj;
26876fail:
26877 return NULL;
26878}
26879
26880
26881SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26882 PyObject *obj;
26883 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26884 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26885 return SWIG_Py_Void();
26886}
26887
26888SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26889 return SWIG_Python_InitShadowInstance(args);
26890}
26891
26892SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26893 PyObject *resultobj = 0;
26894 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26895 int arg2 = (int) 0 ;
26896 wxMenu *arg3 = (wxMenu *) NULL ;
26897 wxMenuEvent *result = 0 ;
26898 int val1 ;
26899 int ecode1 = 0 ;
26900 int val2 ;
26901 int ecode2 = 0 ;
26902 void *argp3 = 0 ;
26903 int res3 = 0 ;
26904 PyObject * obj0 = 0 ;
26905 PyObject * obj1 = 0 ;
26906 PyObject * obj2 = 0 ;
26907 char * kwnames[] = {
26908 (char *) "type",(char *) "winid",(char *) "menu", NULL
26909 };
26910
26911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26912 if (obj0) {
26913 ecode1 = SWIG_AsVal_int(obj0, &val1);
26914 if (!SWIG_IsOK(ecode1)) {
26915 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26916 }
26917 arg1 = static_cast< wxEventType >(val1);
26918 }
26919 if (obj1) {
26920 ecode2 = SWIG_AsVal_int(obj1, &val2);
26921 if (!SWIG_IsOK(ecode2)) {
26922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
26923 }
26924 arg2 = static_cast< int >(val2);
26925 }
26926 if (obj2) {
26927 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
26928 if (!SWIG_IsOK(res3)) {
26929 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
d55e5bfc 26930 }
1bd55598
RD
26931 arg3 = reinterpret_cast< wxMenu * >(argp3);
26932 }
26933 {
26934 PyThreadState* __tstate = wxPyBeginAllowThreads();
26935 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
26936 wxPyEndAllowThreads(__tstate);
26937 if (PyErr_Occurred()) SWIG_fail;
26938 }
26939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
26940 return resultobj;
26941fail:
26942 return NULL;
d55e5bfc
RD
26943}
26944
26945
1bd55598
RD
26946SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26947 PyObject *resultobj = 0;
26948 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26949 int result;
26950 void *argp1 = 0 ;
26951 int res1 = 0 ;
26952 PyObject *swig_obj[1] ;
26953
26954 if (!args) SWIG_fail;
26955 swig_obj[0] = args;
26956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26957 if (!SWIG_IsOK(res1)) {
26958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26959 }
26960 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26961 {
26962 PyThreadState* __tstate = wxPyBeginAllowThreads();
26963 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
26964 wxPyEndAllowThreads(__tstate);
26965 if (PyErr_Occurred()) SWIG_fail;
26966 }
26967 resultobj = SWIG_From_int(static_cast< int >(result));
26968 return resultobj;
26969fail:
26970 return NULL;
d55e5bfc
RD
26971}
26972
26973
1bd55598
RD
26974SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26975 PyObject *resultobj = 0;
26976 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26977 bool result;
26978 void *argp1 = 0 ;
26979 int res1 = 0 ;
26980 PyObject *swig_obj[1] ;
26981
26982 if (!args) SWIG_fail;
26983 swig_obj[0] = args;
26984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26985 if (!SWIG_IsOK(res1)) {
26986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26987 }
26988 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26989 {
26990 PyThreadState* __tstate = wxPyBeginAllowThreads();
26991 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
26992 wxPyEndAllowThreads(__tstate);
26993 if (PyErr_Occurred()) SWIG_fail;
26994 }
26995 {
26996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26997 }
26998 return resultobj;
26999fail:
27000 return NULL;
d55e5bfc
RD
27001}
27002
27003
1bd55598
RD
27004SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27005 PyObject *resultobj = 0;
27006 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27007 wxMenu *result = 0 ;
27008 void *argp1 = 0 ;
27009 int res1 = 0 ;
27010 PyObject *swig_obj[1] ;
27011
27012 if (!args) SWIG_fail;
27013 swig_obj[0] = args;
27014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27015 if (!SWIG_IsOK(res1)) {
27016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27017 }
27018 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27019 {
27020 PyThreadState* __tstate = wxPyBeginAllowThreads();
27021 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27022 wxPyEndAllowThreads(__tstate);
27023 if (PyErr_Occurred()) SWIG_fail;
27024 }
27025 {
27026 resultobj = wxPyMake_wxObject(result, (bool)0);
27027 }
27028 return resultobj;
27029fail:
27030 return NULL;
d55e5bfc
RD
27031}
27032
27033
1bd55598
RD
27034SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27035 PyObject *obj;
27036 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27037 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27038 return SWIG_Py_Void();
d55e5bfc
RD
27039}
27040
1bd55598
RD
27041SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27042 return SWIG_Python_InitShadowInstance(args);
27043}
d55e5bfc 27044
1bd55598
RD
27045SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27046 PyObject *resultobj = 0;
27047 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27048 int arg2 = (int) 0 ;
27049 wxCloseEvent *result = 0 ;
27050 int val1 ;
27051 int ecode1 = 0 ;
27052 int val2 ;
27053 int ecode2 = 0 ;
27054 PyObject * obj0 = 0 ;
27055 PyObject * obj1 = 0 ;
27056 char * kwnames[] = {
27057 (char *) "type",(char *) "winid", NULL
27058 };
27059
27060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27061 if (obj0) {
27062 ecode1 = SWIG_AsVal_int(obj0, &val1);
27063 if (!SWIG_IsOK(ecode1)) {
27064 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27065 }
27066 arg1 = static_cast< wxEventType >(val1);
27067 }
27068 if (obj1) {
27069 ecode2 = SWIG_AsVal_int(obj1, &val2);
27070 if (!SWIG_IsOK(ecode2)) {
27071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27072 }
27073 arg2 = static_cast< int >(val2);
27074 }
27075 {
27076 PyThreadState* __tstate = wxPyBeginAllowThreads();
27077 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27078 wxPyEndAllowThreads(__tstate);
27079 if (PyErr_Occurred()) SWIG_fail;
27080 }
27081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27082 return resultobj;
27083fail:
27084 return NULL;
27085}
27086
27087
27088SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27089 PyObject *resultobj = 0;
27090 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27091 bool arg2 ;
27092 void *argp1 = 0 ;
27093 int res1 = 0 ;
27094 bool val2 ;
27095 int ecode2 = 0 ;
27096 PyObject * obj0 = 0 ;
27097 PyObject * obj1 = 0 ;
27098 char * kwnames[] = {
27099 (char *) "self",(char *) "logOff", NULL
27100 };
27101
27102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27104 if (!SWIG_IsOK(res1)) {
27105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27106 }
27107 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27108 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27109 if (!SWIG_IsOK(ecode2)) {
27110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27111 }
27112 arg2 = static_cast< bool >(val2);
27113 {
27114 PyThreadState* __tstate = wxPyBeginAllowThreads();
27115 (arg1)->SetLoggingOff(arg2);
27116 wxPyEndAllowThreads(__tstate);
27117 if (PyErr_Occurred()) SWIG_fail;
27118 }
27119 resultobj = SWIG_Py_Void();
27120 return resultobj;
27121fail:
27122 return NULL;
d55e5bfc
RD
27123}
27124
27125
1bd55598
RD
27126SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27127 PyObject *resultobj = 0;
27128 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27129 bool result;
27130 void *argp1 = 0 ;
27131 int res1 = 0 ;
27132 PyObject *swig_obj[1] ;
27133
27134 if (!args) SWIG_fail;
27135 swig_obj[0] = args;
27136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27137 if (!SWIG_IsOK(res1)) {
27138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27139 }
27140 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27141 {
27142 PyThreadState* __tstate = wxPyBeginAllowThreads();
27143 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27144 wxPyEndAllowThreads(__tstate);
27145 if (PyErr_Occurred()) SWIG_fail;
27146 }
27147 {
27148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27149 }
27150 return resultobj;
27151fail:
27152 return NULL;
27153}
27154
27155
27156SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27157 PyObject *resultobj = 0;
27158 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27159 bool arg2 = (bool) true ;
27160 void *argp1 = 0 ;
27161 int res1 = 0 ;
27162 bool val2 ;
27163 int ecode2 = 0 ;
27164 PyObject * obj0 = 0 ;
27165 PyObject * obj1 = 0 ;
27166 char * kwnames[] = {
27167 (char *) "self",(char *) "veto", NULL
27168 };
27169
27170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27172 if (!SWIG_IsOK(res1)) {
27173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27174 }
27175 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27176 if (obj1) {
27177 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27178 if (!SWIG_IsOK(ecode2)) {
27179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27180 }
27181 arg2 = static_cast< bool >(val2);
27182 }
27183 {
27184 PyThreadState* __tstate = wxPyBeginAllowThreads();
27185 (arg1)->Veto(arg2);
27186 wxPyEndAllowThreads(__tstate);
27187 if (PyErr_Occurred()) SWIG_fail;
27188 }
27189 resultobj = SWIG_Py_Void();
27190 return resultobj;
27191fail:
27192 return NULL;
d55e5bfc
RD
27193}
27194
27195
1bd55598
RD
27196SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27197 PyObject *resultobj = 0;
27198 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27199 bool result;
27200 void *argp1 = 0 ;
27201 int res1 = 0 ;
27202 PyObject *swig_obj[1] ;
27203
27204 if (!args) SWIG_fail;
27205 swig_obj[0] = args;
27206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27207 if (!SWIG_IsOK(res1)) {
27208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27209 }
27210 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27211 {
27212 PyThreadState* __tstate = wxPyBeginAllowThreads();
27213 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27214 wxPyEndAllowThreads(__tstate);
27215 if (PyErr_Occurred()) SWIG_fail;
27216 }
27217 {
27218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27219 }
27220 return resultobj;
27221fail:
27222 return NULL;
27223}
27224
27225
27226SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27227 PyObject *resultobj = 0;
27228 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27229 bool arg2 ;
27230 void *argp1 = 0 ;
27231 int res1 = 0 ;
27232 bool val2 ;
27233 int ecode2 = 0 ;
27234 PyObject * obj0 = 0 ;
27235 PyObject * obj1 = 0 ;
27236 char * kwnames[] = {
27237 (char *) "self",(char *) "canVeto", NULL
27238 };
27239
27240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27242 if (!SWIG_IsOK(res1)) {
27243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27244 }
27245 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27246 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27247 if (!SWIG_IsOK(ecode2)) {
27248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27249 }
27250 arg2 = static_cast< bool >(val2);
27251 {
27252 PyThreadState* __tstate = wxPyBeginAllowThreads();
27253 (arg1)->SetCanVeto(arg2);
27254 wxPyEndAllowThreads(__tstate);
27255 if (PyErr_Occurred()) SWIG_fail;
27256 }
27257 resultobj = SWIG_Py_Void();
27258 return resultobj;
27259fail:
27260 return NULL;
d55e5bfc
RD
27261}
27262
27263
1bd55598
RD
27264SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27265 PyObject *resultobj = 0;
27266 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27267 bool result;
27268 void *argp1 = 0 ;
27269 int res1 = 0 ;
27270 PyObject *swig_obj[1] ;
27271
27272 if (!args) SWIG_fail;
27273 swig_obj[0] = args;
27274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27275 if (!SWIG_IsOK(res1)) {
27276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27277 }
27278 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27279 {
27280 PyThreadState* __tstate = wxPyBeginAllowThreads();
27281 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27282 wxPyEndAllowThreads(__tstate);
27283 if (PyErr_Occurred()) SWIG_fail;
27284 }
27285 {
27286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27287 }
27288 return resultobj;
27289fail:
27290 return NULL;
d55e5bfc
RD
27291}
27292
27293
1bd55598
RD
27294SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27295 PyObject *obj;
27296 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27297 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27298 return SWIG_Py_Void();
d55e5bfc
RD
27299}
27300
1bd55598
RD
27301SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27302 return SWIG_Python_InitShadowInstance(args);
d55e5bfc 27303}
1bd55598
RD
27304
27305SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27306 PyObject *resultobj = 0;
27307 int arg1 = (int) 0 ;
27308 bool arg2 = (bool) false ;
27309 wxShowEvent *result = 0 ;
27310 int val1 ;
27311 int ecode1 = 0 ;
27312 bool val2 ;
27313 int ecode2 = 0 ;
27314 PyObject * obj0 = 0 ;
27315 PyObject * obj1 = 0 ;
27316 char * kwnames[] = {
27317 (char *) "winid",(char *) "show", NULL
27318 };
27319
27320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27321 if (obj0) {
27322 ecode1 = SWIG_AsVal_int(obj0, &val1);
27323 if (!SWIG_IsOK(ecode1)) {
27324 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27325 }
27326 arg1 = static_cast< int >(val1);
27327 }
27328 if (obj1) {
27329 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27330 if (!SWIG_IsOK(ecode2)) {
27331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27332 }
27333 arg2 = static_cast< bool >(val2);
27334 }
27335 {
27336 PyThreadState* __tstate = wxPyBeginAllowThreads();
27337 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27338 wxPyEndAllowThreads(__tstate);
27339 if (PyErr_Occurred()) SWIG_fail;
27340 }
27341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27342 return resultobj;
27343fail:
27344 return NULL;
27345}
27346
27347
27348SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27349 PyObject *resultobj = 0;
27350 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27351 bool arg2 ;
27352 void *argp1 = 0 ;
27353 int res1 = 0 ;
27354 bool val2 ;
27355 int ecode2 = 0 ;
27356 PyObject * obj0 = 0 ;
27357 PyObject * obj1 = 0 ;
27358 char * kwnames[] = {
27359 (char *) "self",(char *) "show", NULL
27360 };
27361
27362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27364 if (!SWIG_IsOK(res1)) {
27365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27366 }
27367 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27368 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27369 if (!SWIG_IsOK(ecode2)) {
27370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27371 }
27372 arg2 = static_cast< bool >(val2);
27373 {
27374 PyThreadState* __tstate = wxPyBeginAllowThreads();
27375 (arg1)->SetShow(arg2);
27376 wxPyEndAllowThreads(__tstate);
27377 if (PyErr_Occurred()) SWIG_fail;
27378 }
27379 resultobj = SWIG_Py_Void();
27380 return resultobj;
27381fail:
27382 return NULL;
d55e5bfc
RD
27383}
27384
27385
1bd55598
RD
27386SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27387 PyObject *resultobj = 0;
27388 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27389 bool result;
27390 void *argp1 = 0 ;
27391 int res1 = 0 ;
27392 PyObject *swig_obj[1] ;
27393
27394 if (!args) SWIG_fail;
27395 swig_obj[0] = args;
27396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27397 if (!SWIG_IsOK(res1)) {
27398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27399 }
27400 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27401 {
27402 PyThreadState* __tstate = wxPyBeginAllowThreads();
27403 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27404 wxPyEndAllowThreads(__tstate);
27405 if (PyErr_Occurred()) SWIG_fail;
27406 }
27407 {
27408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27409 }
27410 return resultobj;
27411fail:
27412 return NULL;
d55e5bfc
RD
27413}
27414
27415
1bd55598
RD
27416SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27417 PyObject *obj;
27418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27419 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27420 return SWIG_Py_Void();
d55e5bfc
RD
27421}
27422
1bd55598
RD
27423SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27424 return SWIG_Python_InitShadowInstance(args);
27425}
d55e5bfc 27426
1bd55598
RD
27427SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27428 PyObject *resultobj = 0;
27429 int arg1 = (int) 0 ;
27430 bool arg2 = (bool) true ;
27431 wxIconizeEvent *result = 0 ;
27432 int val1 ;
27433 int ecode1 = 0 ;
27434 bool val2 ;
27435 int ecode2 = 0 ;
27436 PyObject * obj0 = 0 ;
27437 PyObject * obj1 = 0 ;
27438 char * kwnames[] = {
27439 (char *) "id",(char *) "iconized", NULL
27440 };
27441
27442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27443 if (obj0) {
27444 ecode1 = SWIG_AsVal_int(obj0, &val1);
27445 if (!SWIG_IsOK(ecode1)) {
27446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27447 }
27448 arg1 = static_cast< int >(val1);
27449 }
27450 if (obj1) {
27451 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27452 if (!SWIG_IsOK(ecode2)) {
27453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27454 }
27455 arg2 = static_cast< bool >(val2);
27456 }
27457 {
27458 PyThreadState* __tstate = wxPyBeginAllowThreads();
27459 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27460 wxPyEndAllowThreads(__tstate);
27461 if (PyErr_Occurred()) SWIG_fail;
27462 }
27463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27464 return resultobj;
27465fail:
27466 return NULL;
d55e5bfc
RD
27467}
27468
27469
1bd55598
RD
27470SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27471 PyObject *resultobj = 0;
27472 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27473 bool result;
27474 void *argp1 = 0 ;
27475 int res1 = 0 ;
27476 PyObject *swig_obj[1] ;
27477
27478 if (!args) SWIG_fail;
27479 swig_obj[0] = args;
27480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27481 if (!SWIG_IsOK(res1)) {
27482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27483 }
27484 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27485 {
27486 PyThreadState* __tstate = wxPyBeginAllowThreads();
27487 result = (bool)(arg1)->Iconized();
27488 wxPyEndAllowThreads(__tstate);
27489 if (PyErr_Occurred()) SWIG_fail;
27490 }
27491 {
27492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27493 }
27494 return resultobj;
27495fail:
27496 return NULL;
d55e5bfc
RD
27497}
27498
27499
1bd55598
RD
27500SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27501 PyObject *obj;
27502 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27503 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27504 return SWIG_Py_Void();
d55e5bfc
RD
27505}
27506
1bd55598
RD
27507SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27508 return SWIG_Python_InitShadowInstance(args);
27509}
d55e5bfc 27510
1bd55598
RD
27511SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27512 PyObject *resultobj = 0;
27513 int arg1 = (int) 0 ;
27514 wxMaximizeEvent *result = 0 ;
27515 int val1 ;
27516 int ecode1 = 0 ;
27517 PyObject * obj0 = 0 ;
27518 char * kwnames[] = {
27519 (char *) "id", NULL
27520 };
27521
27522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27523 if (obj0) {
27524 ecode1 = SWIG_AsVal_int(obj0, &val1);
27525 if (!SWIG_IsOK(ecode1)) {
27526 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27527 }
27528 arg1 = static_cast< int >(val1);
27529 }
27530 {
27531 PyThreadState* __tstate = wxPyBeginAllowThreads();
27532 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27533 wxPyEndAllowThreads(__tstate);
27534 if (PyErr_Occurred()) SWIG_fail;
27535 }
27536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27537 return resultobj;
27538fail:
27539 return NULL;
d55e5bfc
RD
27540}
27541
27542
1bd55598
RD
27543SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27544 PyObject *obj;
27545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27546 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27547 return SWIG_Py_Void();
d55e5bfc
RD
27548}
27549
1bd55598
RD
27550SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27551 return SWIG_Python_InitShadowInstance(args);
27552}
d55e5bfc 27553
1bd55598
RD
27554SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27555 PyObject *resultobj = 0;
27556 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27557 wxPoint result;
27558 void *argp1 = 0 ;
27559 int res1 = 0 ;
27560 PyObject *swig_obj[1] ;
27561
27562 if (!args) SWIG_fail;
27563 swig_obj[0] = args;
27564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27565 if (!SWIG_IsOK(res1)) {
27566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27567 }
27568 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27569 {
27570 PyThreadState* __tstate = wxPyBeginAllowThreads();
27571 result = (arg1)->GetPosition();
27572 wxPyEndAllowThreads(__tstate);
27573 if (PyErr_Occurred()) SWIG_fail;
27574 }
27575 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27576 return resultobj;
27577fail:
27578 return NULL;
d55e5bfc
RD
27579}
27580
27581
1bd55598
RD
27582SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27583 PyObject *resultobj = 0;
27584 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27585 int result;
27586 void *argp1 = 0 ;
27587 int res1 = 0 ;
27588 PyObject *swig_obj[1] ;
27589
27590 if (!args) SWIG_fail;
27591 swig_obj[0] = args;
27592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27593 if (!SWIG_IsOK(res1)) {
27594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27595 }
27596 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27597 {
27598 PyThreadState* __tstate = wxPyBeginAllowThreads();
27599 result = (int)(arg1)->GetNumberOfFiles();
27600 wxPyEndAllowThreads(__tstate);
27601 if (PyErr_Occurred()) SWIG_fail;
27602 }
27603 resultobj = SWIG_From_int(static_cast< int >(result));
27604 return resultobj;
27605fail:
27606 return NULL;
d55e5bfc
RD
27607}
27608
27609
1bd55598
RD
27610SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27611 PyObject *resultobj = 0;
27612 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27613 PyObject *result = 0 ;
27614 void *argp1 = 0 ;
27615 int res1 = 0 ;
27616 PyObject *swig_obj[1] ;
27617
27618 if (!args) SWIG_fail;
27619 swig_obj[0] = args;
27620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27621 if (!SWIG_IsOK(res1)) {
27622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27623 }
27624 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27625 {
27626 PyThreadState* __tstate = wxPyBeginAllowThreads();
27627 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27628 wxPyEndAllowThreads(__tstate);
27629 if (PyErr_Occurred()) SWIG_fail;
27630 }
27631 resultobj = result;
27632 return resultobj;
27633fail:
27634 return NULL;
d55e5bfc
RD
27635}
27636
27637
1bd55598
RD
27638SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27639 PyObject *obj;
27640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27641 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27642 return SWIG_Py_Void();
d55e5bfc
RD
27643}
27644
1bd55598
RD
27645SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27646 PyObject *resultobj = 0;
27647 int arg1 = (int) 0 ;
27648 wxUpdateUIEvent *result = 0 ;
27649 int val1 ;
27650 int ecode1 = 0 ;
27651 PyObject * obj0 = 0 ;
27652 char * kwnames[] = {
27653 (char *) "commandId", NULL
27654 };
27655
27656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27657 if (obj0) {
27658 ecode1 = SWIG_AsVal_int(obj0, &val1);
27659 if (!SWIG_IsOK(ecode1)) {
27660 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27661 }
27662 arg1 = static_cast< int >(val1);
27663 }
27664 {
27665 PyThreadState* __tstate = wxPyBeginAllowThreads();
27666 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27667 wxPyEndAllowThreads(__tstate);
27668 if (PyErr_Occurred()) SWIG_fail;
27669 }
27670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27671 return resultobj;
27672fail:
27673 return NULL;
27674}
d55e5bfc 27675
1bd55598
RD
27676
27677SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27678 PyObject *resultobj = 0;
27679 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27680 bool result;
27681 void *argp1 = 0 ;
27682 int res1 = 0 ;
27683 PyObject *swig_obj[1] ;
27684
27685 if (!args) SWIG_fail;
27686 swig_obj[0] = args;
27687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27688 if (!SWIG_IsOK(res1)) {
27689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27690 }
27691 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27692 {
27693 PyThreadState* __tstate = wxPyBeginAllowThreads();
27694 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27695 wxPyEndAllowThreads(__tstate);
27696 if (PyErr_Occurred()) SWIG_fail;
27697 }
27698 {
27699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27700 }
27701 return resultobj;
27702fail:
27703 return NULL;
d55e5bfc
RD
27704}
27705
27706
1bd55598
RD
27707SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27708 PyObject *resultobj = 0;
27709 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27710 bool result;
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_wxUpdateUIEvent, 0 | 0 );
27718 if (!SWIG_IsOK(res1)) {
27719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27720 }
27721 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27722 {
27723 PyThreadState* __tstate = wxPyBeginAllowThreads();
27724 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27725 wxPyEndAllowThreads(__tstate);
27726 if (PyErr_Occurred()) SWIG_fail;
27727 }
27728 {
27729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27730 }
27731 return resultobj;
27732fail:
27733 return NULL;
d55e5bfc
RD
27734}
27735
27736
1bd55598
RD
27737SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27738 PyObject *resultobj = 0;
27739 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27740 bool result;
27741 void *argp1 = 0 ;
27742 int res1 = 0 ;
27743 PyObject *swig_obj[1] ;
27744
27745 if (!args) SWIG_fail;
27746 swig_obj[0] = args;
27747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27748 if (!SWIG_IsOK(res1)) {
27749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27750 }
27751 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27752 {
27753 PyThreadState* __tstate = wxPyBeginAllowThreads();
27754 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27755 wxPyEndAllowThreads(__tstate);
27756 if (PyErr_Occurred()) SWIG_fail;
27757 }
27758 {
27759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27760 }
27761 return resultobj;
27762fail:
27763 return NULL;
d55e5bfc
RD
27764}
27765
27766
1bd55598
RD
27767SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27768 PyObject *resultobj = 0;
27769 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27770 wxString result;
27771 void *argp1 = 0 ;
27772 int res1 = 0 ;
27773 PyObject *swig_obj[1] ;
27774
27775 if (!args) SWIG_fail;
27776 swig_obj[0] = args;
27777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27778 if (!SWIG_IsOK(res1)) {
27779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27780 }
27781 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27782 {
27783 PyThreadState* __tstate = wxPyBeginAllowThreads();
27784 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27785 wxPyEndAllowThreads(__tstate);
27786 if (PyErr_Occurred()) SWIG_fail;
27787 }
27788 {
27789#if wxUSE_UNICODE
27790 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27791#else
27792 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27793#endif
27794 }
27795 return resultobj;
27796fail:
27797 return NULL;
d55e5bfc
RD
27798}
27799
27800
1bd55598
RD
27801SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27802 PyObject *resultobj = 0;
27803 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27804 bool result;
27805 void *argp1 = 0 ;
27806 int res1 = 0 ;
27807 PyObject *swig_obj[1] ;
27808
27809 if (!args) SWIG_fail;
27810 swig_obj[0] = args;
27811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27812 if (!SWIG_IsOK(res1)) {
27813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27814 }
27815 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27816 {
27817 PyThreadState* __tstate = wxPyBeginAllowThreads();
27818 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27819 wxPyEndAllowThreads(__tstate);
27820 if (PyErr_Occurred()) SWIG_fail;
27821 }
27822 {
27823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27824 }
27825 return resultobj;
27826fail:
27827 return NULL;
d55e5bfc
RD
27828}
27829
27830
1bd55598
RD
27831SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27832 PyObject *resultobj = 0;
27833 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27834 bool result;
27835 void *argp1 = 0 ;
27836 int res1 = 0 ;
27837 PyObject *swig_obj[1] ;
27838
27839 if (!args) SWIG_fail;
27840 swig_obj[0] = args;
27841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27842 if (!SWIG_IsOK(res1)) {
27843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27844 }
27845 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27846 {
27847 PyThreadState* __tstate = wxPyBeginAllowThreads();
27848 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27849 wxPyEndAllowThreads(__tstate);
27850 if (PyErr_Occurred()) SWIG_fail;
27851 }
27852 {
27853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27854 }
27855 return resultobj;
27856fail:
27857 return NULL;
d55e5bfc
RD
27858}
27859
27860
1bd55598
RD
27861SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27862 PyObject *resultobj = 0;
27863 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27864 bool result;
27865 void *argp1 = 0 ;
27866 int res1 = 0 ;
27867 PyObject *swig_obj[1] ;
27868
27869 if (!args) SWIG_fail;
27870 swig_obj[0] = args;
27871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27872 if (!SWIG_IsOK(res1)) {
27873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27874 }
27875 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27876 {
27877 PyThreadState* __tstate = wxPyBeginAllowThreads();
27878 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27879 wxPyEndAllowThreads(__tstate);
27880 if (PyErr_Occurred()) SWIG_fail;
27881 }
27882 {
27883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27884 }
27885 return resultobj;
27886fail:
27887 return NULL;
d55e5bfc
RD
27888}
27889
27890
1bd55598
RD
27891SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27892 PyObject *resultobj = 0;
27893 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27894 bool result;
27895 void *argp1 = 0 ;
27896 int res1 = 0 ;
27897 PyObject *swig_obj[1] ;
27898
27899 if (!args) SWIG_fail;
27900 swig_obj[0] = args;
27901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27902 if (!SWIG_IsOK(res1)) {
27903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27904 }
27905 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27906 {
27907 PyThreadState* __tstate = wxPyBeginAllowThreads();
27908 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27909 wxPyEndAllowThreads(__tstate);
27910 if (PyErr_Occurred()) SWIG_fail;
27911 }
27912 {
27913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27914 }
27915 return resultobj;
27916fail:
27917 return NULL;
27918}
27919
27920
27921SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27922 PyObject *resultobj = 0;
27923 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27924 bool arg2 ;
27925 void *argp1 = 0 ;
27926 int res1 = 0 ;
27927 bool val2 ;
27928 int ecode2 = 0 ;
27929 PyObject * obj0 = 0 ;
27930 PyObject * obj1 = 0 ;
27931 char * kwnames[] = {
27932 (char *) "self",(char *) "check", NULL
27933 };
27934
27935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
27936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27937 if (!SWIG_IsOK(res1)) {
27938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27939 }
27940 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27941 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27942 if (!SWIG_IsOK(ecode2)) {
27943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
27944 }
27945 arg2 = static_cast< bool >(val2);
27946 {
27947 PyThreadState* __tstate = wxPyBeginAllowThreads();
27948 (arg1)->Check(arg2);
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 resultobj = SWIG_Py_Void();
27953 return resultobj;
27954fail:
27955 return NULL;
27956}
27957
27958
27959SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27960 PyObject *resultobj = 0;
27961 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27962 bool arg2 ;
27963 void *argp1 = 0 ;
27964 int res1 = 0 ;
27965 bool val2 ;
27966 int ecode2 = 0 ;
27967 PyObject * obj0 = 0 ;
27968 PyObject * obj1 = 0 ;
27969 char * kwnames[] = {
27970 (char *) "self",(char *) "enable", NULL
27971 };
27972
27973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
27974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27975 if (!SWIG_IsOK(res1)) {
27976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27977 }
27978 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27979 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27980 if (!SWIG_IsOK(ecode2)) {
27981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
27982 }
27983 arg2 = static_cast< bool >(val2);
27984 {
27985 PyThreadState* __tstate = wxPyBeginAllowThreads();
27986 (arg1)->Enable(arg2);
27987 wxPyEndAllowThreads(__tstate);
27988 if (PyErr_Occurred()) SWIG_fail;
27989 }
27990 resultobj = SWIG_Py_Void();
27991 return resultobj;
27992fail:
27993 return NULL;
27994}
27995
27996
27997SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27998 PyObject *resultobj = 0;
27999 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28000 bool arg2 ;
28001 void *argp1 = 0 ;
28002 int res1 = 0 ;
28003 bool val2 ;
28004 int ecode2 = 0 ;
28005 PyObject * obj0 = 0 ;
28006 PyObject * obj1 = 0 ;
28007 char * kwnames[] = {
28008 (char *) "self",(char *) "show", NULL
28009 };
28010
28011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28013 if (!SWIG_IsOK(res1)) {
28014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28015 }
28016 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28017 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28018 if (!SWIG_IsOK(ecode2)) {
28019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28020 }
28021 arg2 = static_cast< bool >(val2);
28022 {
28023 PyThreadState* __tstate = wxPyBeginAllowThreads();
28024 (arg1)->Show(arg2);
28025 wxPyEndAllowThreads(__tstate);
28026 if (PyErr_Occurred()) SWIG_fail;
28027 }
28028 resultobj = SWIG_Py_Void();
28029 return resultobj;
28030fail:
28031 return NULL;
28032}
28033
28034
28035SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28036 PyObject *resultobj = 0;
28037 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28038 wxString *arg2 = 0 ;
28039 void *argp1 = 0 ;
28040 int res1 = 0 ;
28041 bool temp2 = false ;
28042 PyObject * obj0 = 0 ;
28043 PyObject * obj1 = 0 ;
28044 char * kwnames[] = {
28045 (char *) "self",(char *) "text", NULL
28046 };
28047
28048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28050 if (!SWIG_IsOK(res1)) {
28051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28052 }
28053 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28054 {
28055 arg2 = wxString_in_helper(obj1);
28056 if (arg2 == NULL) SWIG_fail;
28057 temp2 = true;
28058 }
28059 {
28060 PyThreadState* __tstate = wxPyBeginAllowThreads();
28061 (arg1)->SetText((wxString const &)*arg2);
28062 wxPyEndAllowThreads(__tstate);
28063 if (PyErr_Occurred()) SWIG_fail;
28064 }
28065 resultobj = SWIG_Py_Void();
28066 {
28067 if (temp2)
28068 delete arg2;
28069 }
28070 return resultobj;
28071fail:
28072 {
28073 if (temp2)
28074 delete arg2;
28075 }
28076 return NULL;
d55e5bfc
RD
28077}
28078
28079
1bd55598
RD
28080SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28081 PyObject *resultobj = 0;
28082 long arg1 ;
28083 long val1 ;
28084 int ecode1 = 0 ;
28085 PyObject * obj0 = 0 ;
28086 char * kwnames[] = {
28087 (char *) "updateInterval", NULL
28088 };
28089
28090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28091 ecode1 = SWIG_AsVal_long(obj0, &val1);
28092 if (!SWIG_IsOK(ecode1)) {
28093 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28094 }
28095 arg1 = static_cast< long >(val1);
28096 {
28097 PyThreadState* __tstate = wxPyBeginAllowThreads();
28098 wxUpdateUIEvent::SetUpdateInterval(arg1);
28099 wxPyEndAllowThreads(__tstate);
28100 if (PyErr_Occurred()) SWIG_fail;
28101 }
28102 resultobj = SWIG_Py_Void();
28103 return resultobj;
28104fail:
28105 return NULL;
d55e5bfc
RD
28106}
28107
28108
1bd55598
RD
28109SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28110 PyObject *resultobj = 0;
28111 long result;
28112
28113 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28114 {
28115 PyThreadState* __tstate = wxPyBeginAllowThreads();
28116 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28117 wxPyEndAllowThreads(__tstate);
28118 if (PyErr_Occurred()) SWIG_fail;
28119 }
28120 resultobj = SWIG_From_long(static_cast< long >(result));
28121 return resultobj;
28122fail:
28123 return NULL;
28124}
28125
28126
28127SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28128 PyObject *resultobj = 0;
28129 wxWindow *arg1 = (wxWindow *) 0 ;
28130 bool result;
28131 void *argp1 = 0 ;
28132 int res1 = 0 ;
28133 PyObject * obj0 = 0 ;
28134 char * kwnames[] = {
28135 (char *) "win", NULL
28136 };
28137
28138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28140 if (!SWIG_IsOK(res1)) {
28141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28142 }
28143 arg1 = reinterpret_cast< wxWindow * >(argp1);
28144 {
28145 PyThreadState* __tstate = wxPyBeginAllowThreads();
28146 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28147 wxPyEndAllowThreads(__tstate);
28148 if (PyErr_Occurred()) SWIG_fail;
28149 }
28150 {
28151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28152 }
28153 return resultobj;
28154fail:
28155 return NULL;
d55e5bfc
RD
28156}
28157
28158
1bd55598
RD
28159SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28160 PyObject *resultobj = 0;
28161
28162 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28163 {
28164 PyThreadState* __tstate = wxPyBeginAllowThreads();
28165 wxUpdateUIEvent::ResetUpdateTime();
28166 wxPyEndAllowThreads(__tstate);
28167 if (PyErr_Occurred()) SWIG_fail;
28168 }
28169 resultobj = SWIG_Py_Void();
28170 return resultobj;
28171fail:
28172 return NULL;
d55e5bfc
RD
28173}
28174
28175
1bd55598
RD
28176SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28177 PyObject *resultobj = 0;
28178 wxUpdateUIMode arg1 ;
28179 int val1 ;
28180 int ecode1 = 0 ;
28181 PyObject * obj0 = 0 ;
28182 char * kwnames[] = {
28183 (char *) "mode", NULL
28184 };
28185
28186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28187 ecode1 = SWIG_AsVal_int(obj0, &val1);
28188 if (!SWIG_IsOK(ecode1)) {
28189 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28190 }
28191 arg1 = static_cast< wxUpdateUIMode >(val1);
28192 {
28193 PyThreadState* __tstate = wxPyBeginAllowThreads();
28194 wxUpdateUIEvent::SetMode(arg1);
28195 wxPyEndAllowThreads(__tstate);
28196 if (PyErr_Occurred()) SWIG_fail;
28197 }
28198 resultobj = SWIG_Py_Void();
28199 return resultobj;
28200fail:
28201 return NULL;
d55e5bfc
RD
28202}
28203
28204
1bd55598
RD
28205SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28206 PyObject *resultobj = 0;
28207 wxUpdateUIMode result;
28208
28209 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28210 {
28211 PyThreadState* __tstate = wxPyBeginAllowThreads();
28212 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28213 wxPyEndAllowThreads(__tstate);
28214 if (PyErr_Occurred()) SWIG_fail;
28215 }
28216 resultobj = SWIG_From_int(static_cast< int >(result));
28217 return resultobj;
28218fail:
28219 return NULL;
d55e5bfc
RD
28220}
28221
28222
1bd55598
RD
28223SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28224 PyObject *obj;
28225 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28226 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28227 return SWIG_Py_Void();
d55e5bfc
RD
28228}
28229
1bd55598
RD
28230SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28231 return SWIG_Python_InitShadowInstance(args);
28232}
d55e5bfc 28233
1bd55598
RD
28234SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28235 PyObject *resultobj = 0;
28236 wxSysColourChangedEvent *result = 0 ;
28237
28238 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28239 {
28240 PyThreadState* __tstate = wxPyBeginAllowThreads();
28241 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28242 wxPyEndAllowThreads(__tstate);
28243 if (PyErr_Occurred()) SWIG_fail;
28244 }
28245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28246 return resultobj;
28247fail:
28248 return NULL;
d55e5bfc
RD
28249}
28250
28251
1bd55598
RD
28252SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28253 PyObject *obj;
28254 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28255 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28256 return SWIG_Py_Void();
d55e5bfc
RD
28257}
28258
1bd55598
RD
28259SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28260 return SWIG_Python_InitShadowInstance(args);
28261}
d55e5bfc 28262
1bd55598
RD
28263SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28264 PyObject *resultobj = 0;
28265 int arg1 = (int) 0 ;
28266 wxWindow *arg2 = (wxWindow *) NULL ;
28267 wxMouseCaptureChangedEvent *result = 0 ;
28268 int val1 ;
28269 int ecode1 = 0 ;
28270 void *argp2 = 0 ;
28271 int res2 = 0 ;
28272 PyObject * obj0 = 0 ;
28273 PyObject * obj1 = 0 ;
28274 char * kwnames[] = {
28275 (char *) "winid",(char *) "gainedCapture", NULL
28276 };
28277
28278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28279 if (obj0) {
28280 ecode1 = SWIG_AsVal_int(obj0, &val1);
28281 if (!SWIG_IsOK(ecode1)) {
28282 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28283 }
28284 arg1 = static_cast< int >(val1);
28285 }
28286 if (obj1) {
28287 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28288 if (!SWIG_IsOK(res2)) {
28289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
d55e5bfc 28290 }
1bd55598
RD
28291 arg2 = reinterpret_cast< wxWindow * >(argp2);
28292 }
28293 {
28294 PyThreadState* __tstate = wxPyBeginAllowThreads();
28295 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28296 wxPyEndAllowThreads(__tstate);
28297 if (PyErr_Occurred()) SWIG_fail;
28298 }
28299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28300 return resultobj;
28301fail:
28302 return NULL;
d55e5bfc
RD
28303}
28304
28305
1bd55598
RD
28306SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28307 PyObject *resultobj = 0;
28308 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28309 wxWindow *result = 0 ;
28310 void *argp1 = 0 ;
28311 int res1 = 0 ;
28312 PyObject *swig_obj[1] ;
28313
28314 if (!args) SWIG_fail;
28315 swig_obj[0] = args;
28316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28317 if (!SWIG_IsOK(res1)) {
28318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28319 }
28320 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28321 {
28322 PyThreadState* __tstate = wxPyBeginAllowThreads();
28323 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28324 wxPyEndAllowThreads(__tstate);
28325 if (PyErr_Occurred()) SWIG_fail;
28326 }
28327 {
28328 resultobj = wxPyMake_wxObject(result, (bool)0);
28329 }
28330 return resultobj;
28331fail:
28332 return NULL;
d55e5bfc
RD
28333}
28334
28335
1bd55598
RD
28336SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28337 PyObject *obj;
28338 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28339 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28340 return SWIG_Py_Void();
d55e5bfc
RD
28341}
28342
1bd55598
RD
28343SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28344 return SWIG_Python_InitShadowInstance(args);
28345}
d55e5bfc 28346
34e0a3bb
RD
28347SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28348 PyObject *resultobj = 0;
28349 int arg1 = (int) 0 ;
28350 wxMouseCaptureLostEvent *result = 0 ;
28351 int val1 ;
28352 int ecode1 = 0 ;
28353 PyObject * obj0 = 0 ;
28354 char * kwnames[] = {
28355 (char *) "winid", NULL
28356 };
28357
28358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28359 if (obj0) {
28360 ecode1 = SWIG_AsVal_int(obj0, &val1);
28361 if (!SWIG_IsOK(ecode1)) {
28362 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28363 }
28364 arg1 = static_cast< int >(val1);
28365 }
28366 {
28367 PyThreadState* __tstate = wxPyBeginAllowThreads();
28368 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28369 wxPyEndAllowThreads(__tstate);
28370 if (PyErr_Occurred()) SWIG_fail;
28371 }
28372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28373 return resultobj;
28374fail:
28375 return NULL;
28376}
28377
28378
28379SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28380 PyObject *obj;
28381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28382 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28383 return SWIG_Py_Void();
28384}
28385
28386SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28387 return SWIG_Python_InitShadowInstance(args);
28388}
28389
1bd55598
RD
28390SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28391 PyObject *resultobj = 0;
28392 wxDisplayChangedEvent *result = 0 ;
28393
28394 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28395 {
28396 PyThreadState* __tstate = wxPyBeginAllowThreads();
28397 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28398 wxPyEndAllowThreads(__tstate);
28399 if (PyErr_Occurred()) SWIG_fail;
28400 }
28401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28402 return resultobj;
28403fail:
28404 return NULL;
d55e5bfc
RD
28405}
28406
28407
1bd55598
RD
28408SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28409 PyObject *obj;
28410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28411 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28412 return SWIG_Py_Void();
d55e5bfc
RD
28413}
28414
1bd55598
RD
28415SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28416 return SWIG_Python_InitShadowInstance(args);
28417}
d55e5bfc 28418
1bd55598
RD
28419SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28420 PyObject *resultobj = 0;
28421 int arg1 = (int) 0 ;
28422 wxPaletteChangedEvent *result = 0 ;
28423 int val1 ;
28424 int ecode1 = 0 ;
28425 PyObject * obj0 = 0 ;
28426 char * kwnames[] = {
28427 (char *) "id", NULL
28428 };
28429
28430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28431 if (obj0) {
28432 ecode1 = SWIG_AsVal_int(obj0, &val1);
28433 if (!SWIG_IsOK(ecode1)) {
28434 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28435 }
28436 arg1 = static_cast< int >(val1);
28437 }
28438 {
28439 PyThreadState* __tstate = wxPyBeginAllowThreads();
28440 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28441 wxPyEndAllowThreads(__tstate);
28442 if (PyErr_Occurred()) SWIG_fail;
28443 }
28444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28445 return resultobj;
28446fail:
28447 return NULL;
28448}
28449
28450
28451SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28452 PyObject *resultobj = 0;
28453 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28454 wxWindow *arg2 = (wxWindow *) 0 ;
28455 void *argp1 = 0 ;
28456 int res1 = 0 ;
28457 void *argp2 = 0 ;
28458 int res2 = 0 ;
28459 PyObject * obj0 = 0 ;
28460 PyObject * obj1 = 0 ;
28461 char * kwnames[] = {
28462 (char *) "self",(char *) "win", NULL
28463 };
28464
28465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28467 if (!SWIG_IsOK(res1)) {
28468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28469 }
28470 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28471 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28472 if (!SWIG_IsOK(res2)) {
28473 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28474 }
28475 arg2 = reinterpret_cast< wxWindow * >(argp2);
28476 {
28477 PyThreadState* __tstate = wxPyBeginAllowThreads();
28478 (arg1)->SetChangedWindow(arg2);
28479 wxPyEndAllowThreads(__tstate);
28480 if (PyErr_Occurred()) SWIG_fail;
28481 }
28482 resultobj = SWIG_Py_Void();
28483 return resultobj;
28484fail:
28485 return NULL;
d55e5bfc
RD
28486}
28487
28488
1bd55598
RD
28489SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28490 PyObject *resultobj = 0;
28491 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28492 wxWindow *result = 0 ;
28493 void *argp1 = 0 ;
28494 int res1 = 0 ;
28495 PyObject *swig_obj[1] ;
28496
28497 if (!args) SWIG_fail;
28498 swig_obj[0] = args;
28499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28500 if (!SWIG_IsOK(res1)) {
28501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28502 }
28503 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28504 {
28505 PyThreadState* __tstate = wxPyBeginAllowThreads();
28506 result = (wxWindow *)(arg1)->GetChangedWindow();
28507 wxPyEndAllowThreads(__tstate);
28508 if (PyErr_Occurred()) SWIG_fail;
28509 }
28510 {
28511 resultobj = wxPyMake_wxObject(result, (bool)0);
28512 }
28513 return resultobj;
28514fail:
28515 return NULL;
d55e5bfc
RD
28516}
28517
28518
1bd55598
RD
28519SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28520 PyObject *obj;
28521 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28522 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28523 return SWIG_Py_Void();
d55e5bfc
RD
28524}
28525
1bd55598
RD
28526SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28527 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
28528}
28529
1bd55598
RD
28530SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28531 PyObject *resultobj = 0;
28532 int arg1 = (int) 0 ;
28533 wxQueryNewPaletteEvent *result = 0 ;
28534 int val1 ;
28535 int ecode1 = 0 ;
28536 PyObject * obj0 = 0 ;
28537 char * kwnames[] = {
28538 (char *) "winid", NULL
28539 };
28540
28541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28542 if (obj0) {
28543 ecode1 = SWIG_AsVal_int(obj0, &val1);
28544 if (!SWIG_IsOK(ecode1)) {
28545 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28546 }
28547 arg1 = static_cast< int >(val1);
28548 }
28549 {
28550 PyThreadState* __tstate = wxPyBeginAllowThreads();
28551 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28552 wxPyEndAllowThreads(__tstate);
28553 if (PyErr_Occurred()) SWIG_fail;
28554 }
28555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28556 return resultobj;
28557fail:
28558 return NULL;
28559}
28560
28561
28562SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28563 PyObject *resultobj = 0;
28564 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28565 bool arg2 ;
28566 void *argp1 = 0 ;
28567 int res1 = 0 ;
28568 bool val2 ;
28569 int ecode2 = 0 ;
28570 PyObject * obj0 = 0 ;
28571 PyObject * obj1 = 0 ;
28572 char * kwnames[] = {
28573 (char *) "self",(char *) "realized", NULL
28574 };
28575
28576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28578 if (!SWIG_IsOK(res1)) {
28579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28580 }
28581 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28582 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28583 if (!SWIG_IsOK(ecode2)) {
28584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28585 }
28586 arg2 = static_cast< bool >(val2);
28587 {
28588 PyThreadState* __tstate = wxPyBeginAllowThreads();
28589 (arg1)->SetPaletteRealized(arg2);
28590 wxPyEndAllowThreads(__tstate);
28591 if (PyErr_Occurred()) SWIG_fail;
28592 }
28593 resultobj = SWIG_Py_Void();
28594 return resultobj;
28595fail:
28596 return NULL;
d55e5bfc
RD
28597}
28598
28599
1bd55598
RD
28600SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28601 PyObject *resultobj = 0;
28602 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28603 bool result;
28604 void *argp1 = 0 ;
28605 int res1 = 0 ;
28606 PyObject *swig_obj[1] ;
28607
28608 if (!args) SWIG_fail;
28609 swig_obj[0] = args;
28610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28611 if (!SWIG_IsOK(res1)) {
28612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28613 }
28614 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28615 {
28616 PyThreadState* __tstate = wxPyBeginAllowThreads();
28617 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28618 wxPyEndAllowThreads(__tstate);
28619 if (PyErr_Occurred()) SWIG_fail;
28620 }
28621 {
28622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28623 }
28624 return resultobj;
28625fail:
28626 return NULL;
d55e5bfc
RD
28627}
28628
28629
1bd55598
RD
28630SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28631 PyObject *obj;
28632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28633 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28634 return SWIG_Py_Void();
412d302d
RD
28635}
28636
1bd55598
RD
28637SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28638 return SWIG_Python_InitShadowInstance(args);
28639}
412d302d 28640
1bd55598
RD
28641SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28642 PyObject *resultobj = 0;
28643 wxNavigationKeyEvent *result = 0 ;
28644
28645 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28646 {
28647 PyThreadState* __tstate = wxPyBeginAllowThreads();
28648 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28649 wxPyEndAllowThreads(__tstate);
28650 if (PyErr_Occurred()) SWIG_fail;
28651 }
28652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28653 return resultobj;
28654fail:
28655 return NULL;
d55e5bfc
RD
28656}
28657
28658
1bd55598
RD
28659SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28660 PyObject *resultobj = 0;
28661 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28662 bool result;
28663 void *argp1 = 0 ;
28664 int res1 = 0 ;
28665 PyObject *swig_obj[1] ;
28666
28667 if (!args) SWIG_fail;
28668 swig_obj[0] = args;
28669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28670 if (!SWIG_IsOK(res1)) {
28671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28672 }
28673 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28674 {
28675 PyThreadState* __tstate = wxPyBeginAllowThreads();
28676 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28677 wxPyEndAllowThreads(__tstate);
28678 if (PyErr_Occurred()) SWIG_fail;
28679 }
28680 {
28681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28682 }
28683 return resultobj;
28684fail:
28685 return NULL;
28686}
28687
28688
28689SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28690 PyObject *resultobj = 0;
28691 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28692 bool arg2 ;
28693 void *argp1 = 0 ;
28694 int res1 = 0 ;
28695 bool val2 ;
28696 int ecode2 = 0 ;
28697 PyObject * obj0 = 0 ;
28698 PyObject * obj1 = 0 ;
28699 char * kwnames[] = {
28700 (char *) "self",(char *) "forward", NULL
28701 };
28702
28703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28705 if (!SWIG_IsOK(res1)) {
28706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28707 }
28708 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28709 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28710 if (!SWIG_IsOK(ecode2)) {
28711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28712 }
28713 arg2 = static_cast< bool >(val2);
28714 {
28715 PyThreadState* __tstate = wxPyBeginAllowThreads();
28716 (arg1)->SetDirection(arg2);
28717 wxPyEndAllowThreads(__tstate);
28718 if (PyErr_Occurred()) SWIG_fail;
28719 }
28720 resultobj = SWIG_Py_Void();
28721 return resultobj;
28722fail:
28723 return NULL;
d55e5bfc
RD
28724}
28725
28726
1bd55598
RD
28727SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28728 PyObject *resultobj = 0;
28729 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28730 bool result;
28731 void *argp1 = 0 ;
28732 int res1 = 0 ;
28733 PyObject *swig_obj[1] ;
28734
28735 if (!args) SWIG_fail;
28736 swig_obj[0] = args;
28737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28738 if (!SWIG_IsOK(res1)) {
28739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28740 }
28741 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28742 {
28743 PyThreadState* __tstate = wxPyBeginAllowThreads();
28744 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28745 wxPyEndAllowThreads(__tstate);
28746 if (PyErr_Occurred()) SWIG_fail;
28747 }
28748 {
28749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28750 }
28751 return resultobj;
28752fail:
28753 return NULL;
28754}
28755
28756
28757SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28758 PyObject *resultobj = 0;
28759 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28760 bool arg2 ;
28761 void *argp1 = 0 ;
28762 int res1 = 0 ;
28763 bool val2 ;
28764 int ecode2 = 0 ;
28765 PyObject * obj0 = 0 ;
28766 PyObject * obj1 = 0 ;
28767 char * kwnames[] = {
28768 (char *) "self",(char *) "ischange", NULL
28769 };
28770
28771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28773 if (!SWIG_IsOK(res1)) {
28774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28775 }
28776 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28777 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28778 if (!SWIG_IsOK(ecode2)) {
28779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28780 }
28781 arg2 = static_cast< bool >(val2);
28782 {
28783 PyThreadState* __tstate = wxPyBeginAllowThreads();
28784 (arg1)->SetWindowChange(arg2);
28785 wxPyEndAllowThreads(__tstate);
28786 if (PyErr_Occurred()) SWIG_fail;
28787 }
28788 resultobj = SWIG_Py_Void();
28789 return resultobj;
28790fail:
28791 return NULL;
d55e5bfc
RD
28792}
28793
28794
1bd55598
RD
28795SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28796 PyObject *resultobj = 0;
28797 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28798 bool result;
28799 void *argp1 = 0 ;
28800 int res1 = 0 ;
28801 PyObject *swig_obj[1] ;
28802
28803 if (!args) SWIG_fail;
28804 swig_obj[0] = args;
28805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28806 if (!SWIG_IsOK(res1)) {
28807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28808 }
28809 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28810 {
28811 PyThreadState* __tstate = wxPyBeginAllowThreads();
28812 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28813 wxPyEndAllowThreads(__tstate);
28814 if (PyErr_Occurred()) SWIG_fail;
28815 }
28816 {
28817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28818 }
28819 return resultobj;
28820fail:
28821 return NULL;
28822}
28823
28824
28825SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28826 PyObject *resultobj = 0;
28827 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28828 bool arg2 ;
28829 void *argp1 = 0 ;
28830 int res1 = 0 ;
28831 bool val2 ;
28832 int ecode2 = 0 ;
28833 PyObject * obj0 = 0 ;
28834 PyObject * obj1 = 0 ;
28835 char * kwnames[] = {
28836 (char *) "self",(char *) "bIs", NULL
28837 };
28838
28839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28841 if (!SWIG_IsOK(res1)) {
28842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28843 }
28844 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28845 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28846 if (!SWIG_IsOK(ecode2)) {
28847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28848 }
28849 arg2 = static_cast< bool >(val2);
28850 {
28851 PyThreadState* __tstate = wxPyBeginAllowThreads();
28852 (arg1)->SetFromTab(arg2);
28853 wxPyEndAllowThreads(__tstate);
28854 if (PyErr_Occurred()) SWIG_fail;
28855 }
28856 resultobj = SWIG_Py_Void();
28857 return resultobj;
28858fail:
28859 return NULL;
28860}
28861
28862
28863SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28864 PyObject *resultobj = 0;
28865 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28866 long arg2 ;
28867 void *argp1 = 0 ;
28868 int res1 = 0 ;
28869 long val2 ;
28870 int ecode2 = 0 ;
28871 PyObject * obj0 = 0 ;
28872 PyObject * obj1 = 0 ;
28873 char * kwnames[] = {
28874 (char *) "self",(char *) "flags", NULL
28875 };
28876
28877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28879 if (!SWIG_IsOK(res1)) {
28880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28881 }
28882 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28883 ecode2 = SWIG_AsVal_long(obj1, &val2);
28884 if (!SWIG_IsOK(ecode2)) {
28885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28886 }
28887 arg2 = static_cast< long >(val2);
28888 {
28889 PyThreadState* __tstate = wxPyBeginAllowThreads();
28890 (arg1)->SetFlags(arg2);
28891 wxPyEndAllowThreads(__tstate);
28892 if (PyErr_Occurred()) SWIG_fail;
28893 }
28894 resultobj = SWIG_Py_Void();
28895 return resultobj;
28896fail:
28897 return NULL;
d55e5bfc
RD
28898}
28899
28900
1bd55598
RD
28901SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28902 PyObject *resultobj = 0;
28903 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28904 wxWindow *result = 0 ;
28905 void *argp1 = 0 ;
28906 int res1 = 0 ;
28907 PyObject *swig_obj[1] ;
28908
28909 if (!args) SWIG_fail;
28910 swig_obj[0] = args;
28911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28912 if (!SWIG_IsOK(res1)) {
28913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28914 }
28915 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28916 {
28917 PyThreadState* __tstate = wxPyBeginAllowThreads();
28918 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
28919 wxPyEndAllowThreads(__tstate);
28920 if (PyErr_Occurred()) SWIG_fail;
28921 }
28922 {
28923 resultobj = wxPyMake_wxObject(result, (bool)0);
28924 }
28925 return resultobj;
28926fail:
28927 return NULL;
28928}
28929
28930
28931SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28932 PyObject *resultobj = 0;
28933 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28934 wxWindow *arg2 = (wxWindow *) 0 ;
28935 void *argp1 = 0 ;
28936 int res1 = 0 ;
28937 void *argp2 = 0 ;
28938 int res2 = 0 ;
28939 PyObject * obj0 = 0 ;
28940 PyObject * obj1 = 0 ;
28941 char * kwnames[] = {
28942 (char *) "self",(char *) "win", NULL
28943 };
28944
28945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
28946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28947 if (!SWIG_IsOK(res1)) {
28948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28949 }
28950 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28951 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28952 if (!SWIG_IsOK(res2)) {
28953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
28954 }
28955 arg2 = reinterpret_cast< wxWindow * >(argp2);
28956 {
28957 PyThreadState* __tstate = wxPyBeginAllowThreads();
28958 (arg1)->SetCurrentFocus(arg2);
28959 wxPyEndAllowThreads(__tstate);
28960 if (PyErr_Occurred()) SWIG_fail;
28961 }
28962 resultobj = SWIG_Py_Void();
28963 return resultobj;
28964fail:
28965 return NULL;
d55e5bfc
RD
28966}
28967
28968
1bd55598
RD
28969SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28970 PyObject *obj;
28971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28972 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
28973 return SWIG_Py_Void();
d55e5bfc
RD
28974}
28975
1bd55598
RD
28976SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28977 return SWIG_Python_InitShadowInstance(args);
28978}
d55e5bfc 28979
1bd55598
RD
28980SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28981 PyObject *resultobj = 0;
28982 wxWindow *arg1 = (wxWindow *) NULL ;
28983 wxWindowCreateEvent *result = 0 ;
28984 void *argp1 = 0 ;
28985 int res1 = 0 ;
28986 PyObject * obj0 = 0 ;
28987 char * kwnames[] = {
28988 (char *) "win", NULL
28989 };
28990
28991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
28992 if (obj0) {
28993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28994 if (!SWIG_IsOK(res1)) {
28995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
d55e5bfc 28996 }
1bd55598
RD
28997 arg1 = reinterpret_cast< wxWindow * >(argp1);
28998 }
28999 {
29000 PyThreadState* __tstate = wxPyBeginAllowThreads();
29001 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29002 wxPyEndAllowThreads(__tstate);
29003 if (PyErr_Occurred()) SWIG_fail;
29004 }
29005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29006 return resultobj;
29007fail:
29008 return NULL;
d55e5bfc
RD
29009}
29010
29011
1bd55598
RD
29012SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29013 PyObject *resultobj = 0;
29014 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29015 wxWindow *result = 0 ;
29016 void *argp1 = 0 ;
29017 int res1 = 0 ;
29018 PyObject *swig_obj[1] ;
29019
29020 if (!args) SWIG_fail;
29021 swig_obj[0] = args;
29022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29023 if (!SWIG_IsOK(res1)) {
29024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29025 }
29026 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29027 {
29028 PyThreadState* __tstate = wxPyBeginAllowThreads();
29029 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29030 wxPyEndAllowThreads(__tstate);
29031 if (PyErr_Occurred()) SWIG_fail;
29032 }
29033 {
29034 resultobj = wxPyMake_wxObject(result, (bool)0);
29035 }
29036 return resultobj;
29037fail:
29038 return NULL;
d55e5bfc
RD
29039}
29040
29041
1bd55598
RD
29042SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29043 PyObject *obj;
29044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29045 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29046 return SWIG_Py_Void();
d55e5bfc
RD
29047}
29048
1bd55598
RD
29049SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29050 return SWIG_Python_InitShadowInstance(args);
29051}
d55e5bfc 29052
1bd55598
RD
29053SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29054 PyObject *resultobj = 0;
29055 wxWindow *arg1 = (wxWindow *) NULL ;
29056 wxWindowDestroyEvent *result = 0 ;
29057 void *argp1 = 0 ;
29058 int res1 = 0 ;
29059 PyObject * obj0 = 0 ;
29060 char * kwnames[] = {
29061 (char *) "win", NULL
29062 };
29063
29064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29065 if (obj0) {
29066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29067 if (!SWIG_IsOK(res1)) {
29068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
d55e5bfc 29069 }
1bd55598
RD
29070 arg1 = reinterpret_cast< wxWindow * >(argp1);
29071 }
29072 {
29073 PyThreadState* __tstate = wxPyBeginAllowThreads();
29074 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29075 wxPyEndAllowThreads(__tstate);
29076 if (PyErr_Occurred()) SWIG_fail;
29077 }
29078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29079 return resultobj;
29080fail:
29081 return NULL;
d55e5bfc
RD
29082}
29083
29084
1bd55598
RD
29085SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29086 PyObject *resultobj = 0;
29087 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29088 wxWindow *result = 0 ;
29089 void *argp1 = 0 ;
29090 int res1 = 0 ;
29091 PyObject *swig_obj[1] ;
29092
29093 if (!args) SWIG_fail;
29094 swig_obj[0] = args;
29095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29096 if (!SWIG_IsOK(res1)) {
29097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29098 }
29099 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29100 {
29101 PyThreadState* __tstate = wxPyBeginAllowThreads();
29102 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29103 wxPyEndAllowThreads(__tstate);
29104 if (PyErr_Occurred()) SWIG_fail;
29105 }
29106 {
29107 resultobj = wxPyMake_wxObject(result, (bool)0);
29108 }
29109 return resultobj;
29110fail:
29111 return NULL;
29112}
29113
29114
29115SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29116 PyObject *obj;
29117 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29118 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29119 return SWIG_Py_Void();
29120}
29121
29122SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29123 return SWIG_Python_InitShadowInstance(args);
29124}
29125
29126SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29127 PyObject *resultobj = 0;
29128 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29129 int arg2 = (int) 0 ;
29130 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29131 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29132 wxContextMenuEvent *result = 0 ;
29133 int val1 ;
29134 int ecode1 = 0 ;
29135 int val2 ;
29136 int ecode2 = 0 ;
29137 wxPoint temp3 ;
29138 PyObject * obj0 = 0 ;
29139 PyObject * obj1 = 0 ;
29140 PyObject * obj2 = 0 ;
29141 char * kwnames[] = {
29142 (char *) "type",(char *) "winid",(char *) "pt", NULL
29143 };
29144
29145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29146 if (obj0) {
29147 ecode1 = SWIG_AsVal_int(obj0, &val1);
29148 if (!SWIG_IsOK(ecode1)) {
29149 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29150 }
29151 arg1 = static_cast< wxEventType >(val1);
29152 }
29153 if (obj1) {
29154 ecode2 = SWIG_AsVal_int(obj1, &val2);
29155 if (!SWIG_IsOK(ecode2)) {
29156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29157 }
29158 arg2 = static_cast< int >(val2);
29159 }
29160 if (obj2) {
d55e5bfc 29161 {
1bd55598
RD
29162 arg3 = &temp3;
29163 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
d55e5bfc 29164 }
1bd55598
RD
29165 }
29166 {
29167 PyThreadState* __tstate = wxPyBeginAllowThreads();
29168 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29169 wxPyEndAllowThreads(__tstate);
29170 if (PyErr_Occurred()) SWIG_fail;
29171 }
29172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29173 return resultobj;
29174fail:
29175 return NULL;
d55e5bfc
RD
29176}
29177
29178
1bd55598
RD
29179SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29180 PyObject *resultobj = 0;
29181 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29182 wxPoint *result = 0 ;
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_wxContextMenuEvent, 0 | 0 );
29190 if (!SWIG_IsOK(res1)) {
29191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29192 }
29193 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29194 {
29195 PyThreadState* __tstate = wxPyBeginAllowThreads();
d55e5bfc 29196 {
1bd55598
RD
29197 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29198 result = (wxPoint *) &_result_ref;
d55e5bfc 29199 }
1bd55598
RD
29200 wxPyEndAllowThreads(__tstate);
29201 if (PyErr_Occurred()) SWIG_fail;
29202 }
29203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29204 return resultobj;
29205fail:
29206 return NULL;
29207}
29208
29209
29210SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29211 PyObject *resultobj = 0;
29212 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29213 wxPoint *arg2 = 0 ;
29214 void *argp1 = 0 ;
29215 int res1 = 0 ;
29216 wxPoint temp2 ;
29217 PyObject * obj0 = 0 ;
29218 PyObject * obj1 = 0 ;
29219 char * kwnames[] = {
29220 (char *) "self",(char *) "pos", NULL
29221 };
29222
29223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29225 if (!SWIG_IsOK(res1)) {
29226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29227 }
29228 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29229 {
29230 arg2 = &temp2;
29231 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29232 }
29233 {
29234 PyThreadState* __tstate = wxPyBeginAllowThreads();
29235 (arg1)->SetPosition((wxPoint const &)*arg2);
29236 wxPyEndAllowThreads(__tstate);
29237 if (PyErr_Occurred()) SWIG_fail;
29238 }
29239 resultobj = SWIG_Py_Void();
29240 return resultobj;
29241fail:
29242 return NULL;
d55e5bfc
RD
29243}
29244
29245
1bd55598
RD
29246SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29247 PyObject *obj;
29248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29249 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29250 return SWIG_Py_Void();
d55e5bfc
RD
29251}
29252
1bd55598
RD
29253SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29254 return SWIG_Python_InitShadowInstance(args);
29255}
d55e5bfc 29256
1bd55598
RD
29257SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29258 PyObject *resultobj = 0;
29259 wxIdleEvent *result = 0 ;
29260
29261 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29262 {
29263 PyThreadState* __tstate = wxPyBeginAllowThreads();
29264 result = (wxIdleEvent *)new wxIdleEvent();
29265 wxPyEndAllowThreads(__tstate);
29266 if (PyErr_Occurred()) SWIG_fail;
29267 }
29268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29269 return resultobj;
29270fail:
29271 return NULL;
29272}
29273
29274
29275SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29276 PyObject *resultobj = 0;
29277 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29278 bool arg2 = (bool) true ;
29279 void *argp1 = 0 ;
29280 int res1 = 0 ;
29281 bool val2 ;
29282 int ecode2 = 0 ;
29283 PyObject * obj0 = 0 ;
29284 PyObject * obj1 = 0 ;
29285 char * kwnames[] = {
29286 (char *) "self",(char *) "needMore", NULL
29287 };
29288
29289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29291 if (!SWIG_IsOK(res1)) {
29292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29293 }
29294 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29295 if (obj1) {
29296 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29297 if (!SWIG_IsOK(ecode2)) {
29298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29299 }
29300 arg2 = static_cast< bool >(val2);
29301 }
29302 {
29303 PyThreadState* __tstate = wxPyBeginAllowThreads();
29304 (arg1)->RequestMore(arg2);
29305 wxPyEndAllowThreads(__tstate);
29306 if (PyErr_Occurred()) SWIG_fail;
29307 }
29308 resultobj = SWIG_Py_Void();
29309 return resultobj;
29310fail:
29311 return NULL;
d55e5bfc
RD
29312}
29313
29314
1bd55598
RD
29315SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29316 PyObject *resultobj = 0;
29317 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29318 bool result;
29319 void *argp1 = 0 ;
29320 int res1 = 0 ;
29321 PyObject *swig_obj[1] ;
29322
29323 if (!args) SWIG_fail;
29324 swig_obj[0] = args;
29325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29326 if (!SWIG_IsOK(res1)) {
29327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29328 }
29329 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29330 {
29331 PyThreadState* __tstate = wxPyBeginAllowThreads();
29332 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29333 wxPyEndAllowThreads(__tstate);
29334 if (PyErr_Occurred()) SWIG_fail;
29335 }
29336 {
29337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29338 }
29339 return resultobj;
29340fail:
29341 return NULL;
d55e5bfc
RD
29342}
29343
29344
1bd55598
RD
29345SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29346 PyObject *resultobj = 0;
29347 wxIdleMode arg1 ;
29348 int val1 ;
29349 int ecode1 = 0 ;
29350 PyObject * obj0 = 0 ;
29351 char * kwnames[] = {
29352 (char *) "mode", NULL
29353 };
29354
29355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29356 ecode1 = SWIG_AsVal_int(obj0, &val1);
29357 if (!SWIG_IsOK(ecode1)) {
29358 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29359 }
29360 arg1 = static_cast< wxIdleMode >(val1);
29361 {
29362 PyThreadState* __tstate = wxPyBeginAllowThreads();
29363 wxIdleEvent::SetMode(arg1);
29364 wxPyEndAllowThreads(__tstate);
29365 if (PyErr_Occurred()) SWIG_fail;
29366 }
29367 resultobj = SWIG_Py_Void();
29368 return resultobj;
29369fail:
29370 return NULL;
d55e5bfc
RD
29371}
29372
29373
1bd55598
RD
29374SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29375 PyObject *resultobj = 0;
29376 wxIdleMode result;
29377
29378 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29379 {
29380 PyThreadState* __tstate = wxPyBeginAllowThreads();
29381 result = (wxIdleMode)wxIdleEvent::GetMode();
29382 wxPyEndAllowThreads(__tstate);
29383 if (PyErr_Occurred()) SWIG_fail;
29384 }
29385 resultobj = SWIG_From_int(static_cast< int >(result));
29386 return resultobj;
29387fail:
29388 return NULL;
29389}
29390
29391
29392SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29393 PyObject *resultobj = 0;
29394 wxWindow *arg1 = (wxWindow *) 0 ;
29395 bool result;
29396 void *argp1 = 0 ;
29397 int res1 = 0 ;
29398 PyObject * obj0 = 0 ;
29399 char * kwnames[] = {
29400 (char *) "win", NULL
29401 };
29402
29403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29405 if (!SWIG_IsOK(res1)) {
29406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29407 }
29408 arg1 = reinterpret_cast< wxWindow * >(argp1);
29409 {
29410 PyThreadState* __tstate = wxPyBeginAllowThreads();
29411 result = (bool)wxIdleEvent::CanSend(arg1);
29412 wxPyEndAllowThreads(__tstate);
29413 if (PyErr_Occurred()) SWIG_fail;
29414 }
29415 {
29416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29417 }
29418 return resultobj;
29419fail:
29420 return NULL;
d55e5bfc
RD
29421}
29422
29423
1bd55598
RD
29424SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29425 PyObject *obj;
29426 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29427 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29428 return SWIG_Py_Void();
d55e5bfc
RD
29429}
29430
1bd55598
RD
29431SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29432 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
29433}
29434
2131d850
RD
29435SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29436 PyObject *resultobj = 0;
29437 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29438 int arg2 = (int) 0 ;
29439 wxClipboardTextEvent *result = 0 ;
29440 int val1 ;
29441 int ecode1 = 0 ;
29442 int val2 ;
29443 int ecode2 = 0 ;
29444 PyObject * obj0 = 0 ;
29445 PyObject * obj1 = 0 ;
29446 char * kwnames[] = {
29447 (char *) "type",(char *) "winid", NULL
29448 };
29449
29450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29451 if (obj0) {
29452 ecode1 = SWIG_AsVal_int(obj0, &val1);
29453 if (!SWIG_IsOK(ecode1)) {
29454 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29455 }
29456 arg1 = static_cast< wxEventType >(val1);
29457 }
29458 if (obj1) {
29459 ecode2 = SWIG_AsVal_int(obj1, &val2);
29460 if (!SWIG_IsOK(ecode2)) {
29461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29462 }
29463 arg2 = static_cast< int >(val2);
29464 }
29465 {
29466 PyThreadState* __tstate = wxPyBeginAllowThreads();
29467 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29468 wxPyEndAllowThreads(__tstate);
29469 if (PyErr_Occurred()) SWIG_fail;
29470 }
29471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29472 return resultobj;
29473fail:
29474 return NULL;
29475}
29476
29477
29478SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29479 PyObject *obj;
29480 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29481 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29482 return SWIG_Py_Void();
29483}
29484
29485SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29486 return SWIG_Python_InitShadowInstance(args);
29487}
29488
1bd55598
RD
29489SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29490 PyObject *resultobj = 0;
29491 int arg1 = (int) 0 ;
29492 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29493 wxPyEvent *result = 0 ;
29494 int val1 ;
29495 int ecode1 = 0 ;
29496 int val2 ;
29497 int ecode2 = 0 ;
29498 PyObject * obj0 = 0 ;
29499 PyObject * obj1 = 0 ;
29500 char * kwnames[] = {
29501 (char *) "winid",(char *) "eventType", NULL
29502 };
29503
29504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29505 if (obj0) {
29506 ecode1 = SWIG_AsVal_int(obj0, &val1);
29507 if (!SWIG_IsOK(ecode1)) {
29508 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29509 }
29510 arg1 = static_cast< int >(val1);
29511 }
29512 if (obj1) {
29513 ecode2 = SWIG_AsVal_int(obj1, &val2);
29514 if (!SWIG_IsOK(ecode2)) {
29515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29516 }
29517 arg2 = static_cast< wxEventType >(val2);
29518 }
29519 {
29520 PyThreadState* __tstate = wxPyBeginAllowThreads();
29521 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29522 wxPyEndAllowThreads(__tstate);
29523 if (PyErr_Occurred()) SWIG_fail;
29524 }
29525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29526 return resultobj;
29527fail:
29528 return NULL;
d55e5bfc
RD
29529}
29530
29531
1bd55598
RD
29532SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29533 PyObject *resultobj = 0;
29534 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29535 void *argp1 = 0 ;
29536 int res1 = 0 ;
29537 PyObject *swig_obj[1] ;
29538
29539 if (!args) SWIG_fail;
29540 swig_obj[0] = args;
29541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29542 if (!SWIG_IsOK(res1)) {
29543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29544 }
29545 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29546 {
29547 PyThreadState* __tstate = wxPyBeginAllowThreads();
29548 delete arg1;
d55e5bfc 29549
1bd55598
RD
29550 wxPyEndAllowThreads(__tstate);
29551 if (PyErr_Occurred()) SWIG_fail;
29552 }
29553 resultobj = SWIG_Py_Void();
29554 return resultobj;
29555fail:
29556 return NULL;
29557}
29558
29559
29560SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29561 PyObject *resultobj = 0;
29562 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29563 PyObject *arg2 = (PyObject *) 0 ;
29564 void *argp1 = 0 ;
29565 int res1 = 0 ;
29566 PyObject * obj0 = 0 ;
29567 PyObject * obj1 = 0 ;
29568 char * kwnames[] = {
29569 (char *) "self",(char *) "self", NULL
29570 };
29571
29572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29574 if (!SWIG_IsOK(res1)) {
29575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29576 }
29577 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29578 arg2 = obj1;
29579 {
29580 PyThreadState* __tstate = wxPyBeginAllowThreads();
29581 (arg1)->SetSelf(arg2);
29582 wxPyEndAllowThreads(__tstate);
29583 if (PyErr_Occurred()) SWIG_fail;
29584 }
29585 resultobj = SWIG_Py_Void();
29586 return resultobj;
29587fail:
29588 return NULL;
d55e5bfc
RD
29589}
29590
29591
1bd55598
RD
29592SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29593 PyObject *resultobj = 0;
29594 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29595 PyObject *result = 0 ;
29596 void *argp1 = 0 ;
29597 int res1 = 0 ;
29598 PyObject *swig_obj[1] ;
29599
29600 if (!args) SWIG_fail;
29601 swig_obj[0] = args;
29602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29603 if (!SWIG_IsOK(res1)) {
29604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29605 }
29606 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29607 {
29608 PyThreadState* __tstate = wxPyBeginAllowThreads();
29609 result = (PyObject *)(arg1)->GetSelf();
29610 wxPyEndAllowThreads(__tstate);
29611 if (PyErr_Occurred()) SWIG_fail;
29612 }
29613 resultobj = result;
29614 return resultobj;
29615fail:
29616 return NULL;
d55e5bfc
RD
29617}
29618
29619
1bd55598
RD
29620SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29621 PyObject *obj;
29622 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29623 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29624 return SWIG_Py_Void();
d55e5bfc
RD
29625}
29626
1bd55598
RD
29627SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29628 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
29629}
29630
1bd55598
RD
29631SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29632 PyObject *resultobj = 0;
29633 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29634 int arg2 = (int) 0 ;
29635 wxPyCommandEvent *result = 0 ;
29636 int val1 ;
29637 int ecode1 = 0 ;
29638 int val2 ;
29639 int ecode2 = 0 ;
29640 PyObject * obj0 = 0 ;
29641 PyObject * obj1 = 0 ;
29642 char * kwnames[] = {
29643 (char *) "eventType",(char *) "id", NULL
29644 };
29645
29646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29647 if (obj0) {
29648 ecode1 = SWIG_AsVal_int(obj0, &val1);
29649 if (!SWIG_IsOK(ecode1)) {
29650 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29651 }
29652 arg1 = static_cast< wxEventType >(val1);
29653 }
29654 if (obj1) {
29655 ecode2 = SWIG_AsVal_int(obj1, &val2);
29656 if (!SWIG_IsOK(ecode2)) {
29657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29658 }
29659 arg2 = static_cast< int >(val2);
29660 }
29661 {
29662 PyThreadState* __tstate = wxPyBeginAllowThreads();
29663 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29664 wxPyEndAllowThreads(__tstate);
29665 if (PyErr_Occurred()) SWIG_fail;
29666 }
29667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29668 return resultobj;
29669fail:
29670 return NULL;
d55e5bfc
RD
29671}
29672
29673
1bd55598
RD
29674SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29675 PyObject *resultobj = 0;
29676 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29677 void *argp1 = 0 ;
29678 int res1 = 0 ;
29679 PyObject *swig_obj[1] ;
29680
29681 if (!args) SWIG_fail;
29682 swig_obj[0] = args;
29683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29684 if (!SWIG_IsOK(res1)) {
29685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29686 }
29687 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29688 {
29689 PyThreadState* __tstate = wxPyBeginAllowThreads();
29690 delete arg1;
d55e5bfc 29691
1bd55598
RD
29692 wxPyEndAllowThreads(__tstate);
29693 if (PyErr_Occurred()) SWIG_fail;
29694 }
29695 resultobj = SWIG_Py_Void();
29696 return resultobj;
29697fail:
29698 return NULL;
29699}
29700
29701
29702SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29703 PyObject *resultobj = 0;
29704 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29705 PyObject *arg2 = (PyObject *) 0 ;
29706 void *argp1 = 0 ;
29707 int res1 = 0 ;
29708 PyObject * obj0 = 0 ;
29709 PyObject * obj1 = 0 ;
29710 char * kwnames[] = {
29711 (char *) "self",(char *) "self", NULL
29712 };
29713
29714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29716 if (!SWIG_IsOK(res1)) {
29717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29718 }
29719 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29720 arg2 = obj1;
29721 {
29722 PyThreadState* __tstate = wxPyBeginAllowThreads();
29723 (arg1)->SetSelf(arg2);
29724 wxPyEndAllowThreads(__tstate);
29725 if (PyErr_Occurred()) SWIG_fail;
29726 }
29727 resultobj = SWIG_Py_Void();
29728 return resultobj;
29729fail:
29730 return NULL;
d55e5bfc
RD
29731}
29732
29733
1bd55598
RD
29734SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29735 PyObject *resultobj = 0;
29736 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29737 PyObject *result = 0 ;
29738 void *argp1 = 0 ;
29739 int res1 = 0 ;
29740 PyObject *swig_obj[1] ;
29741
29742 if (!args) SWIG_fail;
29743 swig_obj[0] = args;
29744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29745 if (!SWIG_IsOK(res1)) {
29746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29747 }
29748 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29749 {
29750 PyThreadState* __tstate = wxPyBeginAllowThreads();
29751 result = (PyObject *)(arg1)->GetSelf();
29752 wxPyEndAllowThreads(__tstate);
29753 if (PyErr_Occurred()) SWIG_fail;
29754 }
29755 resultobj = result;
29756 return resultobj;
29757fail:
29758 return NULL;
29759}
29760
29761
29762SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29763 PyObject *obj;
29764 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29765 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29766 return SWIG_Py_Void();
29767}
29768
29769SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29770 return SWIG_Python_InitShadowInstance(args);
29771}
29772
29773SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29774 PyObject *resultobj = 0;
29775 wxWindow *arg1 = (wxWindow *) 0 ;
29776 wxDateTime *arg2 = 0 ;
29777 wxEventType arg3 ;
29778 wxDateEvent *result = 0 ;
29779 void *argp1 = 0 ;
29780 int res1 = 0 ;
29781 void *argp2 = 0 ;
29782 int res2 = 0 ;
29783 int val3 ;
29784 int ecode3 = 0 ;
29785 PyObject * obj0 = 0 ;
29786 PyObject * obj1 = 0 ;
29787 PyObject * obj2 = 0 ;
29788 char * kwnames[] = {
29789 (char *) "win",(char *) "dt",(char *) "type", NULL
29790 };
29791
29792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29794 if (!SWIG_IsOK(res1)) {
29795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29796 }
29797 arg1 = reinterpret_cast< wxWindow * >(argp1);
29798 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29799 if (!SWIG_IsOK(res2)) {
29800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29801 }
29802 if (!argp2) {
29803 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29804 }
29805 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29806 ecode3 = SWIG_AsVal_int(obj2, &val3);
29807 if (!SWIG_IsOK(ecode3)) {
29808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29809 }
29810 arg3 = static_cast< wxEventType >(val3);
29811 {
29812 PyThreadState* __tstate = wxPyBeginAllowThreads();
29813 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29814 wxPyEndAllowThreads(__tstate);
29815 if (PyErr_Occurred()) SWIG_fail;
29816 }
29817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29818 return resultobj;
29819fail:
29820 return NULL;
d55e5bfc
RD
29821}
29822
29823
1bd55598
RD
29824SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29825 PyObject *resultobj = 0;
29826 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29827 wxDateTime *result = 0 ;
29828 void *argp1 = 0 ;
29829 int res1 = 0 ;
29830 PyObject *swig_obj[1] ;
29831
29832 if (!args) SWIG_fail;
29833 swig_obj[0] = args;
29834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29835 if (!SWIG_IsOK(res1)) {
29836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29837 }
29838 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29839 {
29840 PyThreadState* __tstate = wxPyBeginAllowThreads();
36ed4f51 29841 {
1bd55598
RD
29842 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29843 result = (wxDateTime *) &_result_ref;
36ed4f51 29844 }
1bd55598
RD
29845 wxPyEndAllowThreads(__tstate);
29846 if (PyErr_Occurred()) SWIG_fail;
29847 }
29848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29849 return resultobj;
29850fail:
29851 return NULL;
29852}
29853
29854
29855SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29856 PyObject *resultobj = 0;
29857 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29858 wxDateTime *arg2 = 0 ;
29859 void *argp1 = 0 ;
29860 int res1 = 0 ;
29861 void *argp2 = 0 ;
29862 int res2 = 0 ;
29863 PyObject * obj0 = 0 ;
29864 PyObject * obj1 = 0 ;
29865 char * kwnames[] = {
29866 (char *) "self",(char *) "date", NULL
29867 };
29868
29869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29871 if (!SWIG_IsOK(res1)) {
29872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29873 }
29874 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29875 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29876 if (!SWIG_IsOK(res2)) {
29877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29878 }
29879 if (!argp2) {
29880 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29881 }
29882 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29883 {
29884 PyThreadState* __tstate = wxPyBeginAllowThreads();
29885 (arg1)->SetDate((wxDateTime const &)*arg2);
29886 wxPyEndAllowThreads(__tstate);
29887 if (PyErr_Occurred()) SWIG_fail;
29888 }
29889 resultobj = SWIG_Py_Void();
29890 return resultobj;
29891fail:
29892 return NULL;
d55e5bfc
RD
29893}
29894
29895
1bd55598
RD
29896SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29897 PyObject *obj;
29898 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29899 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29900 return SWIG_Py_Void();
d55e5bfc
RD
29901}
29902
1bd55598
RD
29903SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29904 return SWIG_Python_InitShadowInstance(args);
29905}
d55e5bfc 29906
1bd55598
RD
29907SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29908 PyObject *resultobj = 0;
29909 wxPyApp *result = 0 ;
29910
29911 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
29912 {
29913 PyThreadState* __tstate = wxPyBeginAllowThreads();
29914 result = (wxPyApp *)new_wxPyApp();
29915 wxPyEndAllowThreads(__tstate);
29916 if (PyErr_Occurred()) SWIG_fail;
29917 }
29918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
29919 return resultobj;
29920fail:
29921 return NULL;
d55e5bfc
RD
29922}
29923
29924
1bd55598
RD
29925SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29926 PyObject *resultobj = 0;
29927 wxPyApp *arg1 = (wxPyApp *) 0 ;
29928 void *argp1 = 0 ;
29929 int res1 = 0 ;
29930 PyObject *swig_obj[1] ;
29931
29932 if (!args) SWIG_fail;
29933 swig_obj[0] = args;
29934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
29935 if (!SWIG_IsOK(res1)) {
29936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29937 }
29938 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29939 {
29940 PyThreadState* __tstate = wxPyBeginAllowThreads();
29941 delete arg1;
d55e5bfc 29942
1bd55598
RD
29943 wxPyEndAllowThreads(__tstate);
29944 if (PyErr_Occurred()) SWIG_fail;
29945 }
29946 resultobj = SWIG_Py_Void();
29947 return resultobj;
29948fail:
29949 return NULL;
29950}
29951
29952
29953SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29954 PyObject *resultobj = 0;
29955 wxPyApp *arg1 = (wxPyApp *) 0 ;
29956 PyObject *arg2 = (PyObject *) 0 ;
29957 PyObject *arg3 = (PyObject *) 0 ;
c25f90f6 29958 bool arg4 = (bool) false ;
1bd55598
RD
29959 void *argp1 = 0 ;
29960 int res1 = 0 ;
29961 bool val4 ;
29962 int ecode4 = 0 ;
29963 PyObject * obj0 = 0 ;
29964 PyObject * obj1 = 0 ;
29965 PyObject * obj2 = 0 ;
29966 PyObject * obj3 = 0 ;
29967 char * kwnames[] = {
29968 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
29969 };
29970
c25f90f6 29971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
1bd55598
RD
29972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29973 if (!SWIG_IsOK(res1)) {
29974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
29975 }
29976 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29977 arg2 = obj1;
29978 arg3 = obj2;
c25f90f6
RD
29979 if (obj3) {
29980 ecode4 = SWIG_AsVal_bool(obj3, &val4);
29981 if (!SWIG_IsOK(ecode4)) {
29982 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
29983 }
29984 arg4 = static_cast< bool >(val4);
29985 }
1bd55598
RD
29986 {
29987 PyThreadState* __tstate = wxPyBeginAllowThreads();
29988 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
29989 wxPyEndAllowThreads(__tstate);
29990 if (PyErr_Occurred()) SWIG_fail;
29991 }
29992 resultobj = SWIG_Py_Void();
29993 return resultobj;
29994fail:
29995 return NULL;
d55e5bfc
RD
29996}
29997
29998
1bd55598
RD
29999SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30000 PyObject *resultobj = 0;
30001 wxPyApp *arg1 = (wxPyApp *) 0 ;
30002 wxString result;
30003 void *argp1 = 0 ;
30004 int res1 = 0 ;
30005 PyObject *swig_obj[1] ;
30006
30007 if (!args) SWIG_fail;
30008 swig_obj[0] = args;
30009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30010 if (!SWIG_IsOK(res1)) {
30011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30012 }
30013 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30014 {
30015 PyThreadState* __tstate = wxPyBeginAllowThreads();
30016 result = ((wxPyApp const *)arg1)->GetAppName();
30017 wxPyEndAllowThreads(__tstate);
30018 if (PyErr_Occurred()) SWIG_fail;
30019 }
30020 {
30021#if wxUSE_UNICODE
30022 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30023#else
30024 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30025#endif
30026 }
30027 return resultobj;
30028fail:
30029 return NULL;
30030}
30031
30032
30033SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30034 PyObject *resultobj = 0;
30035 wxPyApp *arg1 = (wxPyApp *) 0 ;
30036 wxString *arg2 = 0 ;
30037 void *argp1 = 0 ;
30038 int res1 = 0 ;
30039 bool temp2 = false ;
30040 PyObject * obj0 = 0 ;
30041 PyObject * obj1 = 0 ;
30042 char * kwnames[] = {
30043 (char *) "self",(char *) "name", NULL
30044 };
30045
30046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30048 if (!SWIG_IsOK(res1)) {
30049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30050 }
30051 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30052 {
30053 arg2 = wxString_in_helper(obj1);
30054 if (arg2 == NULL) SWIG_fail;
30055 temp2 = true;
30056 }
30057 {
30058 PyThreadState* __tstate = wxPyBeginAllowThreads();
30059 (arg1)->SetAppName((wxString const &)*arg2);
30060 wxPyEndAllowThreads(__tstate);
30061 if (PyErr_Occurred()) SWIG_fail;
30062 }
30063 resultobj = SWIG_Py_Void();
30064 {
30065 if (temp2)
30066 delete arg2;
30067 }
30068 return resultobj;
30069fail:
30070 {
30071 if (temp2)
30072 delete arg2;
30073 }
30074 return NULL;
d55e5bfc
RD
30075}
30076
30077
1bd55598
RD
30078SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30079 PyObject *resultobj = 0;
30080 wxPyApp *arg1 = (wxPyApp *) 0 ;
30081 wxString result;
30082 void *argp1 = 0 ;
30083 int res1 = 0 ;
30084 PyObject *swig_obj[1] ;
30085
30086 if (!args) SWIG_fail;
30087 swig_obj[0] = args;
30088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30089 if (!SWIG_IsOK(res1)) {
30090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30091 }
30092 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30093 {
30094 PyThreadState* __tstate = wxPyBeginAllowThreads();
30095 result = ((wxPyApp const *)arg1)->GetClassName();
30096 wxPyEndAllowThreads(__tstate);
30097 if (PyErr_Occurred()) SWIG_fail;
30098 }
30099 {
30100#if wxUSE_UNICODE
30101 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30102#else
30103 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30104#endif
30105 }
30106 return resultobj;
30107fail:
30108 return NULL;
30109}
30110
30111
30112SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30113 PyObject *resultobj = 0;
30114 wxPyApp *arg1 = (wxPyApp *) 0 ;
30115 wxString *arg2 = 0 ;
30116 void *argp1 = 0 ;
30117 int res1 = 0 ;
30118 bool temp2 = false ;
30119 PyObject * obj0 = 0 ;
30120 PyObject * obj1 = 0 ;
30121 char * kwnames[] = {
30122 (char *) "self",(char *) "name", NULL
30123 };
30124
30125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30127 if (!SWIG_IsOK(res1)) {
30128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30129 }
30130 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30131 {
30132 arg2 = wxString_in_helper(obj1);
30133 if (arg2 == NULL) SWIG_fail;
30134 temp2 = true;
30135 }
30136 {
30137 PyThreadState* __tstate = wxPyBeginAllowThreads();
30138 (arg1)->SetClassName((wxString const &)*arg2);
30139 wxPyEndAllowThreads(__tstate);
30140 if (PyErr_Occurred()) SWIG_fail;
30141 }
30142 resultobj = SWIG_Py_Void();
30143 {
30144 if (temp2)
30145 delete arg2;
30146 }
30147 return resultobj;
30148fail:
30149 {
30150 if (temp2)
30151 delete arg2;
30152 }
30153 return NULL;
d55e5bfc
RD
30154}
30155
30156
1bd55598
RD
30157SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30158 PyObject *resultobj = 0;
30159 wxPyApp *arg1 = (wxPyApp *) 0 ;
30160 wxString *result = 0 ;
30161 void *argp1 = 0 ;
30162 int res1 = 0 ;
30163 PyObject *swig_obj[1] ;
30164
30165 if (!args) SWIG_fail;
30166 swig_obj[0] = args;
30167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30168 if (!SWIG_IsOK(res1)) {
30169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30170 }
30171 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30172 {
30173 PyThreadState* __tstate = wxPyBeginAllowThreads();
36ed4f51 30174 {
1bd55598
RD
30175 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30176 result = (wxString *) &_result_ref;
36ed4f51 30177 }
1bd55598
RD
30178 wxPyEndAllowThreads(__tstate);
30179 if (PyErr_Occurred()) SWIG_fail;
30180 }
30181 {
30182#if wxUSE_UNICODE
30183 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30184#else
30185 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30186#endif
30187 }
30188 return resultobj;
30189fail:
30190 return NULL;
30191}
30192
30193
30194SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30195 PyObject *resultobj = 0;
30196 wxPyApp *arg1 = (wxPyApp *) 0 ;
30197 wxString *arg2 = 0 ;
30198 void *argp1 = 0 ;
30199 int res1 = 0 ;
30200 bool temp2 = false ;
30201 PyObject * obj0 = 0 ;
30202 PyObject * obj1 = 0 ;
30203 char * kwnames[] = {
30204 (char *) "self",(char *) "name", NULL
30205 };
30206
30207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30209 if (!SWIG_IsOK(res1)) {
30210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30211 }
30212 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30213 {
30214 arg2 = wxString_in_helper(obj1);
30215 if (arg2 == NULL) SWIG_fail;
30216 temp2 = true;
30217 }
30218 {
30219 PyThreadState* __tstate = wxPyBeginAllowThreads();
30220 (arg1)->SetVendorName((wxString const &)*arg2);
30221 wxPyEndAllowThreads(__tstate);
30222 if (PyErr_Occurred()) SWIG_fail;
30223 }
30224 resultobj = SWIG_Py_Void();
30225 {
30226 if (temp2)
30227 delete arg2;
30228 }
30229 return resultobj;
30230fail:
30231 {
30232 if (temp2)
30233 delete arg2;
30234 }
30235 return NULL;
30236}
d55e5bfc
RD
30237
30238
1bd55598
RD
30239SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30240 PyObject *resultobj = 0;
30241 wxPyApp *arg1 = (wxPyApp *) 0 ;
30242 wxAppTraits *result = 0 ;
30243 void *argp1 = 0 ;
30244 int res1 = 0 ;
30245 PyObject *swig_obj[1] ;
30246
30247 if (!args) SWIG_fail;
30248 swig_obj[0] = args;
30249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30250 if (!SWIG_IsOK(res1)) {
30251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30252 }
30253 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30254 {
30255 PyThreadState* __tstate = wxPyBeginAllowThreads();
30256 result = (wxAppTraits *)(arg1)->GetTraits();
30257 wxPyEndAllowThreads(__tstate);
30258 if (PyErr_Occurred()) SWIG_fail;
30259 }
30260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30261 return resultobj;
30262fail:
30263 return NULL;
d55e5bfc
RD
30264}
30265
30266
1bd55598
RD
30267SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30268 PyObject *resultobj = 0;
30269 wxPyApp *arg1 = (wxPyApp *) 0 ;
30270 void *argp1 = 0 ;
30271 int res1 = 0 ;
30272 PyObject *swig_obj[1] ;
30273
30274 if (!args) SWIG_fail;
30275 swig_obj[0] = args;
30276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30277 if (!SWIG_IsOK(res1)) {
30278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30279 }
30280 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30281 {
30282 PyThreadState* __tstate = wxPyBeginAllowThreads();
30283 (arg1)->ProcessPendingEvents();
30284 wxPyEndAllowThreads(__tstate);
30285 if (PyErr_Occurred()) SWIG_fail;
30286 }
30287 resultobj = SWIG_Py_Void();
30288 return resultobj;
30289fail:
30290 return NULL;
30291}
30292
30293
30294SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30295 PyObject *resultobj = 0;
30296 wxPyApp *arg1 = (wxPyApp *) 0 ;
30297 bool arg2 = (bool) false ;
30298 bool result;
30299 void *argp1 = 0 ;
30300 int res1 = 0 ;
30301 bool val2 ;
30302 int ecode2 = 0 ;
30303 PyObject * obj0 = 0 ;
30304 PyObject * obj1 = 0 ;
30305 char * kwnames[] = {
30306 (char *) "self",(char *) "onlyIfNeeded", NULL
30307 };
30308
30309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30311 if (!SWIG_IsOK(res1)) {
30312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30313 }
30314 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30315 if (obj1) {
30316 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30317 if (!SWIG_IsOK(ecode2)) {
30318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30319 }
30320 arg2 = static_cast< bool >(val2);
30321 }
30322 {
30323 PyThreadState* __tstate = wxPyBeginAllowThreads();
30324 result = (bool)(arg1)->Yield(arg2);
30325 wxPyEndAllowThreads(__tstate);
30326 if (PyErr_Occurred()) SWIG_fail;
30327 }
30328 {
30329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30330 }
30331 return resultobj;
30332fail:
30333 return NULL;
d55e5bfc
RD
30334}
30335
30336
1bd55598
RD
30337SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30338 PyObject *resultobj = 0;
30339 wxPyApp *arg1 = (wxPyApp *) 0 ;
30340 void *argp1 = 0 ;
30341 int res1 = 0 ;
30342 PyObject *swig_obj[1] ;
30343
30344 if (!args) SWIG_fail;
30345 swig_obj[0] = args;
30346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30347 if (!SWIG_IsOK(res1)) {
30348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30349 }
30350 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30351 {
30352 PyThreadState* __tstate = wxPyBeginAllowThreads();
30353 (arg1)->WakeUpIdle();
30354 wxPyEndAllowThreads(__tstate);
30355 if (PyErr_Occurred()) SWIG_fail;
30356 }
30357 resultobj = SWIG_Py_Void();
30358 return resultobj;
30359fail:
30360 return NULL;
d55e5bfc
RD
30361}
30362
30363
1bd55598
RD
30364SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30365 PyObject *resultobj = 0;
30366 bool result;
30367
30368 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30369 {
30370 PyThreadState* __tstate = wxPyBeginAllowThreads();
30371 result = (bool)wxPyApp::IsMainLoopRunning();
30372 wxPyEndAllowThreads(__tstate);
30373 if (PyErr_Occurred()) SWIG_fail;
30374 }
30375 {
30376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30377 }
30378 return resultobj;
30379fail:
30380 return NULL;
d55e5bfc
RD
30381}
30382
30383
1bd55598
RD
30384SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30385 PyObject *resultobj = 0;
30386 wxPyApp *arg1 = (wxPyApp *) 0 ;
30387 int result;
30388 void *argp1 = 0 ;
30389 int res1 = 0 ;
30390 PyObject *swig_obj[1] ;
30391
30392 if (!args) SWIG_fail;
30393 swig_obj[0] = args;
30394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30395 if (!SWIG_IsOK(res1)) {
30396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30397 }
30398 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30399 {
30400 PyThreadState* __tstate = wxPyBeginAllowThreads();
30401 result = (int)(arg1)->MainLoop();
30402 wxPyEndAllowThreads(__tstate);
30403 if (PyErr_Occurred()) SWIG_fail;
30404 }
30405 resultobj = SWIG_From_int(static_cast< int >(result));
30406 return resultobj;
30407fail:
30408 return NULL;
d55e5bfc
RD
30409}
30410
30411
1bd55598
RD
30412SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30413 PyObject *resultobj = 0;
30414 wxPyApp *arg1 = (wxPyApp *) 0 ;
30415 void *argp1 = 0 ;
30416 int res1 = 0 ;
30417 PyObject *swig_obj[1] ;
30418
30419 if (!args) SWIG_fail;
30420 swig_obj[0] = args;
30421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30422 if (!SWIG_IsOK(res1)) {
30423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30424 }
30425 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30426 {
30427 PyThreadState* __tstate = wxPyBeginAllowThreads();
30428 (arg1)->Exit();
30429 wxPyEndAllowThreads(__tstate);
30430 if (PyErr_Occurred()) SWIG_fail;
30431 }
30432 resultobj = SWIG_Py_Void();
30433 return resultobj;
30434fail:
30435 return NULL;
d55e5bfc
RD
30436}
30437
30438
ac5d357a
RD
30439SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30440 PyObject *resultobj = 0;
30441 wxPyApp *arg1 = (wxPyApp *) 0 ;
30442 wxLayoutDirection result;
30443 void *argp1 = 0 ;
30444 int res1 = 0 ;
30445 PyObject *swig_obj[1] ;
30446
30447 if (!args) SWIG_fail;
30448 swig_obj[0] = args;
30449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30450 if (!SWIG_IsOK(res1)) {
30451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30452 }
30453 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30454 {
30455 PyThreadState* __tstate = wxPyBeginAllowThreads();
994453b8 30456 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
ac5d357a
RD
30457 wxPyEndAllowThreads(__tstate);
30458 if (PyErr_Occurred()) SWIG_fail;
30459 }
994453b8 30460 resultobj = SWIG_From_int(static_cast< int >(result));
ac5d357a
RD
30461 return resultobj;
30462fail:
30463 return NULL;
30464}
30465
30466
1bd55598
RD
30467SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30468 PyObject *resultobj = 0;
30469 wxPyApp *arg1 = (wxPyApp *) 0 ;
30470 void *argp1 = 0 ;
30471 int res1 = 0 ;
30472 PyObject *swig_obj[1] ;
30473
30474 if (!args) SWIG_fail;
30475 swig_obj[0] = args;
30476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30477 if (!SWIG_IsOK(res1)) {
30478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30479 }
30480 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30481 {
30482 PyThreadState* __tstate = wxPyBeginAllowThreads();
30483 (arg1)->ExitMainLoop();
30484 wxPyEndAllowThreads(__tstate);
30485 if (PyErr_Occurred()) SWIG_fail;
30486 }
30487 resultobj = SWIG_Py_Void();
30488 return resultobj;
30489fail:
30490 return NULL;
d55e5bfc
RD
30491}
30492
30493
1bd55598
RD
30494SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30495 PyObject *resultobj = 0;
30496 wxPyApp *arg1 = (wxPyApp *) 0 ;
30497 bool result;
30498 void *argp1 = 0 ;
30499 int res1 = 0 ;
30500 PyObject *swig_obj[1] ;
30501
30502 if (!args) SWIG_fail;
30503 swig_obj[0] = args;
30504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30505 if (!SWIG_IsOK(res1)) {
30506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30507 }
30508 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30509 {
30510 PyThreadState* __tstate = wxPyBeginAllowThreads();
30511 result = (bool)(arg1)->Pending();
30512 wxPyEndAllowThreads(__tstate);
30513 if (PyErr_Occurred()) SWIG_fail;
30514 }
30515 {
30516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30517 }
30518 return resultobj;
30519fail:
30520 return NULL;
d55e5bfc
RD
30521}
30522
30523
1bd55598
RD
30524SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30525 PyObject *resultobj = 0;
30526 wxPyApp *arg1 = (wxPyApp *) 0 ;
30527 bool result;
30528 void *argp1 = 0 ;
30529 int res1 = 0 ;
30530 PyObject *swig_obj[1] ;
30531
30532 if (!args) SWIG_fail;
30533 swig_obj[0] = args;
30534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30535 if (!SWIG_IsOK(res1)) {
30536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30537 }
30538 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30539 {
30540 PyThreadState* __tstate = wxPyBeginAllowThreads();
30541 result = (bool)(arg1)->Dispatch();
30542 wxPyEndAllowThreads(__tstate);
30543 if (PyErr_Occurred()) SWIG_fail;
30544 }
30545 {
30546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30547 }
30548 return resultobj;
30549fail:
30550 return NULL;
d55e5bfc
RD
30551}
30552
30553
1bd55598
RD
30554SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30555 PyObject *resultobj = 0;
30556 wxPyApp *arg1 = (wxPyApp *) 0 ;
30557 bool result;
30558 void *argp1 = 0 ;
30559 int res1 = 0 ;
30560 PyObject *swig_obj[1] ;
30561
30562 if (!args) SWIG_fail;
30563 swig_obj[0] = args;
30564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30565 if (!SWIG_IsOK(res1)) {
30566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30567 }
30568 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30569 {
30570 PyThreadState* __tstate = wxPyBeginAllowThreads();
30571 result = (bool)(arg1)->ProcessIdle();
30572 wxPyEndAllowThreads(__tstate);
30573 if (PyErr_Occurred()) SWIG_fail;
30574 }
30575 {
30576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30577 }
30578 return resultobj;
30579fail:
30580 return NULL;
30581}
30582
30583
30584SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30585 PyObject *resultobj = 0;
30586 wxPyApp *arg1 = (wxPyApp *) 0 ;
30587 wxWindow *arg2 = (wxWindow *) 0 ;
30588 wxIdleEvent *arg3 = 0 ;
30589 bool result;
30590 void *argp1 = 0 ;
30591 int res1 = 0 ;
30592 void *argp2 = 0 ;
30593 int res2 = 0 ;
30594 void *argp3 = 0 ;
30595 int res3 = 0 ;
30596 PyObject * obj0 = 0 ;
30597 PyObject * obj1 = 0 ;
30598 PyObject * obj2 = 0 ;
30599 char * kwnames[] = {
30600 (char *) "self",(char *) "win",(char *) "event", NULL
30601 };
30602
30603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30605 if (!SWIG_IsOK(res1)) {
30606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30607 }
30608 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30609 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30610 if (!SWIG_IsOK(res2)) {
30611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30612 }
30613 arg2 = reinterpret_cast< wxWindow * >(argp2);
30614 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30615 if (!SWIG_IsOK(res3)) {
30616 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30617 }
30618 if (!argp3) {
30619 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30620 }
30621 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30622 {
30623 PyThreadState* __tstate = wxPyBeginAllowThreads();
30624 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30625 wxPyEndAllowThreads(__tstate);
30626 if (PyErr_Occurred()) SWIG_fail;
30627 }
30628 {
30629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30630 }
30631 return resultobj;
30632fail:
30633 return NULL;
d55e5bfc
RD
30634}
30635
30636
1bd55598
RD
30637SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30638 PyObject *resultobj = 0;
30639 wxPyApp *arg1 = (wxPyApp *) 0 ;
30640 bool result;
30641 void *argp1 = 0 ;
30642 int res1 = 0 ;
30643 PyObject *swig_obj[1] ;
30644
30645 if (!args) SWIG_fail;
30646 swig_obj[0] = args;
30647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30648 if (!SWIG_IsOK(res1)) {
30649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30650 }
30651 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30652 {
30653 PyThreadState* __tstate = wxPyBeginAllowThreads();
30654 result = (bool)((wxPyApp const *)arg1)->IsActive();
30655 wxPyEndAllowThreads(__tstate);
30656 if (PyErr_Occurred()) SWIG_fail;
30657 }
30658 {
30659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30660 }
30661 return resultobj;
30662fail:
30663 return NULL;
30664}
30665
30666
30667SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30668 PyObject *resultobj = 0;
30669 wxPyApp *arg1 = (wxPyApp *) 0 ;
30670 wxWindow *arg2 = (wxWindow *) 0 ;
30671 void *argp1 = 0 ;
30672 int res1 = 0 ;
30673 void *argp2 = 0 ;
30674 int res2 = 0 ;
30675 PyObject * obj0 = 0 ;
30676 PyObject * obj1 = 0 ;
30677 char * kwnames[] = {
30678 (char *) "self",(char *) "win", NULL
30679 };
30680
30681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30683 if (!SWIG_IsOK(res1)) {
30684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30685 }
30686 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30687 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30688 if (!SWIG_IsOK(res2)) {
30689 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30690 }
30691 arg2 = reinterpret_cast< wxWindow * >(argp2);
30692 {
30693 PyThreadState* __tstate = wxPyBeginAllowThreads();
30694 (arg1)->SetTopWindow(arg2);
30695 wxPyEndAllowThreads(__tstate);
30696 if (PyErr_Occurred()) SWIG_fail;
30697 }
30698 resultobj = SWIG_Py_Void();
30699 return resultobj;
30700fail:
30701 return NULL;
d55e5bfc
RD
30702}
30703
30704
1bd55598
RD
30705SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30706 PyObject *resultobj = 0;
30707 wxPyApp *arg1 = (wxPyApp *) 0 ;
30708 wxWindow *result = 0 ;
30709 void *argp1 = 0 ;
30710 int res1 = 0 ;
30711 PyObject *swig_obj[1] ;
30712
30713 if (!args) SWIG_fail;
30714 swig_obj[0] = args;
30715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30716 if (!SWIG_IsOK(res1)) {
30717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30718 }
30719 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30720 {
30721 PyThreadState* __tstate = wxPyBeginAllowThreads();
30722 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30723 wxPyEndAllowThreads(__tstate);
30724 if (PyErr_Occurred()) SWIG_fail;
30725 }
30726 {
30727 resultobj = wxPyMake_wxObject(result, (bool)0);
30728 }
30729 return resultobj;
30730fail:
30731 return NULL;
30732}
30733
30734
30735SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30736 PyObject *resultobj = 0;
30737 wxPyApp *arg1 = (wxPyApp *) 0 ;
30738 bool arg2 ;
30739 void *argp1 = 0 ;
30740 int res1 = 0 ;
30741 bool val2 ;
30742 int ecode2 = 0 ;
30743 PyObject * obj0 = 0 ;
30744 PyObject * obj1 = 0 ;
30745 char * kwnames[] = {
30746 (char *) "self",(char *) "flag", NULL
30747 };
30748
30749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30751 if (!SWIG_IsOK(res1)) {
30752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30753 }
30754 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30755 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30756 if (!SWIG_IsOK(ecode2)) {
30757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30758 }
30759 arg2 = static_cast< bool >(val2);
30760 {
30761 PyThreadState* __tstate = wxPyBeginAllowThreads();
30762 (arg1)->SetExitOnFrameDelete(arg2);
30763 wxPyEndAllowThreads(__tstate);
30764 if (PyErr_Occurred()) SWIG_fail;
30765 }
30766 resultobj = SWIG_Py_Void();
30767 return resultobj;
30768fail:
30769 return NULL;
d55e5bfc
RD
30770}
30771
30772
1bd55598
RD
30773SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30774 PyObject *resultobj = 0;
30775 wxPyApp *arg1 = (wxPyApp *) 0 ;
30776 bool result;
30777 void *argp1 = 0 ;
30778 int res1 = 0 ;
30779 PyObject *swig_obj[1] ;
30780
30781 if (!args) SWIG_fail;
30782 swig_obj[0] = args;
30783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30784 if (!SWIG_IsOK(res1)) {
30785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30786 }
30787 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30788 {
30789 PyThreadState* __tstate = wxPyBeginAllowThreads();
30790 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30791 wxPyEndAllowThreads(__tstate);
30792 if (PyErr_Occurred()) SWIG_fail;
30793 }
30794 {
30795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30796 }
30797 return resultobj;
30798fail:
30799 return NULL;
30800}
30801
30802
30803SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30804 PyObject *resultobj = 0;
30805 wxPyApp *arg1 = (wxPyApp *) 0 ;
30806 bool arg2 ;
eccab1a7 30807 bool arg3 = (bool) false ;
1bd55598
RD
30808 void *argp1 = 0 ;
30809 int res1 = 0 ;
30810 bool val2 ;
30811 int ecode2 = 0 ;
eccab1a7
RD
30812 bool val3 ;
30813 int ecode3 = 0 ;
1bd55598
RD
30814 PyObject * obj0 = 0 ;
30815 PyObject * obj1 = 0 ;
eccab1a7 30816 PyObject * obj2 = 0 ;
1bd55598 30817 char * kwnames[] = {
eccab1a7 30818 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
1bd55598
RD
30819 };
30820
eccab1a7 30821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
1bd55598
RD
30822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30823 if (!SWIG_IsOK(res1)) {
30824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30825 }
30826 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30827 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30828 if (!SWIG_IsOK(ecode2)) {
30829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30830 }
30831 arg2 = static_cast< bool >(val2);
eccab1a7
RD
30832 if (obj2) {
30833 ecode3 = SWIG_AsVal_bool(obj2, &val3);
30834 if (!SWIG_IsOK(ecode3)) {
30835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
30836 }
30837 arg3 = static_cast< bool >(val3);
30838 }
1bd55598
RD
30839 {
30840 PyThreadState* __tstate = wxPyBeginAllowThreads();
eccab1a7 30841 (arg1)->SetUseBestVisual(arg2,arg3);
1bd55598
RD
30842 wxPyEndAllowThreads(__tstate);
30843 if (PyErr_Occurred()) SWIG_fail;
30844 }
30845 resultobj = SWIG_Py_Void();
30846 return resultobj;
30847fail:
30848 return NULL;
d55e5bfc
RD
30849}
30850
30851
1bd55598
RD
30852SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30853 PyObject *resultobj = 0;
30854 wxPyApp *arg1 = (wxPyApp *) 0 ;
30855 bool result;
30856 void *argp1 = 0 ;
30857 int res1 = 0 ;
30858 PyObject *swig_obj[1] ;
30859
30860 if (!args) SWIG_fail;
30861 swig_obj[0] = args;
30862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30863 if (!SWIG_IsOK(res1)) {
30864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30865 }
30866 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30867 {
30868 PyThreadState* __tstate = wxPyBeginAllowThreads();
30869 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30870 wxPyEndAllowThreads(__tstate);
30871 if (PyErr_Occurred()) SWIG_fail;
30872 }
30873 {
30874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30875 }
30876 return resultobj;
30877fail:
30878 return NULL;
30879}
30880
30881
30882SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30883 PyObject *resultobj = 0;
30884 wxPyApp *arg1 = (wxPyApp *) 0 ;
30885 int arg2 ;
30886 void *argp1 = 0 ;
30887 int res1 = 0 ;
30888 int val2 ;
30889 int ecode2 = 0 ;
30890 PyObject * obj0 = 0 ;
30891 PyObject * obj1 = 0 ;
30892 char * kwnames[] = {
30893 (char *) "self",(char *) "mode", NULL
30894 };
30895
30896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30898 if (!SWIG_IsOK(res1)) {
30899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30900 }
30901 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30902 ecode2 = SWIG_AsVal_int(obj1, &val2);
30903 if (!SWIG_IsOK(ecode2)) {
30904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30905 }
30906 arg2 = static_cast< int >(val2);
30907 {
30908 PyThreadState* __tstate = wxPyBeginAllowThreads();
30909 (arg1)->SetPrintMode(arg2);
30910 wxPyEndAllowThreads(__tstate);
30911 if (PyErr_Occurred()) SWIG_fail;
30912 }
30913 resultobj = SWIG_Py_Void();
30914 return resultobj;
30915fail:
30916 return NULL;
d55e5bfc
RD
30917}
30918
30919
1bd55598
RD
30920SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30921 PyObject *resultobj = 0;
30922 wxPyApp *arg1 = (wxPyApp *) 0 ;
30923 int result;
30924 void *argp1 = 0 ;
30925 int res1 = 0 ;
30926 PyObject *swig_obj[1] ;
30927
30928 if (!args) SWIG_fail;
30929 swig_obj[0] = args;
30930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30931 if (!SWIG_IsOK(res1)) {
30932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30933 }
30934 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30935 {
30936 PyThreadState* __tstate = wxPyBeginAllowThreads();
30937 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
30938 wxPyEndAllowThreads(__tstate);
30939 if (PyErr_Occurred()) SWIG_fail;
30940 }
30941 resultobj = SWIG_From_int(static_cast< int >(result));
30942 return resultobj;
30943fail:
30944 return NULL;
30945}
30946
30947
30948SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30949 PyObject *resultobj = 0;
30950 wxPyApp *arg1 = (wxPyApp *) 0 ;
30951 int arg2 ;
30952 void *argp1 = 0 ;
30953 int res1 = 0 ;
30954 int val2 ;
30955 int ecode2 = 0 ;
30956 PyObject * obj0 = 0 ;
30957 PyObject * obj1 = 0 ;
30958 char * kwnames[] = {
30959 (char *) "self",(char *) "mode", NULL
30960 };
30961
30962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
30963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30964 if (!SWIG_IsOK(res1)) {
30965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30966 }
30967 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30968 ecode2 = SWIG_AsVal_int(obj1, &val2);
30969 if (!SWIG_IsOK(ecode2)) {
30970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
30971 }
30972 arg2 = static_cast< int >(val2);
30973 {
30974 PyThreadState* __tstate = wxPyBeginAllowThreads();
30975 (arg1)->SetAssertMode(arg2);
30976 wxPyEndAllowThreads(__tstate);
30977 if (PyErr_Occurred()) SWIG_fail;
30978 }
30979 resultobj = SWIG_Py_Void();
30980 return resultobj;
30981fail:
30982 return NULL;
d55e5bfc
RD
30983}
30984
30985
1bd55598
RD
30986SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30987 PyObject *resultobj = 0;
30988 wxPyApp *arg1 = (wxPyApp *) 0 ;
30989 int result;
30990 void *argp1 = 0 ;
30991 int res1 = 0 ;
30992 PyObject *swig_obj[1] ;
30993
30994 if (!args) SWIG_fail;
30995 swig_obj[0] = args;
30996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30997 if (!SWIG_IsOK(res1)) {
30998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30999 }
31000 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31001 {
31002 PyThreadState* __tstate = wxPyBeginAllowThreads();
31003 result = (int)(arg1)->GetAssertMode();
31004 wxPyEndAllowThreads(__tstate);
31005 if (PyErr_Occurred()) SWIG_fail;
31006 }
31007 resultobj = SWIG_From_int(static_cast< int >(result));
31008 return resultobj;
31009fail:
31010 return NULL;
d55e5bfc
RD
31011}
31012
31013
1bd55598
RD
31014SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31015 PyObject *resultobj = 0;
31016 bool result;
31017
31018 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31019 {
31020 PyThreadState* __tstate = wxPyBeginAllowThreads();
31021 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31022 wxPyEndAllowThreads(__tstate);
31023 if (PyErr_Occurred()) SWIG_fail;
31024 }
31025 {
31026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31027 }
31028 return resultobj;
31029fail:
31030 return NULL;
d55e5bfc
RD
31031}
31032
31033
1bd55598
RD
31034SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31035 PyObject *resultobj = 0;
31036 long result;
31037
31038 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31039 {
31040 PyThreadState* __tstate = wxPyBeginAllowThreads();
31041 result = (long)wxPyApp::GetMacAboutMenuItemId();
31042 wxPyEndAllowThreads(__tstate);
31043 if (PyErr_Occurred()) SWIG_fail;
31044 }
31045 resultobj = SWIG_From_long(static_cast< long >(result));
31046 return resultobj;
31047fail:
31048 return NULL;
d55e5bfc
RD
31049}
31050
31051
1bd55598
RD
31052SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31053 PyObject *resultobj = 0;
31054 long result;
31055
31056 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31057 {
31058 PyThreadState* __tstate = wxPyBeginAllowThreads();
31059 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31060 wxPyEndAllowThreads(__tstate);
31061 if (PyErr_Occurred()) SWIG_fail;
31062 }
31063 resultobj = SWIG_From_long(static_cast< long >(result));
31064 return resultobj;
31065fail:
31066 return NULL;
d55e5bfc
RD
31067}
31068
31069
1bd55598
RD
31070SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31071 PyObject *resultobj = 0;
31072 long result;
31073
31074 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31075 {
31076 PyThreadState* __tstate = wxPyBeginAllowThreads();
31077 result = (long)wxPyApp::GetMacExitMenuItemId();
31078 wxPyEndAllowThreads(__tstate);
31079 if (PyErr_Occurred()) SWIG_fail;
31080 }
31081 resultobj = SWIG_From_long(static_cast< long >(result));
31082 return resultobj;
31083fail:
31084 return NULL;
d55e5bfc
RD
31085}
31086
31087
1bd55598
RD
31088SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31089 PyObject *resultobj = 0;
31090 wxString result;
31091
31092 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31093 {
31094 PyThreadState* __tstate = wxPyBeginAllowThreads();
31095 result = wxPyApp::GetMacHelpMenuTitleName();
31096 wxPyEndAllowThreads(__tstate);
31097 if (PyErr_Occurred()) SWIG_fail;
31098 }
31099 {
31100#if wxUSE_UNICODE
31101 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31102#else
31103 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31104#endif
31105 }
31106 return resultobj;
31107fail:
31108 return NULL;
d55e5bfc
RD
31109}
31110
31111
1bd55598
RD
31112SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31113 PyObject *resultobj = 0;
31114 bool arg1 ;
31115 bool val1 ;
31116 int ecode1 = 0 ;
31117 PyObject * obj0 = 0 ;
31118 char * kwnames[] = {
31119 (char *) "val", NULL
31120 };
31121
31122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31123 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31124 if (!SWIG_IsOK(ecode1)) {
31125 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31126 }
31127 arg1 = static_cast< bool >(val1);
31128 {
31129 PyThreadState* __tstate = wxPyBeginAllowThreads();
31130 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31131 wxPyEndAllowThreads(__tstate);
31132 if (PyErr_Occurred()) SWIG_fail;
31133 }
31134 resultobj = SWIG_Py_Void();
31135 return resultobj;
31136fail:
31137 return NULL;
d55e5bfc
RD
31138}
31139
31140
1bd55598
RD
31141SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31142 PyObject *resultobj = 0;
31143 long arg1 ;
31144 long val1 ;
31145 int ecode1 = 0 ;
31146 PyObject * obj0 = 0 ;
31147 char * kwnames[] = {
31148 (char *) "val", NULL
31149 };
31150
31151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31152 ecode1 = SWIG_AsVal_long(obj0, &val1);
31153 if (!SWIG_IsOK(ecode1)) {
31154 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31155 }
31156 arg1 = static_cast< long >(val1);
31157 {
31158 PyThreadState* __tstate = wxPyBeginAllowThreads();
31159 wxPyApp::SetMacAboutMenuItemId(arg1);
31160 wxPyEndAllowThreads(__tstate);
31161 if (PyErr_Occurred()) SWIG_fail;
31162 }
31163 resultobj = SWIG_Py_Void();
31164 return resultobj;
31165fail:
31166 return NULL;
b1fcee84
RD
31167}
31168
31169
1bd55598
RD
31170SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31171 PyObject *resultobj = 0;
31172 long arg1 ;
31173 long val1 ;
31174 int ecode1 = 0 ;
31175 PyObject * obj0 = 0 ;
31176 char * kwnames[] = {
31177 (char *) "val", NULL
31178 };
31179
31180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31181 ecode1 = SWIG_AsVal_long(obj0, &val1);
31182 if (!SWIG_IsOK(ecode1)) {
31183 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31184 }
31185 arg1 = static_cast< long >(val1);
31186 {
31187 PyThreadState* __tstate = wxPyBeginAllowThreads();
31188 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31189 wxPyEndAllowThreads(__tstate);
31190 if (PyErr_Occurred()) SWIG_fail;
31191 }
31192 resultobj = SWIG_Py_Void();
31193 return resultobj;
31194fail:
31195 return NULL;
d55e5bfc
RD
31196}
31197
31198
1bd55598
RD
31199SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31200 PyObject *resultobj = 0;
31201 long arg1 ;
31202 long val1 ;
31203 int ecode1 = 0 ;
31204 PyObject * obj0 = 0 ;
31205 char * kwnames[] = {
31206 (char *) "val", NULL
31207 };
31208
31209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31210 ecode1 = SWIG_AsVal_long(obj0, &val1);
31211 if (!SWIG_IsOK(ecode1)) {
31212 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31213 }
31214 arg1 = static_cast< long >(val1);
31215 {
31216 PyThreadState* __tstate = wxPyBeginAllowThreads();
31217 wxPyApp::SetMacExitMenuItemId(arg1);
31218 wxPyEndAllowThreads(__tstate);
31219 if (PyErr_Occurred()) SWIG_fail;
31220 }
31221 resultobj = SWIG_Py_Void();
31222 return resultobj;
31223fail:
31224 return NULL;
d55e5bfc
RD
31225}
31226
31227
1bd55598
RD
31228SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31229 PyObject *resultobj = 0;
31230 wxString *arg1 = 0 ;
31231 bool temp1 = false ;
31232 PyObject * obj0 = 0 ;
31233 char * kwnames[] = {
31234 (char *) "val", NULL
31235 };
31236
31237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31238 {
31239 arg1 = wxString_in_helper(obj0);
31240 if (arg1 == NULL) SWIG_fail;
31241 temp1 = true;
31242 }
31243 {
31244 PyThreadState* __tstate = wxPyBeginAllowThreads();
31245 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31246 wxPyEndAllowThreads(__tstate);
31247 if (PyErr_Occurred()) SWIG_fail;
31248 }
31249 resultobj = SWIG_Py_Void();
31250 {
31251 if (temp1)
31252 delete arg1;
31253 }
31254 return resultobj;
31255fail:
31256 {
31257 if (temp1)
31258 delete arg1;
31259 }
31260 return NULL;
d55e5bfc
RD
31261}
31262
31263
1bd55598
RD
31264SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31265 PyObject *resultobj = 0;
31266 wxPyApp *arg1 = (wxPyApp *) 0 ;
31267 void *argp1 = 0 ;
31268 int res1 = 0 ;
31269 PyObject *swig_obj[1] ;
31270
31271 if (!args) SWIG_fail;
31272 swig_obj[0] = args;
31273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31274 if (!SWIG_IsOK(res1)) {
31275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31276 }
31277 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31278 {
31279 PyThreadState* __tstate = wxPyBeginAllowThreads();
31280 (arg1)->_BootstrapApp();
31281 wxPyEndAllowThreads(__tstate);
31282 if (PyErr_Occurred()) SWIG_fail;
31283 }
31284 resultobj = SWIG_Py_Void();
31285 return resultobj;
31286fail:
31287 return NULL;
d55e5bfc
RD
31288}
31289
31290
1bd55598
RD
31291SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31292 PyObject *resultobj = 0;
31293 int result;
31294
31295 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31296 {
31297 PyThreadState* __tstate = wxPyBeginAllowThreads();
31298 result = (int)wxPyApp_GetComCtl32Version();
31299 wxPyEndAllowThreads(__tstate);
31300 if (PyErr_Occurred()) SWIG_fail;
31301 }
31302 resultobj = SWIG_From_int(static_cast< int >(result));
31303 return resultobj;
31304fail:
31305 return NULL;
412d302d
RD
31306}
31307
31308
33d6fd3b 31309SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
fc46b7f3
RD
31310 PyObject *resultobj = 0;
31311 bool result;
31312
33d6fd3b 31313 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
fc46b7f3
RD
31314 {
31315 PyThreadState* __tstate = wxPyBeginAllowThreads();
33d6fd3b 31316 result = (bool)wxPyApp_IsDisplayAvailable();
fc46b7f3
RD
31317 wxPyEndAllowThreads(__tstate);
31318 if (PyErr_Occurred()) SWIG_fail;
31319 }
31320 {
31321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31322 }
31323 return resultobj;
31324fail:
31325 return NULL;
31326}
31327
31328
1bd55598
RD
31329SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31330 PyObject *obj;
31331 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31332 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31333 return SWIG_Py_Void();
d55e5bfc
RD
31334}
31335
1bd55598
RD
31336SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31337 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
31338}
31339
1bd55598
RD
31340SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31341 PyObject *resultobj = 0;
31342
31343 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31344 {
31345 PyThreadState* __tstate = wxPyBeginAllowThreads();
31346 wxExit();
31347 wxPyEndAllowThreads(__tstate);
31348 if (PyErr_Occurred()) SWIG_fail;
31349 }
31350 resultobj = SWIG_Py_Void();
31351 return resultobj;
31352fail:
31353 return NULL;
d55e5bfc
RD
31354}
31355
31356
1bd55598
RD
31357SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31358 PyObject *resultobj = 0;
31359 bool result;
31360
31361 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31362 {
31363 PyThreadState* __tstate = wxPyBeginAllowThreads();
31364 result = (bool)wxYield();
31365 wxPyEndAllowThreads(__tstate);
31366 if (PyErr_Occurred()) SWIG_fail;
31367 }
31368 {
31369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31370 }
31371 return resultobj;
31372fail:
31373 return NULL;
d55e5bfc
RD
31374}
31375
31376
1bd55598
RD
31377SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31378 PyObject *resultobj = 0;
31379 bool result;
31380
31381 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31382 {
31383 PyThreadState* __tstate = wxPyBeginAllowThreads();
31384 result = (bool)wxYieldIfNeeded();
31385 wxPyEndAllowThreads(__tstate);
31386 if (PyErr_Occurred()) SWIG_fail;
31387 }
31388 {
31389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31390 }
31391 return resultobj;
31392fail:
31393 return NULL;
31394}
31395
31396
31397SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31398 PyObject *resultobj = 0;
31399 wxWindow *arg1 = (wxWindow *) NULL ;
31400 bool arg2 = (bool) false ;
31401 bool result;
31402 void *argp1 = 0 ;
31403 int res1 = 0 ;
31404 bool val2 ;
31405 int ecode2 = 0 ;
31406 PyObject * obj0 = 0 ;
31407 PyObject * obj1 = 0 ;
31408 char * kwnames[] = {
31409 (char *) "win",(char *) "onlyIfNeeded", NULL
31410 };
31411
31412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31413 if (obj0) {
31414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31415 if (!SWIG_IsOK(res1)) {
31416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
36ed4f51 31417 }
1bd55598
RD
31418 arg1 = reinterpret_cast< wxWindow * >(argp1);
31419 }
31420 if (obj1) {
31421 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31422 if (!SWIG_IsOK(ecode2)) {
31423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31424 }
31425 arg2 = static_cast< bool >(val2);
31426 }
31427 {
31428 PyThreadState* __tstate = wxPyBeginAllowThreads();
31429 result = (bool)wxSafeYield(arg1,arg2);
31430 wxPyEndAllowThreads(__tstate);
31431 if (PyErr_Occurred()) SWIG_fail;
31432 }
31433 {
31434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31435 }
31436 return resultobj;
31437fail:
31438 return NULL;
d55e5bfc
RD
31439}
31440
31441
1bd55598
RD
31442SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31443 PyObject *resultobj = 0;
31444
31445 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31446 {
31447 PyThreadState* __tstate = wxPyBeginAllowThreads();
31448 wxWakeUpIdle();
31449 wxPyEndAllowThreads(__tstate);
31450 if (PyErr_Occurred()) SWIG_fail;
31451 }
31452 resultobj = SWIG_Py_Void();
31453 return resultobj;
31454fail:
31455 return NULL;
31456}
31457
31458
31459SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31460 PyObject *resultobj = 0;
31461 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31462 wxEvent *arg2 = 0 ;
31463 void *argp1 = 0 ;
31464 int res1 = 0 ;
31465 void *argp2 = 0 ;
31466 int res2 = 0 ;
31467 PyObject * obj0 = 0 ;
31468 PyObject * obj1 = 0 ;
31469 char * kwnames[] = {
31470 (char *) "dest",(char *) "event", NULL
31471 };
31472
31473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31475 if (!SWIG_IsOK(res1)) {
31476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31477 }
31478 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31479 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31480 if (!SWIG_IsOK(res2)) {
31481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31482 }
31483 if (!argp2) {
31484 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31485 }
31486 arg2 = reinterpret_cast< wxEvent * >(argp2);
31487 {
31488 PyThreadState* __tstate = wxPyBeginAllowThreads();
31489 wxPostEvent(arg1,*arg2);
31490 wxPyEndAllowThreads(__tstate);
31491 if (PyErr_Occurred()) SWIG_fail;
31492 }
31493 resultobj = SWIG_Py_Void();
31494 return resultobj;
31495fail:
31496 return NULL;
d55e5bfc
RD
31497}
31498
31499
1bd55598
RD
31500SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31501 PyObject *resultobj = 0;
31502
31503 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31504 {
31505 PyThreadState* __tstate = wxPyBeginAllowThreads();
31506 wxApp_CleanUp();
31507 wxPyEndAllowThreads(__tstate);
31508 if (PyErr_Occurred()) SWIG_fail;
31509 }
31510 resultobj = SWIG_Py_Void();
31511 return resultobj;
31512fail:
31513 return NULL;
d55e5bfc
RD
31514}
31515
31516
1bd55598
RD
31517SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31518 PyObject *resultobj = 0;
31519 wxPyApp *result = 0 ;
31520
31521 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31522 {
31523 PyThreadState* __tstate = wxPyBeginAllowThreads();
31524 result = (wxPyApp *)wxPyGetApp();
31525 wxPyEndAllowThreads(__tstate);
31526 if (PyErr_Occurred()) SWIG_fail;
31527 }
31528 {
31529 resultobj = wxPyMake_wxObject(result, 0);
31530 }
31531 return resultobj;
31532fail:
31533 return NULL;
d55e5bfc
RD
31534}
31535
31536
1bd55598
RD
31537SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31538 PyObject *resultobj = 0;
31539 char *arg1 = (char *) 0 ;
31540 int res1 ;
31541 char *buf1 = 0 ;
31542 int alloc1 = 0 ;
31543 PyObject * obj0 = 0 ;
31544 char * kwnames[] = {
31545 (char *) "encoding", NULL
31546 };
31547
31548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31549 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31550 if (!SWIG_IsOK(res1)) {
31551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31552 }
31553 arg1 = buf1;
31554 {
31555 PyThreadState* __tstate = wxPyBeginAllowThreads();
31556 wxSetDefaultPyEncoding((char const *)arg1);
31557 wxPyEndAllowThreads(__tstate);
31558 if (PyErr_Occurred()) SWIG_fail;
31559 }
31560 resultobj = SWIG_Py_Void();
31561 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31562 return resultobj;
31563fail:
31564 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31565 return NULL;
d55e5bfc
RD
31566}
31567
31568
1bd55598
RD
31569SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31570 PyObject *resultobj = 0;
31571 char *result = 0 ;
31572
31573 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31574 {
31575 PyThreadState* __tstate = wxPyBeginAllowThreads();
31576 result = (char *)wxGetDefaultPyEncoding();
31577 wxPyEndAllowThreads(__tstate);
31578 if (PyErr_Occurred()) SWIG_fail;
31579 }
31580 resultobj = SWIG_FromCharPtr(result);
31581 return resultobj;
31582fail:
31583 return NULL;
d55e5bfc
RD
31584}
31585
31586
1bd55598
RD
31587SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31588 PyObject *resultobj = 0;
31589 wxEventLoop *result = 0 ;
31590
31591 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31592 {
31593 PyThreadState* __tstate = wxPyBeginAllowThreads();
31594 result = (wxEventLoop *)new wxEventLoop();
31595 wxPyEndAllowThreads(__tstate);
31596 if (PyErr_Occurred()) SWIG_fail;
31597 }
31598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31599 return resultobj;
31600fail:
31601 return NULL;
d55e5bfc
RD
31602}
31603
31604
1bd55598
RD
31605SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31606 PyObject *resultobj = 0;
31607 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31608 void *argp1 = 0 ;
31609 int res1 = 0 ;
31610 PyObject *swig_obj[1] ;
31611
31612 if (!args) SWIG_fail;
31613 swig_obj[0] = args;
31614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31615 if (!SWIG_IsOK(res1)) {
31616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31617 }
31618 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31619 {
31620 PyThreadState* __tstate = wxPyBeginAllowThreads();
31621 delete arg1;
d55e5bfc 31622
1bd55598
RD
31623 wxPyEndAllowThreads(__tstate);
31624 if (PyErr_Occurred()) SWIG_fail;
31625 }
31626 resultobj = SWIG_Py_Void();
31627 return resultobj;
31628fail:
31629 return NULL;
d55e5bfc
RD
31630}
31631
31632
1bd55598
RD
31633SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31634 PyObject *resultobj = 0;
31635 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31636 int result;
31637 void *argp1 = 0 ;
31638 int res1 = 0 ;
31639 PyObject *swig_obj[1] ;
31640
31641 if (!args) SWIG_fail;
31642 swig_obj[0] = args;
31643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31644 if (!SWIG_IsOK(res1)) {
31645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31646 }
31647 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31648 {
31649 PyThreadState* __tstate = wxPyBeginAllowThreads();
31650 result = (int)(arg1)->Run();
31651 wxPyEndAllowThreads(__tstate);
31652 if (PyErr_Occurred()) SWIG_fail;
31653 }
31654 resultobj = SWIG_From_int(static_cast< int >(result));
31655 return resultobj;
31656fail:
31657 return NULL;
31658}
31659
31660
31661SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31662 PyObject *resultobj = 0;
31663 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31664 int arg2 = (int) 0 ;
31665 void *argp1 = 0 ;
31666 int res1 = 0 ;
31667 int val2 ;
31668 int ecode2 = 0 ;
31669 PyObject * obj0 = 0 ;
31670 PyObject * obj1 = 0 ;
31671 char * kwnames[] = {
31672 (char *) "self",(char *) "rc", NULL
31673 };
31674
31675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31677 if (!SWIG_IsOK(res1)) {
31678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31679 }
31680 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31681 if (obj1) {
31682 ecode2 = SWIG_AsVal_int(obj1, &val2);
31683 if (!SWIG_IsOK(ecode2)) {
31684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31685 }
31686 arg2 = static_cast< int >(val2);
31687 }
31688 {
31689 PyThreadState* __tstate = wxPyBeginAllowThreads();
31690 (arg1)->Exit(arg2);
31691 wxPyEndAllowThreads(__tstate);
31692 if (PyErr_Occurred()) SWIG_fail;
31693 }
31694 resultobj = SWIG_Py_Void();
31695 return resultobj;
31696fail:
31697 return NULL;
d55e5bfc
RD
31698}
31699
31700
1bd55598
RD
31701SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31702 PyObject *resultobj = 0;
31703 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31704 bool result;
31705 void *argp1 = 0 ;
31706 int res1 = 0 ;
31707 PyObject *swig_obj[1] ;
31708
31709 if (!args) SWIG_fail;
31710 swig_obj[0] = args;
31711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31712 if (!SWIG_IsOK(res1)) {
31713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31714 }
31715 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31716 {
31717 PyThreadState* __tstate = wxPyBeginAllowThreads();
31718 result = (bool)((wxEventLoop const *)arg1)->Pending();
31719 wxPyEndAllowThreads(__tstate);
31720 if (PyErr_Occurred()) SWIG_fail;
31721 }
31722 {
31723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31724 }
31725 return resultobj;
31726fail:
31727 return NULL;
d55e5bfc
RD
31728}
31729
31730
1bd55598
RD
31731SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31732 PyObject *resultobj = 0;
31733 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31734 bool result;
31735 void *argp1 = 0 ;
31736 int res1 = 0 ;
31737 PyObject *swig_obj[1] ;
31738
31739 if (!args) SWIG_fail;
31740 swig_obj[0] = args;
31741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31742 if (!SWIG_IsOK(res1)) {
31743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31744 }
31745 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31746 {
31747 PyThreadState* __tstate = wxPyBeginAllowThreads();
31748 result = (bool)(arg1)->Dispatch();
31749 wxPyEndAllowThreads(__tstate);
31750 if (PyErr_Occurred()) SWIG_fail;
31751 }
31752 {
31753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31754 }
31755 return resultobj;
31756fail:
31757 return NULL;
d55e5bfc
RD
31758}
31759
31760
1bd55598
RD
31761SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31762 PyObject *resultobj = 0;
31763 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31764 bool result;
31765 void *argp1 = 0 ;
31766 int res1 = 0 ;
31767 PyObject *swig_obj[1] ;
31768
31769 if (!args) SWIG_fail;
31770 swig_obj[0] = args;
31771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31772 if (!SWIG_IsOK(res1)) {
31773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31774 }
31775 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31776 {
31777 PyThreadState* __tstate = wxPyBeginAllowThreads();
31778 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31779 wxPyEndAllowThreads(__tstate);
31780 if (PyErr_Occurred()) SWIG_fail;
31781 }
31782 {
31783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31784 }
31785 return resultobj;
31786fail:
31787 return NULL;
d55e5bfc
RD
31788}
31789
31790
1bd55598
RD
31791SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31792 PyObject *resultobj = 0;
31793 wxEventLoop *result = 0 ;
31794
31795 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31796 {
31797 PyThreadState* __tstate = wxPyBeginAllowThreads();
31798 result = (wxEventLoop *)wxEventLoop::GetActive();
31799 wxPyEndAllowThreads(__tstate);
31800 if (PyErr_Occurred()) SWIG_fail;
31801 }
31802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31803 return resultobj;
31804fail:
31805 return NULL;
d55e5bfc
RD
31806}
31807
31808
1bd55598
RD
31809SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31810 PyObject *resultobj = 0;
31811 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31812 void *argp1 = 0 ;
31813 int res1 = 0 ;
31814 PyObject * obj0 = 0 ;
31815 char * kwnames[] = {
31816 (char *) "loop", NULL
31817 };
31818
31819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31821 if (!SWIG_IsOK(res1)) {
31822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31823 }
31824 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31825 {
31826 PyThreadState* __tstate = wxPyBeginAllowThreads();
31827 wxEventLoop::SetActive(arg1);
31828 wxPyEndAllowThreads(__tstate);
31829 if (PyErr_Occurred()) SWIG_fail;
31830 }
31831 resultobj = SWIG_Py_Void();
31832 return resultobj;
31833fail:
31834 return NULL;
d55e5bfc
RD
31835}
31836
31837
1bd55598
RD
31838SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31839 PyObject *obj;
31840 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31841 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31842 return SWIG_Py_Void();
d55e5bfc
RD
31843}
31844
1bd55598
RD
31845SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31846 return SWIG_Python_InitShadowInstance(args);
31847}
d55e5bfc 31848
1bd55598
RD
31849SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31850 PyObject *resultobj = 0;
31851 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31852 wxEventLoopActivator *result = 0 ;
31853 void *argp1 = 0 ;
31854 int res1 = 0 ;
31855 PyObject * obj0 = 0 ;
31856 char * kwnames[] = {
31857 (char *) "evtLoop", NULL
31858 };
31859
31860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31862 if (!SWIG_IsOK(res1)) {
31863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31864 }
31865 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31866 {
31867 PyThreadState* __tstate = wxPyBeginAllowThreads();
31868 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31869 wxPyEndAllowThreads(__tstate);
31870 if (PyErr_Occurred()) SWIG_fail;
31871 }
31872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31873 return resultobj;
31874fail:
31875 return NULL;
d55e5bfc
RD
31876}
31877
31878
1bd55598
RD
31879SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31880 PyObject *resultobj = 0;
31881 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31882 void *argp1 = 0 ;
31883 int res1 = 0 ;
31884 PyObject *swig_obj[1] ;
31885
31886 if (!args) SWIG_fail;
31887 swig_obj[0] = args;
31888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31889 if (!SWIG_IsOK(res1)) {
31890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31891 }
31892 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31893 {
31894 PyThreadState* __tstate = wxPyBeginAllowThreads();
31895 delete arg1;
d55e5bfc 31896
1bd55598
RD
31897 wxPyEndAllowThreads(__tstate);
31898 if (PyErr_Occurred()) SWIG_fail;
31899 }
31900 resultobj = SWIG_Py_Void();
31901 return resultobj;
31902fail:
31903 return NULL;
31904}
31905
31906
31907SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31908 PyObject *obj;
31909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31910 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31911 return SWIG_Py_Void();
31912}
31913
31914SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31915 return SWIG_Python_InitShadowInstance(args);
31916}
31917
31918SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31919 PyObject *resultobj = 0;
31920 int arg1 = (int) 0 ;
31921 int arg2 = (int) 0 ;
31922 int arg3 = (int) 0 ;
31923 wxAcceleratorEntry *result = 0 ;
31924 int val1 ;
31925 int ecode1 = 0 ;
31926 int val2 ;
31927 int ecode2 = 0 ;
31928 int val3 ;
31929 int ecode3 = 0 ;
31930 PyObject * obj0 = 0 ;
31931 PyObject * obj1 = 0 ;
31932 PyObject * obj2 = 0 ;
31933 char * kwnames[] = {
31934 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
31935 };
31936
31937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31938 if (obj0) {
31939 ecode1 = SWIG_AsVal_int(obj0, &val1);
31940 if (!SWIG_IsOK(ecode1)) {
31941 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
31942 }
31943 arg1 = static_cast< int >(val1);
31944 }
31945 if (obj1) {
31946 ecode2 = SWIG_AsVal_int(obj1, &val2);
31947 if (!SWIG_IsOK(ecode2)) {
31948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
31949 }
31950 arg2 = static_cast< int >(val2);
31951 }
31952 if (obj2) {
31953 ecode3 = SWIG_AsVal_int(obj2, &val3);
31954 if (!SWIG_IsOK(ecode3)) {
31955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
31956 }
31957 arg3 = static_cast< int >(val3);
31958 }
31959 {
31960 PyThreadState* __tstate = wxPyBeginAllowThreads();
31961 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
31962 wxPyEndAllowThreads(__tstate);
31963 if (PyErr_Occurred()) SWIG_fail;
31964 }
31965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
31966 return resultobj;
31967fail:
31968 return NULL;
d55e5bfc
RD
31969}
31970
31971
1bd55598
RD
31972SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31973 PyObject *resultobj = 0;
31974 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31975 void *argp1 = 0 ;
31976 int res1 = 0 ;
31977 PyObject *swig_obj[1] ;
31978
31979 if (!args) SWIG_fail;
31980 swig_obj[0] = args;
31981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
31982 if (!SWIG_IsOK(res1)) {
31983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
31984 }
31985 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
31986 {
31987 PyThreadState* __tstate = wxPyBeginAllowThreads();
31988 delete arg1;
d55e5bfc 31989
1bd55598
RD
31990 wxPyEndAllowThreads(__tstate);
31991 if (PyErr_Occurred()) SWIG_fail;
31992 }
31993 resultobj = SWIG_Py_Void();
31994 return resultobj;
31995fail:
31996 return NULL;
31997}
31998
31999
32000SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32001 PyObject *resultobj = 0;
32002 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32003 int arg2 ;
32004 int arg3 ;
32005 int arg4 ;
32006 void *argp1 = 0 ;
32007 int res1 = 0 ;
32008 int val2 ;
32009 int ecode2 = 0 ;
32010 int val3 ;
32011 int ecode3 = 0 ;
32012 int val4 ;
32013 int ecode4 = 0 ;
32014 PyObject * obj0 = 0 ;
32015 PyObject * obj1 = 0 ;
32016 PyObject * obj2 = 0 ;
32017 PyObject * obj3 = 0 ;
32018 char * kwnames[] = {
32019 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32020 };
32021
32022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32024 if (!SWIG_IsOK(res1)) {
32025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32026 }
32027 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32028 ecode2 = SWIG_AsVal_int(obj1, &val2);
32029 if (!SWIG_IsOK(ecode2)) {
32030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32031 }
32032 arg2 = static_cast< int >(val2);
32033 ecode3 = SWIG_AsVal_int(obj2, &val3);
32034 if (!SWIG_IsOK(ecode3)) {
32035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32036 }
32037 arg3 = static_cast< int >(val3);
32038 ecode4 = SWIG_AsVal_int(obj3, &val4);
32039 if (!SWIG_IsOK(ecode4)) {
32040 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32041 }
32042 arg4 = static_cast< int >(val4);
32043 {
32044 PyThreadState* __tstate = wxPyBeginAllowThreads();
32045 (arg1)->Set(arg2,arg3,arg4);
32046 wxPyEndAllowThreads(__tstate);
32047 if (PyErr_Occurred()) SWIG_fail;
32048 }
32049 resultobj = SWIG_Py_Void();
32050 return resultobj;
32051fail:
32052 return NULL;
d55e5bfc
RD
32053}
32054
32055
ac5d357a
RD
32056SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32057 PyObject *resultobj = 0;
32058 wxString *arg1 = 0 ;
32059 wxAcceleratorEntry *result = 0 ;
32060 bool temp1 = false ;
32061 PyObject * obj0 = 0 ;
32062 char * kwnames[] = {
32063 (char *) "str", NULL
32064 };
32065
32066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32067 {
32068 arg1 = wxString_in_helper(obj0);
32069 if (arg1 == NULL) SWIG_fail;
32070 temp1 = true;
32071 }
32072 {
32073 PyThreadState* __tstate = wxPyBeginAllowThreads();
32074 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32075 wxPyEndAllowThreads(__tstate);
32076 if (PyErr_Occurred()) SWIG_fail;
32077 }
32078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32079 {
32080 if (temp1)
32081 delete arg1;
32082 }
32083 return resultobj;
32084fail:
32085 {
32086 if (temp1)
32087 delete arg1;
32088 }
32089 return NULL;
32090}
32091
32092
1bd55598
RD
32093SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32094 PyObject *resultobj = 0;
32095 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32096 int result;
32097 void *argp1 = 0 ;
32098 int res1 = 0 ;
32099 PyObject *swig_obj[1] ;
32100
32101 if (!args) SWIG_fail;
32102 swig_obj[0] = args;
32103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32104 if (!SWIG_IsOK(res1)) {
32105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32106 }
32107 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32108 {
32109 PyThreadState* __tstate = wxPyBeginAllowThreads();
32110 result = (int)(arg1)->GetFlags();
32111 wxPyEndAllowThreads(__tstate);
32112 if (PyErr_Occurred()) SWIG_fail;
32113 }
32114 resultobj = SWIG_From_int(static_cast< int >(result));
32115 return resultobj;
32116fail:
32117 return NULL;
d55e5bfc
RD
32118}
32119
32120
1bd55598
RD
32121SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32122 PyObject *resultobj = 0;
32123 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32124 int result;
32125 void *argp1 = 0 ;
32126 int res1 = 0 ;
32127 PyObject *swig_obj[1] ;
32128
32129 if (!args) SWIG_fail;
32130 swig_obj[0] = args;
32131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32132 if (!SWIG_IsOK(res1)) {
32133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32134 }
32135 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32136 {
32137 PyThreadState* __tstate = wxPyBeginAllowThreads();
32138 result = (int)(arg1)->GetKeyCode();
32139 wxPyEndAllowThreads(__tstate);
32140 if (PyErr_Occurred()) SWIG_fail;
32141 }
32142 resultobj = SWIG_From_int(static_cast< int >(result));
32143 return resultobj;
32144fail:
32145 return NULL;
d55e5bfc
RD
32146}
32147
32148
1bd55598
RD
32149SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32150 PyObject *resultobj = 0;
32151 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32152 int result;
32153 void *argp1 = 0 ;
32154 int res1 = 0 ;
32155 PyObject *swig_obj[1] ;
32156
32157 if (!args) SWIG_fail;
32158 swig_obj[0] = args;
32159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32160 if (!SWIG_IsOK(res1)) {
32161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32162 }
32163 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32164 {
32165 PyThreadState* __tstate = wxPyBeginAllowThreads();
32166 result = (int)(arg1)->GetCommand();
32167 wxPyEndAllowThreads(__tstate);
32168 if (PyErr_Occurred()) SWIG_fail;
32169 }
32170 resultobj = SWIG_From_int(static_cast< int >(result));
32171 return resultobj;
32172fail:
32173 return NULL;
d55e5bfc
RD
32174}
32175
32176
ac5d357a
RD
32177SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32178 PyObject *resultobj = 0;
32179 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32180 bool result;
32181 void *argp1 = 0 ;
32182 int res1 = 0 ;
32183 PyObject *swig_obj[1] ;
32184
32185 if (!args) SWIG_fail;
32186 swig_obj[0] = args;
32187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32188 if (!SWIG_IsOK(res1)) {
32189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32190 }
32191 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32192 {
32193 PyThreadState* __tstate = wxPyBeginAllowThreads();
32194 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32195 wxPyEndAllowThreads(__tstate);
32196 if (PyErr_Occurred()) SWIG_fail;
32197 }
32198 {
32199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32200 }
32201 return resultobj;
32202fail:
32203 return NULL;
32204}
32205
32206
32207SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32208 PyObject *resultobj = 0;
32209 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32210 wxString result;
32211 void *argp1 = 0 ;
32212 int res1 = 0 ;
32213 PyObject *swig_obj[1] ;
32214
32215 if (!args) SWIG_fail;
32216 swig_obj[0] = args;
32217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32218 if (!SWIG_IsOK(res1)) {
32219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32220 }
32221 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32222 {
32223 PyThreadState* __tstate = wxPyBeginAllowThreads();
32224 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32225 wxPyEndAllowThreads(__tstate);
32226 if (PyErr_Occurred()) SWIG_fail;
32227 }
32228 {
32229#if wxUSE_UNICODE
32230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32231#else
32232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32233#endif
32234 }
32235 return resultobj;
32236fail:
32237 return NULL;
32238}
32239
32240
32241SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32242 PyObject *resultobj = 0;
32243 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32244 wxString *arg2 = 0 ;
32245 bool result;
32246 void *argp1 = 0 ;
32247 int res1 = 0 ;
32248 bool temp2 = false ;
32249 PyObject * obj0 = 0 ;
32250 PyObject * obj1 = 0 ;
32251 char * kwnames[] = {
32252 (char *) "self",(char *) "str", NULL
32253 };
32254
32255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32257 if (!SWIG_IsOK(res1)) {
32258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32259 }
32260 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32261 {
32262 arg2 = wxString_in_helper(obj1);
32263 if (arg2 == NULL) SWIG_fail;
32264 temp2 = true;
32265 }
32266 {
32267 PyThreadState* __tstate = wxPyBeginAllowThreads();
32268 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32269 wxPyEndAllowThreads(__tstate);
32270 if (PyErr_Occurred()) SWIG_fail;
32271 }
32272 {
32273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32274 }
32275 {
32276 if (temp2)
32277 delete arg2;
32278 }
32279 return resultobj;
32280fail:
32281 {
32282 if (temp2)
32283 delete arg2;
32284 }
32285 return NULL;
32286}
32287
32288
1bd55598
RD
32289SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32290 PyObject *obj;
32291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32292 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32293 return SWIG_Py_Void();
d55e5bfc
RD
32294}
32295
1bd55598
RD
32296SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32297 return SWIG_Python_InitShadowInstance(args);
32298}
d55e5bfc 32299
1bd55598
RD
32300SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32301 PyObject *resultobj = 0;
32302 int arg1 ;
32303 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32304 wxAcceleratorTable *result = 0 ;
32305 PyObject * obj0 = 0 ;
32306 char * kwnames[] = {
32307 (char *) "n", NULL
32308 };
32309
32310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32311 {
32312 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32313 if (arg2) arg1 = PyList_Size(obj0);
32314 else arg1 = 0;
32315 }
32316 {
32317 PyThreadState* __tstate = wxPyBeginAllowThreads();
32318 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32319 wxPyEndAllowThreads(__tstate);
32320 if (PyErr_Occurred()) SWIG_fail;
32321 }
32322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32323 return resultobj;
32324fail:
32325 return NULL;
d55e5bfc
RD
32326}
32327
32328
1bd55598
RD
32329SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32330 PyObject *resultobj = 0;
32331 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32332 void *argp1 = 0 ;
32333 int res1 = 0 ;
32334 PyObject *swig_obj[1] ;
32335
32336 if (!args) SWIG_fail;
32337 swig_obj[0] = args;
32338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32339 if (!SWIG_IsOK(res1)) {
32340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32341 }
32342 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32343 {
32344 PyThreadState* __tstate = wxPyBeginAllowThreads();
32345 delete arg1;
d55e5bfc 32346
1bd55598
RD
32347 wxPyEndAllowThreads(__tstate);
32348 if (PyErr_Occurred()) SWIG_fail;
32349 }
32350 resultobj = SWIG_Py_Void();
32351 return resultobj;
32352fail:
32353 return NULL;
d55e5bfc
RD
32354}
32355
32356
b39fe951 32357SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1bd55598
RD
32358 PyObject *resultobj = 0;
32359 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32360 bool result;
32361 void *argp1 = 0 ;
32362 int res1 = 0 ;
32363 PyObject *swig_obj[1] ;
32364
32365 if (!args) SWIG_fail;
32366 swig_obj[0] = args;
32367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32368 if (!SWIG_IsOK(res1)) {
b39fe951 32369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
1bd55598
RD
32370 }
32371 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32372 {
32373 PyThreadState* __tstate = wxPyBeginAllowThreads();
b39fe951 32374 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
1bd55598
RD
32375 wxPyEndAllowThreads(__tstate);
32376 if (PyErr_Occurred()) SWIG_fail;
32377 }
32378 {
32379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32380 }
32381 return resultobj;
32382fail:
32383 return NULL;
d55e5bfc
RD
32384}
32385
32386
1bd55598
RD
32387SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32388 PyObject *obj;
32389 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32390 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32391 return SWIG_Py_Void();
d55e5bfc
RD
32392}
32393
1bd55598
RD
32394SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32395 return SWIG_Python_InitShadowInstance(args);
32396}
d55e5bfc 32397
1bd55598
RD
32398SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32399 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32400 return 1;
d55e5bfc
RD
32401}
32402
32403
1bd55598
RD
32404SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32405 PyObject *pyobj = 0;
32406
32407 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32408 return pyobj;
d55e5bfc
RD
32409}
32410
32411
1bd55598
RD
32412SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32413 PyObject *resultobj = 0;
32414 wxString *arg1 = 0 ;
32415 wxAcceleratorEntry *result = 0 ;
32416 bool temp1 = false ;
32417 PyObject * obj0 = 0 ;
32418 char * kwnames[] = {
32419 (char *) "label", NULL
32420 };
32421
32422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32423 {
32424 arg1 = wxString_in_helper(obj0);
32425 if (arg1 == NULL) SWIG_fail;
32426 temp1 = true;
32427 }
32428 {
32429 PyThreadState* __tstate = wxPyBeginAllowThreads();
32430 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32431 wxPyEndAllowThreads(__tstate);
32432 if (PyErr_Occurred()) SWIG_fail;
32433 }
32434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32435 {
32436 if (temp1)
32437 delete arg1;
32438 }
32439 return resultobj;
32440fail:
32441 {
32442 if (temp1)
32443 delete arg1;
32444 }
32445 return NULL;
d55e5bfc
RD
32446}
32447
32448
1bd55598
RD
32449SWIGINTERN int PanelNameStr_set(PyObject *) {
32450 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32451 return 1;
d55e5bfc
RD
32452}
32453
32454
1bd55598
RD
32455SWIGINTERN PyObject *PanelNameStr_get(void) {
32456 PyObject *pyobj = 0;
32457
32458 {
32459#if wxUSE_UNICODE
32460 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32461#else
32462 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32463#endif
32464 }
32465 return pyobj;
d55e5bfc
RD
32466}
32467
32468
1bd55598
RD
32469SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32470 PyObject *resultobj = 0;
32471 wxVisualAttributes *result = 0 ;
32472
32473 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32474 {
32475 PyThreadState* __tstate = wxPyBeginAllowThreads();
32476 result = (wxVisualAttributes *)new_wxVisualAttributes();
32477 wxPyEndAllowThreads(__tstate);
32478 if (PyErr_Occurred()) SWIG_fail;
32479 }
32480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32481 return resultobj;
32482fail:
32483 return NULL;
d55e5bfc
RD
32484}
32485
32486
1bd55598
RD
32487SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32488 PyObject *resultobj = 0;
32489 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32490 void *argp1 = 0 ;
32491 int res1 = 0 ;
32492 PyObject *swig_obj[1] ;
32493
32494 if (!args) SWIG_fail;
32495 swig_obj[0] = args;
32496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32497 if (!SWIG_IsOK(res1)) {
32498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32499 }
32500 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32501 {
32502 PyThreadState* __tstate = wxPyBeginAllowThreads();
32503 delete_wxVisualAttributes(arg1);
d55e5bfc 32504
1bd55598
RD
32505 wxPyEndAllowThreads(__tstate);
32506 if (PyErr_Occurred()) SWIG_fail;
32507 }
32508 resultobj = SWIG_Py_Void();
32509 return resultobj;
32510fail:
32511 return NULL;
32512}
32513
32514
32515SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32516 PyObject *resultobj = 0;
32517 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32518 wxFont *arg2 = (wxFont *) 0 ;
32519 void *argp1 = 0 ;
32520 int res1 = 0 ;
32521 void *argp2 = 0 ;
32522 int res2 = 0 ;
32523 PyObject *swig_obj[2] ;
32524
32525 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32527 if (!SWIG_IsOK(res1)) {
32528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32529 }
32530 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32531 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32532 if (!SWIG_IsOK(res2)) {
32533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32534 }
32535 arg2 = reinterpret_cast< wxFont * >(argp2);
32536 if (arg1) (arg1)->font = *arg2;
32537
32538 resultobj = SWIG_Py_Void();
32539 return resultobj;
32540fail:
32541 return NULL;
d55e5bfc
RD
32542}
32543
32544
1bd55598
RD
32545SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32546 PyObject *resultobj = 0;
32547 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32548 wxFont *result = 0 ;
32549 void *argp1 = 0 ;
32550 int res1 = 0 ;
32551 PyObject *swig_obj[1] ;
32552
32553 if (!args) SWIG_fail;
32554 swig_obj[0] = args;
32555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32556 if (!SWIG_IsOK(res1)) {
32557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32558 }
32559 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32560 result = (wxFont *)& ((arg1)->font);
32561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32562 return resultobj;
32563fail:
32564 return NULL;
32565}
32566
32567
32568SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32569 PyObject *resultobj = 0;
32570 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32571 wxColour *arg2 = (wxColour *) 0 ;
32572 void *argp1 = 0 ;
32573 int res1 = 0 ;
32574 void *argp2 = 0 ;
32575 int res2 = 0 ;
32576 PyObject *swig_obj[2] ;
32577
32578 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32580 if (!SWIG_IsOK(res1)) {
32581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32582 }
32583 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32584 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32585 if (!SWIG_IsOK(res2)) {
32586 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32587 }
32588 arg2 = reinterpret_cast< wxColour * >(argp2);
32589 if (arg1) (arg1)->colFg = *arg2;
32590
32591 resultobj = SWIG_Py_Void();
32592 return resultobj;
32593fail:
32594 return NULL;
d55e5bfc
RD
32595}
32596
32597
1bd55598
RD
32598SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32599 PyObject *resultobj = 0;
32600 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32601 wxColour *result = 0 ;
32602 void *argp1 = 0 ;
32603 int res1 = 0 ;
32604 PyObject *swig_obj[1] ;
32605
32606 if (!args) SWIG_fail;
32607 swig_obj[0] = args;
32608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32609 if (!SWIG_IsOK(res1)) {
32610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32611 }
32612 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32613 result = (wxColour *)& ((arg1)->colFg);
32614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32615 return resultobj;
32616fail:
32617 return NULL;
32618}
32619
32620
32621SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32622 PyObject *resultobj = 0;
32623 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32624 wxColour *arg2 = (wxColour *) 0 ;
32625 void *argp1 = 0 ;
32626 int res1 = 0 ;
32627 void *argp2 = 0 ;
32628 int res2 = 0 ;
32629 PyObject *swig_obj[2] ;
32630
32631 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32633 if (!SWIG_IsOK(res1)) {
32634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32635 }
32636 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32637 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32638 if (!SWIG_IsOK(res2)) {
32639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32640 }
32641 arg2 = reinterpret_cast< wxColour * >(argp2);
32642 if (arg1) (arg1)->colBg = *arg2;
32643
32644 resultobj = SWIG_Py_Void();
32645 return resultobj;
32646fail:
32647 return NULL;
d55e5bfc
RD
32648}
32649
32650
1bd55598
RD
32651SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32652 PyObject *resultobj = 0;
32653 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32654 wxColour *result = 0 ;
32655 void *argp1 = 0 ;
32656 int res1 = 0 ;
32657 PyObject *swig_obj[1] ;
32658
32659 if (!args) SWIG_fail;
32660 swig_obj[0] = args;
32661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32662 if (!SWIG_IsOK(res1)) {
32663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32664 }
32665 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32666 result = (wxColour *)& ((arg1)->colBg);
32667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32668 return resultobj;
32669fail:
32670 return NULL;
32671}
32672
32673
32674SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32675 PyObject *obj;
32676 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32677 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32678 return SWIG_Py_Void();
32679}
32680
32681SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32682 return SWIG_Python_InitShadowInstance(args);
32683}
32684
32685SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32686 PyObject *resultobj = 0;
32687 wxWindow *arg1 = (wxWindow *) 0 ;
32688 int arg2 = (int) (int)-1 ;
32689 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32690 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32691 wxSize const &arg4_defvalue = wxDefaultSize ;
32692 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32693 long arg5 = (long) 0 ;
32694 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32695 wxString *arg6 = (wxString *) &arg6_defvalue ;
32696 wxWindow *result = 0 ;
32697 void *argp1 = 0 ;
32698 int res1 = 0 ;
32699 int val2 ;
32700 int ecode2 = 0 ;
32701 wxPoint temp3 ;
32702 wxSize temp4 ;
32703 long val5 ;
32704 int ecode5 = 0 ;
32705 bool temp6 = false ;
32706 PyObject * obj0 = 0 ;
32707 PyObject * obj1 = 0 ;
32708 PyObject * obj2 = 0 ;
32709 PyObject * obj3 = 0 ;
32710 PyObject * obj4 = 0 ;
32711 PyObject * obj5 = 0 ;
32712 char * kwnames[] = {
32713 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32714 };
32715
32716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32718 if (!SWIG_IsOK(res1)) {
32719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32720 }
32721 arg1 = reinterpret_cast< wxWindow * >(argp1);
32722 if (obj1) {
32723 ecode2 = SWIG_AsVal_int(obj1, &val2);
32724 if (!SWIG_IsOK(ecode2)) {
32725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32726 }
32727 arg2 = static_cast< int >(val2);
32728 }
32729 if (obj2) {
d55e5bfc 32730 {
1bd55598
RD
32731 arg3 = &temp3;
32732 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
d55e5bfc 32733 }
1bd55598
RD
32734 }
32735 if (obj3) {
d55e5bfc 32736 {
1bd55598
RD
32737 arg4 = &temp4;
32738 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
d55e5bfc 32739 }
1bd55598
RD
32740 }
32741 if (obj4) {
32742 ecode5 = SWIG_AsVal_long(obj4, &val5);
32743 if (!SWIG_IsOK(ecode5)) {
32744 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32745 }
32746 arg5 = static_cast< long >(val5);
32747 }
32748 if (obj5) {
d55e5bfc 32749 {
1bd55598
RD
32750 arg6 = wxString_in_helper(obj5);
32751 if (arg6 == NULL) SWIG_fail;
32752 temp6 = true;
d55e5bfc 32753 }
1bd55598
RD
32754 }
32755 {
32756 if (!wxPyCheckForApp()) SWIG_fail;
32757 PyThreadState* __tstate = wxPyBeginAllowThreads();
32758 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32759 wxPyEndAllowThreads(__tstate);
32760 if (PyErr_Occurred()) SWIG_fail;
32761 }
32762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32763 {
32764 if (temp6)
32765 delete arg6;
32766 }
32767 return resultobj;
32768fail:
32769 {
32770 if (temp6)
32771 delete arg6;
32772 }
32773 return NULL;
d55e5bfc
RD
32774}
32775
32776
1bd55598
RD
32777SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32778 PyObject *resultobj = 0;
32779 wxWindow *result = 0 ;
32780
32781 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32782 {
32783 if (!wxPyCheckForApp()) SWIG_fail;
32784 PyThreadState* __tstate = wxPyBeginAllowThreads();
32785 result = (wxWindow *)new wxWindow();
32786 wxPyEndAllowThreads(__tstate);
32787 if (PyErr_Occurred()) SWIG_fail;
32788 }
32789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32790 return resultobj;
32791fail:
32792 return NULL;
32793}
32794
32795
32796SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32797 PyObject *resultobj = 0;
32798 wxWindow *arg1 = (wxWindow *) 0 ;
32799 wxWindow *arg2 = (wxWindow *) 0 ;
32800 int arg3 = (int) (int)-1 ;
32801 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32802 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32803 wxSize const &arg5_defvalue = wxDefaultSize ;
32804 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32805 long arg6 = (long) 0 ;
32806 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32807 wxString *arg7 = (wxString *) &arg7_defvalue ;
32808 bool result;
32809 void *argp1 = 0 ;
32810 int res1 = 0 ;
32811 void *argp2 = 0 ;
32812 int res2 = 0 ;
32813 int val3 ;
32814 int ecode3 = 0 ;
32815 wxPoint temp4 ;
32816 wxSize temp5 ;
32817 long val6 ;
32818 int ecode6 = 0 ;
32819 bool temp7 = false ;
32820 PyObject * obj0 = 0 ;
32821 PyObject * obj1 = 0 ;
32822 PyObject * obj2 = 0 ;
32823 PyObject * obj3 = 0 ;
32824 PyObject * obj4 = 0 ;
32825 PyObject * obj5 = 0 ;
32826 PyObject * obj6 = 0 ;
32827 char * kwnames[] = {
32828 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32829 };
32830
32831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32833 if (!SWIG_IsOK(res1)) {
32834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32835 }
32836 arg1 = reinterpret_cast< wxWindow * >(argp1);
32837 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32838 if (!SWIG_IsOK(res2)) {
32839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32840 }
32841 arg2 = reinterpret_cast< wxWindow * >(argp2);
32842 if (obj2) {
32843 ecode3 = SWIG_AsVal_int(obj2, &val3);
32844 if (!SWIG_IsOK(ecode3)) {
32845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32846 }
32847 arg3 = static_cast< int >(val3);
32848 }
32849 if (obj3) {
d55e5bfc 32850 {
1bd55598
RD
32851 arg4 = &temp4;
32852 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
d55e5bfc 32853 }
1bd55598
RD
32854 }
32855 if (obj4) {
d55e5bfc 32856 {
1bd55598
RD
32857 arg5 = &temp5;
32858 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
d55e5bfc 32859 }
1bd55598
RD
32860 }
32861 if (obj5) {
32862 ecode6 = SWIG_AsVal_long(obj5, &val6);
32863 if (!SWIG_IsOK(ecode6)) {
32864 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32865 }
32866 arg6 = static_cast< long >(val6);
32867 }
32868 if (obj6) {
d55e5bfc 32869 {
1bd55598
RD
32870 arg7 = wxString_in_helper(obj6);
32871 if (arg7 == NULL) SWIG_fail;
32872 temp7 = true;
d55e5bfc 32873 }
1bd55598
RD
32874 }
32875 {
32876 PyThreadState* __tstate = wxPyBeginAllowThreads();
32877 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32878 wxPyEndAllowThreads(__tstate);
32879 if (PyErr_Occurred()) SWIG_fail;
32880 }
32881 {
32882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32883 }
32884 {
32885 if (temp7)
32886 delete arg7;
32887 }
32888 return resultobj;
32889fail:
32890 {
32891 if (temp7)
32892 delete arg7;
32893 }
32894 return NULL;
32895}
32896
32897
32898SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32899 PyObject *resultobj = 0;
32900 wxWindow *arg1 = (wxWindow *) 0 ;
32901 bool arg2 = (bool) false ;
32902 bool result;
32903 void *argp1 = 0 ;
32904 int res1 = 0 ;
32905 bool val2 ;
32906 int ecode2 = 0 ;
32907 PyObject * obj0 = 0 ;
32908 PyObject * obj1 = 0 ;
32909 char * kwnames[] = {
32910 (char *) "self",(char *) "force", NULL
32911 };
32912
32913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
32914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32915 if (!SWIG_IsOK(res1)) {
32916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
32917 }
32918 arg1 = reinterpret_cast< wxWindow * >(argp1);
32919 if (obj1) {
32920 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32921 if (!SWIG_IsOK(ecode2)) {
32922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
32923 }
32924 arg2 = static_cast< bool >(val2);
32925 }
32926 {
32927 PyThreadState* __tstate = wxPyBeginAllowThreads();
32928 result = (bool)(arg1)->Close(arg2);
32929 wxPyEndAllowThreads(__tstate);
32930 if (PyErr_Occurred()) SWIG_fail;
32931 }
32932 {
32933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32934 }
32935 return resultobj;
32936fail:
32937 return NULL;
d55e5bfc
RD
32938}
32939
32940
1bd55598
RD
32941SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32942 PyObject *resultobj = 0;
32943 wxWindow *arg1 = (wxWindow *) 0 ;
32944 bool result;
32945 void *argp1 = 0 ;
32946 int res1 = 0 ;
32947 PyObject *swig_obj[1] ;
32948
32949 if (!args) SWIG_fail;
32950 swig_obj[0] = args;
32951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32952 if (!SWIG_IsOK(res1)) {
32953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
32954 }
32955 arg1 = reinterpret_cast< wxWindow * >(argp1);
32956 {
32957 PyThreadState* __tstate = wxPyBeginAllowThreads();
32958 result = (bool)(arg1)->Destroy();
32959 wxPyEndAllowThreads(__tstate);
32960 if (PyErr_Occurred()) SWIG_fail;
32961 }
32962 {
32963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32964 }
32965 return resultobj;
32966fail:
32967 return NULL;
d55e5bfc
RD
32968}
32969
32970
1bd55598
RD
32971SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32972 PyObject *resultobj = 0;
32973 wxWindow *arg1 = (wxWindow *) 0 ;
32974 bool result;
32975 void *argp1 = 0 ;
32976 int res1 = 0 ;
32977 PyObject *swig_obj[1] ;
32978
32979 if (!args) SWIG_fail;
32980 swig_obj[0] = args;
32981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32982 if (!SWIG_IsOK(res1)) {
32983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32984 }
32985 arg1 = reinterpret_cast< wxWindow * >(argp1);
32986 {
32987 PyThreadState* __tstate = wxPyBeginAllowThreads();
32988 result = (bool)(arg1)->DestroyChildren();
32989 wxPyEndAllowThreads(__tstate);
32990 if (PyErr_Occurred()) SWIG_fail;
32991 }
32992 {
32993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32994 }
32995 return resultobj;
32996fail:
32997 return NULL;
d55e5bfc
RD
32998}
32999
33000
1bd55598
RD
33001SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33002 PyObject *resultobj = 0;
33003 wxWindow *arg1 = (wxWindow *) 0 ;
33004 bool result;
33005 void *argp1 = 0 ;
33006 int res1 = 0 ;
33007 PyObject *swig_obj[1] ;
33008
33009 if (!args) SWIG_fail;
33010 swig_obj[0] = args;
33011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33012 if (!SWIG_IsOK(res1)) {
33013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33014 }
33015 arg1 = reinterpret_cast< wxWindow * >(argp1);
33016 {
33017 PyThreadState* __tstate = wxPyBeginAllowThreads();
33018 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33019 wxPyEndAllowThreads(__tstate);
33020 if (PyErr_Occurred()) SWIG_fail;
33021 }
33022 {
33023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33024 }
33025 return resultobj;
33026fail:
33027 return NULL;
33028}
33029
33030
33031SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33032 PyObject *resultobj = 0;
33033 wxWindow *arg1 = (wxWindow *) 0 ;
33034 wxString *arg2 = 0 ;
33035 void *argp1 = 0 ;
33036 int res1 = 0 ;
33037 bool temp2 = false ;
33038 PyObject * obj0 = 0 ;
33039 PyObject * obj1 = 0 ;
33040 char * kwnames[] = {
33041 (char *) "self",(char *) "label", NULL
33042 };
33043
33044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33046 if (!SWIG_IsOK(res1)) {
33047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33048 }
33049 arg1 = reinterpret_cast< wxWindow * >(argp1);
33050 {
33051 arg2 = wxString_in_helper(obj1);
33052 if (arg2 == NULL) SWIG_fail;
33053 temp2 = true;
33054 }
33055 {
33056 PyThreadState* __tstate = wxPyBeginAllowThreads();
33057 (arg1)->SetLabel((wxString const &)*arg2);
33058 wxPyEndAllowThreads(__tstate);
33059 if (PyErr_Occurred()) SWIG_fail;
33060 }
33061 resultobj = SWIG_Py_Void();
33062 {
33063 if (temp2)
33064 delete arg2;
33065 }
33066 return resultobj;
33067fail:
33068 {
33069 if (temp2)
33070 delete arg2;
33071 }
33072 return NULL;
d55e5bfc
RD
33073}
33074
33075
1bd55598
RD
33076SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33077 PyObject *resultobj = 0;
33078 wxWindow *arg1 = (wxWindow *) 0 ;
33079 wxString result;
33080 void *argp1 = 0 ;
33081 int res1 = 0 ;
33082 PyObject *swig_obj[1] ;
33083
33084 if (!args) SWIG_fail;
33085 swig_obj[0] = args;
33086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33087 if (!SWIG_IsOK(res1)) {
33088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33089 }
33090 arg1 = reinterpret_cast< wxWindow * >(argp1);
33091 {
33092 PyThreadState* __tstate = wxPyBeginAllowThreads();
33093 result = ((wxWindow const *)arg1)->GetLabel();
33094 wxPyEndAllowThreads(__tstate);
33095 if (PyErr_Occurred()) SWIG_fail;
33096 }
33097 {
33098#if wxUSE_UNICODE
33099 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33100#else
33101 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33102#endif
33103 }
33104 return resultobj;
33105fail:
33106 return NULL;
33107}
33108
33109
33110SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33111 PyObject *resultobj = 0;
33112 wxWindow *arg1 = (wxWindow *) 0 ;
33113 wxString *arg2 = 0 ;
33114 void *argp1 = 0 ;
33115 int res1 = 0 ;
33116 bool temp2 = false ;
33117 PyObject * obj0 = 0 ;
33118 PyObject * obj1 = 0 ;
33119 char * kwnames[] = {
33120 (char *) "self",(char *) "name", NULL
33121 };
33122
33123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33125 if (!SWIG_IsOK(res1)) {
33126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33127 }
33128 arg1 = reinterpret_cast< wxWindow * >(argp1);
33129 {
33130 arg2 = wxString_in_helper(obj1);
33131 if (arg2 == NULL) SWIG_fail;
33132 temp2 = true;
33133 }
33134 {
33135 PyThreadState* __tstate = wxPyBeginAllowThreads();
33136 (arg1)->SetName((wxString const &)*arg2);
33137 wxPyEndAllowThreads(__tstate);
33138 if (PyErr_Occurred()) SWIG_fail;
33139 }
33140 resultobj = SWIG_Py_Void();
33141 {
33142 if (temp2)
33143 delete arg2;
33144 }
33145 return resultobj;
33146fail:
33147 {
33148 if (temp2)
33149 delete arg2;
33150 }
33151 return NULL;
d55e5bfc
RD
33152}
33153
33154
1bd55598
RD
33155SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33156 PyObject *resultobj = 0;
33157 wxWindow *arg1 = (wxWindow *) 0 ;
33158 wxString result;
33159 void *argp1 = 0 ;
33160 int res1 = 0 ;
33161 PyObject *swig_obj[1] ;
33162
33163 if (!args) SWIG_fail;
33164 swig_obj[0] = args;
33165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33166 if (!SWIG_IsOK(res1)) {
33167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33168 }
33169 arg1 = reinterpret_cast< wxWindow * >(argp1);
33170 {
33171 PyThreadState* __tstate = wxPyBeginAllowThreads();
33172 result = ((wxWindow const *)arg1)->GetName();
33173 wxPyEndAllowThreads(__tstate);
33174 if (PyErr_Occurred()) SWIG_fail;
33175 }
33176 {
33177#if wxUSE_UNICODE
33178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33179#else
33180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33181#endif
33182 }
33183 return resultobj;
33184fail:
33185 return NULL;
33186}
33187
33188
33189SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33190 PyObject *resultobj = 0;
33191 wxWindow *arg1 = (wxWindow *) 0 ;
33192 wxWindowVariant arg2 ;
33193 void *argp1 = 0 ;
33194 int res1 = 0 ;
33195 int val2 ;
33196 int ecode2 = 0 ;
33197 PyObject * obj0 = 0 ;
33198 PyObject * obj1 = 0 ;
33199 char * kwnames[] = {
33200 (char *) "self",(char *) "variant", NULL
33201 };
33202
33203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33205 if (!SWIG_IsOK(res1)) {
33206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33207 }
33208 arg1 = reinterpret_cast< wxWindow * >(argp1);
33209 ecode2 = SWIG_AsVal_int(obj1, &val2);
33210 if (!SWIG_IsOK(ecode2)) {
33211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33212 }
33213 arg2 = static_cast< wxWindowVariant >(val2);
33214 {
33215 PyThreadState* __tstate = wxPyBeginAllowThreads();
33216 (arg1)->SetWindowVariant(arg2);
33217 wxPyEndAllowThreads(__tstate);
33218 if (PyErr_Occurred()) SWIG_fail;
33219 }
33220 resultobj = SWIG_Py_Void();
33221 return resultobj;
33222fail:
33223 return NULL;
d55e5bfc
RD
33224}
33225
33226
1bd55598
RD
33227SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33228 PyObject *resultobj = 0;
33229 wxWindow *arg1 = (wxWindow *) 0 ;
33230 wxWindowVariant result;
33231 void *argp1 = 0 ;
33232 int res1 = 0 ;
33233 PyObject *swig_obj[1] ;
33234
33235 if (!args) SWIG_fail;
33236 swig_obj[0] = args;
33237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33238 if (!SWIG_IsOK(res1)) {
33239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33240 }
33241 arg1 = reinterpret_cast< wxWindow * >(argp1);
33242 {
33243 PyThreadState* __tstate = wxPyBeginAllowThreads();
33244 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33245 wxPyEndAllowThreads(__tstate);
33246 if (PyErr_Occurred()) SWIG_fail;
33247 }
33248 resultobj = SWIG_From_int(static_cast< int >(result));
33249 return resultobj;
33250fail:
33251 return NULL;
33252}
33253
33254
33255SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33256 PyObject *resultobj = 0;
33257 wxWindow *arg1 = (wxWindow *) 0 ;
33258 int arg2 ;
33259 void *argp1 = 0 ;
33260 int res1 = 0 ;
33261 int val2 ;
33262 int ecode2 = 0 ;
33263 PyObject * obj0 = 0 ;
33264 PyObject * obj1 = 0 ;
33265 char * kwnames[] = {
33266 (char *) "self",(char *) "winid", NULL
33267 };
33268
33269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33271 if (!SWIG_IsOK(res1)) {
33272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33273 }
33274 arg1 = reinterpret_cast< wxWindow * >(argp1);
33275 ecode2 = SWIG_AsVal_int(obj1, &val2);
33276 if (!SWIG_IsOK(ecode2)) {
33277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33278 }
33279 arg2 = static_cast< int >(val2);
33280 {
33281 PyThreadState* __tstate = wxPyBeginAllowThreads();
33282 (arg1)->SetId(arg2);
33283 wxPyEndAllowThreads(__tstate);
33284 if (PyErr_Occurred()) SWIG_fail;
33285 }
33286 resultobj = SWIG_Py_Void();
33287 return resultobj;
33288fail:
33289 return NULL;
d55e5bfc
RD
33290}
33291
33292
1bd55598
RD
33293SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33294 PyObject *resultobj = 0;
33295 wxWindow *arg1 = (wxWindow *) 0 ;
33296 int result;
33297 void *argp1 = 0 ;
33298 int res1 = 0 ;
33299 PyObject *swig_obj[1] ;
33300
33301 if (!args) SWIG_fail;
33302 swig_obj[0] = args;
33303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33304 if (!SWIG_IsOK(res1)) {
33305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33306 }
33307 arg1 = reinterpret_cast< wxWindow * >(argp1);
33308 {
33309 PyThreadState* __tstate = wxPyBeginAllowThreads();
33310 result = (int)((wxWindow const *)arg1)->GetId();
33311 wxPyEndAllowThreads(__tstate);
33312 if (PyErr_Occurred()) SWIG_fail;
33313 }
33314 resultobj = SWIG_From_int(static_cast< int >(result));
33315 return resultobj;
33316fail:
33317 return NULL;
d55e5bfc
RD
33318}
33319
33320
1bd55598
RD
33321SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33322 PyObject *resultobj = 0;
33323 int result;
33324
33325 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33326 {
33327 PyThreadState* __tstate = wxPyBeginAllowThreads();
33328 result = (int)wxWindow::NewControlId();
33329 wxPyEndAllowThreads(__tstate);
33330 if (PyErr_Occurred()) SWIG_fail;
33331 }
33332 resultobj = SWIG_From_int(static_cast< int >(result));
33333 return resultobj;
33334fail:
33335 return NULL;
33336}
33337
33338
33339SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33340 PyObject *resultobj = 0;
33341 int arg1 ;
33342 int result;
33343 int val1 ;
33344 int ecode1 = 0 ;
33345 PyObject * obj0 = 0 ;
33346 char * kwnames[] = {
33347 (char *) "winid", NULL
33348 };
33349
33350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33351 ecode1 = SWIG_AsVal_int(obj0, &val1);
33352 if (!SWIG_IsOK(ecode1)) {
33353 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33354 }
33355 arg1 = static_cast< int >(val1);
33356 {
33357 PyThreadState* __tstate = wxPyBeginAllowThreads();
33358 result = (int)wxWindow::NextControlId(arg1);
33359 wxPyEndAllowThreads(__tstate);
33360 if (PyErr_Occurred()) SWIG_fail;
33361 }
33362 resultobj = SWIG_From_int(static_cast< int >(result));
33363 return resultobj;
33364fail:
33365 return NULL;
33366}
33367
33368
33369SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33370 PyObject *resultobj = 0;
33371 int arg1 ;
33372 int result;
33373 int val1 ;
33374 int ecode1 = 0 ;
33375 PyObject * obj0 = 0 ;
33376 char * kwnames[] = {
33377 (char *) "winid", NULL
33378 };
33379
33380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33381 ecode1 = SWIG_AsVal_int(obj0, &val1);
33382 if (!SWIG_IsOK(ecode1)) {
33383 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33384 }
33385 arg1 = static_cast< int >(val1);
33386 {
33387 PyThreadState* __tstate = wxPyBeginAllowThreads();
33388 result = (int)wxWindow::PrevControlId(arg1);
33389 wxPyEndAllowThreads(__tstate);
33390 if (PyErr_Occurred()) SWIG_fail;
33391 }
33392 resultobj = SWIG_From_int(static_cast< int >(result));
33393 return resultobj;
33394fail:
33395 return NULL;
33396}
33397
33398
ac5d357a
RD
33399SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33400 PyObject *resultobj = 0;
33401 wxWindow *arg1 = (wxWindow *) 0 ;
33402 wxLayoutDirection result;
33403 void *argp1 = 0 ;
33404 int res1 = 0 ;
33405 PyObject *swig_obj[1] ;
33406
33407 if (!args) SWIG_fail;
33408 swig_obj[0] = args;
33409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33410 if (!SWIG_IsOK(res1)) {
33411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33412 }
33413 arg1 = reinterpret_cast< wxWindow * >(argp1);
33414 {
33415 PyThreadState* __tstate = wxPyBeginAllowThreads();
994453b8 33416 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
ac5d357a
RD
33417 wxPyEndAllowThreads(__tstate);
33418 if (PyErr_Occurred()) SWIG_fail;
33419 }
994453b8 33420 resultobj = SWIG_From_int(static_cast< int >(result));
ac5d357a
RD
33421 return resultobj;
33422fail:
33423 return NULL;
33424}
33425
33426
33427SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33428 PyObject *resultobj = 0;
33429 wxWindow *arg1 = (wxWindow *) 0 ;
33430 wxLayoutDirection arg2 ;
33431 void *argp1 = 0 ;
33432 int res1 = 0 ;
994453b8
RD
33433 int val2 ;
33434 int ecode2 = 0 ;
ac5d357a
RD
33435 PyObject * obj0 = 0 ;
33436 PyObject * obj1 = 0 ;
33437 char * kwnames[] = {
33438 (char *) "self",(char *) "dir", NULL
33439 };
33440
33441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33443 if (!SWIG_IsOK(res1)) {
33444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33445 }
33446 arg1 = reinterpret_cast< wxWindow * >(argp1);
994453b8
RD
33447 ecode2 = SWIG_AsVal_int(obj1, &val2);
33448 if (!SWIG_IsOK(ecode2)) {
33449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33450 }
33451 arg2 = static_cast< wxLayoutDirection >(val2);
ac5d357a
RD
33452 {
33453 PyThreadState* __tstate = wxPyBeginAllowThreads();
33454 (arg1)->SetLayoutDirection(arg2);
33455 wxPyEndAllowThreads(__tstate);
33456 if (PyErr_Occurred()) SWIG_fail;
33457 }
33458 resultobj = SWIG_Py_Void();
33459 return resultobj;
33460fail:
33461 return NULL;
33462}
33463
33464
33465SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33466 PyObject *resultobj = 0;
33467 wxWindow *arg1 = (wxWindow *) 0 ;
33468 int arg2 ;
33469 int arg3 ;
33470 int arg4 ;
33471 int result;
33472 void *argp1 = 0 ;
33473 int res1 = 0 ;
33474 int val2 ;
33475 int ecode2 = 0 ;
33476 int val3 ;
33477 int ecode3 = 0 ;
33478 int val4 ;
33479 int ecode4 = 0 ;
33480 PyObject * obj0 = 0 ;
33481 PyObject * obj1 = 0 ;
33482 PyObject * obj2 = 0 ;
33483 PyObject * obj3 = 0 ;
33484 char * kwnames[] = {
33485 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33486 };
33487
33488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33490 if (!SWIG_IsOK(res1)) {
33491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33492 }
33493 arg1 = reinterpret_cast< wxWindow * >(argp1);
33494 ecode2 = SWIG_AsVal_int(obj1, &val2);
33495 if (!SWIG_IsOK(ecode2)) {
33496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33497 }
33498 arg2 = static_cast< int >(val2);
33499 ecode3 = SWIG_AsVal_int(obj2, &val3);
33500 if (!SWIG_IsOK(ecode3)) {
33501 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33502 }
33503 arg3 = static_cast< int >(val3);
33504 ecode4 = SWIG_AsVal_int(obj3, &val4);
33505 if (!SWIG_IsOK(ecode4)) {
33506 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33507 }
33508 arg4 = static_cast< int >(val4);
33509 {
33510 PyThreadState* __tstate = wxPyBeginAllowThreads();
33511 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33512 wxPyEndAllowThreads(__tstate);
33513 if (PyErr_Occurred()) SWIG_fail;
33514 }
33515 resultobj = SWIG_From_int(static_cast< int >(result));
33516 return resultobj;
33517fail:
33518 return NULL;
33519}
33520
33521
1bd55598
RD
33522SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33523 PyObject *resultobj = 0;
33524 wxWindow *arg1 = (wxWindow *) 0 ;
33525 wxSize *arg2 = 0 ;
33526 void *argp1 = 0 ;
33527 int res1 = 0 ;
33528 wxSize temp2 ;
33529 PyObject * obj0 = 0 ;
33530 PyObject * obj1 = 0 ;
33531 char * kwnames[] = {
33532 (char *) "self",(char *) "size", NULL
33533 };
33534
33535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",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_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33539 }
33540 arg1 = reinterpret_cast< wxWindow * >(argp1);
33541 {
33542 arg2 = &temp2;
33543 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33544 }
33545 {
33546 PyThreadState* __tstate = wxPyBeginAllowThreads();
33547 (arg1)->SetSize((wxSize const &)*arg2);
33548 wxPyEndAllowThreads(__tstate);
33549 if (PyErr_Occurred()) SWIG_fail;
33550 }
33551 resultobj = SWIG_Py_Void();
33552 return resultobj;
33553fail:
33554 return NULL;
33555}
33556
33557
33558SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33559 PyObject *resultobj = 0;
33560 wxWindow *arg1 = (wxWindow *) 0 ;
33561 int arg2 ;
33562 int arg3 ;
33563 int arg4 ;
33564 int arg5 ;
33565 int arg6 = (int) wxSIZE_AUTO ;
33566 void *argp1 = 0 ;
33567 int res1 = 0 ;
33568 int val2 ;
33569 int ecode2 = 0 ;
33570 int val3 ;
33571 int ecode3 = 0 ;
33572 int val4 ;
33573 int ecode4 = 0 ;
33574 int val5 ;
33575 int ecode5 = 0 ;
33576 int val6 ;
33577 int ecode6 = 0 ;
33578 PyObject * obj0 = 0 ;
33579 PyObject * obj1 = 0 ;
33580 PyObject * obj2 = 0 ;
33581 PyObject * obj3 = 0 ;
33582 PyObject * obj4 = 0 ;
33583 PyObject * obj5 = 0 ;
33584 char * kwnames[] = {
33585 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33586 };
33587
33588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33590 if (!SWIG_IsOK(res1)) {
33591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33592 }
33593 arg1 = reinterpret_cast< wxWindow * >(argp1);
33594 ecode2 = SWIG_AsVal_int(obj1, &val2);
33595 if (!SWIG_IsOK(ecode2)) {
33596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33597 }
33598 arg2 = static_cast< int >(val2);
33599 ecode3 = SWIG_AsVal_int(obj2, &val3);
33600 if (!SWIG_IsOK(ecode3)) {
33601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33602 }
33603 arg3 = static_cast< int >(val3);
33604 ecode4 = SWIG_AsVal_int(obj3, &val4);
33605 if (!SWIG_IsOK(ecode4)) {
33606 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33607 }
33608 arg4 = static_cast< int >(val4);
33609 ecode5 = SWIG_AsVal_int(obj4, &val5);
33610 if (!SWIG_IsOK(ecode5)) {
33611 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33612 }
33613 arg5 = static_cast< int >(val5);
33614 if (obj5) {
33615 ecode6 = SWIG_AsVal_int(obj5, &val6);
33616 if (!SWIG_IsOK(ecode6)) {
33617 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33618 }
33619 arg6 = static_cast< int >(val6);
33620 }
33621 {
33622 PyThreadState* __tstate = wxPyBeginAllowThreads();
33623 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33624 wxPyEndAllowThreads(__tstate);
33625 if (PyErr_Occurred()) SWIG_fail;
33626 }
33627 resultobj = SWIG_Py_Void();
33628 return resultobj;
33629fail:
33630 return NULL;
33631}
33632
33633
33634SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33635 PyObject *resultobj = 0;
33636 wxWindow *arg1 = (wxWindow *) 0 ;
33637 wxRect *arg2 = 0 ;
33638 int arg3 = (int) wxSIZE_AUTO ;
33639 void *argp1 = 0 ;
33640 int res1 = 0 ;
33641 wxRect temp2 ;
33642 int val3 ;
33643 int ecode3 = 0 ;
33644 PyObject * obj0 = 0 ;
33645 PyObject * obj1 = 0 ;
33646 PyObject * obj2 = 0 ;
33647 char * kwnames[] = {
33648 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33649 };
33650
33651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33653 if (!SWIG_IsOK(res1)) {
33654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33655 }
33656 arg1 = reinterpret_cast< wxWindow * >(argp1);
33657 {
33658 arg2 = &temp2;
33659 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33660 }
33661 if (obj2) {
33662 ecode3 = SWIG_AsVal_int(obj2, &val3);
33663 if (!SWIG_IsOK(ecode3)) {
33664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33665 }
33666 arg3 = static_cast< int >(val3);
33667 }
33668 {
33669 PyThreadState* __tstate = wxPyBeginAllowThreads();
33670 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33671 wxPyEndAllowThreads(__tstate);
33672 if (PyErr_Occurred()) SWIG_fail;
33673 }
33674 resultobj = SWIG_Py_Void();
33675 return resultobj;
33676fail:
33677 return NULL;
33678}
33679
33680
33681SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33682 PyObject *resultobj = 0;
33683 wxWindow *arg1 = (wxWindow *) 0 ;
33684 int arg2 ;
33685 int arg3 ;
33686 void *argp1 = 0 ;
33687 int res1 = 0 ;
33688 int val2 ;
33689 int ecode2 = 0 ;
33690 int val3 ;
33691 int ecode3 = 0 ;
33692 PyObject * obj0 = 0 ;
33693 PyObject * obj1 = 0 ;
33694 PyObject * obj2 = 0 ;
33695 char * kwnames[] = {
33696 (char *) "self",(char *) "width",(char *) "height", NULL
33697 };
33698
33699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33701 if (!SWIG_IsOK(res1)) {
33702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33703 }
33704 arg1 = reinterpret_cast< wxWindow * >(argp1);
33705 ecode2 = SWIG_AsVal_int(obj1, &val2);
33706 if (!SWIG_IsOK(ecode2)) {
33707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33708 }
33709 arg2 = static_cast< int >(val2);
33710 ecode3 = SWIG_AsVal_int(obj2, &val3);
33711 if (!SWIG_IsOK(ecode3)) {
33712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33713 }
33714 arg3 = static_cast< int >(val3);
33715 {
33716 PyThreadState* __tstate = wxPyBeginAllowThreads();
33717 (arg1)->SetSize(arg2,arg3);
33718 wxPyEndAllowThreads(__tstate);
33719 if (PyErr_Occurred()) SWIG_fail;
33720 }
33721 resultobj = SWIG_Py_Void();
33722 return resultobj;
33723fail:
33724 return NULL;
33725}
33726
33727
33728SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33729 PyObject *resultobj = 0;
33730 wxWindow *arg1 = (wxWindow *) 0 ;
33731 wxPoint *arg2 = 0 ;
33732 int arg3 = (int) wxSIZE_USE_EXISTING ;
33733 void *argp1 = 0 ;
33734 int res1 = 0 ;
33735 wxPoint temp2 ;
33736 int val3 ;
33737 int ecode3 = 0 ;
33738 PyObject * obj0 = 0 ;
33739 PyObject * obj1 = 0 ;
33740 PyObject * obj2 = 0 ;
33741 char * kwnames[] = {
33742 (char *) "self",(char *) "pt",(char *) "flags", NULL
33743 };
33744
33745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33747 if (!SWIG_IsOK(res1)) {
33748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33749 }
33750 arg1 = reinterpret_cast< wxWindow * >(argp1);
33751 {
33752 arg2 = &temp2;
33753 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33754 }
33755 if (obj2) {
33756 ecode3 = SWIG_AsVal_int(obj2, &val3);
33757 if (!SWIG_IsOK(ecode3)) {
33758 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33759 }
33760 arg3 = static_cast< int >(val3);
33761 }
33762 {
33763 PyThreadState* __tstate = wxPyBeginAllowThreads();
33764 (arg1)->Move((wxPoint const &)*arg2,arg3);
33765 wxPyEndAllowThreads(__tstate);
33766 if (PyErr_Occurred()) SWIG_fail;
33767 }
33768 resultobj = SWIG_Py_Void();
33769 return resultobj;
33770fail:
33771 return NULL;
33772}
33773
33774
33775SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33776 PyObject *resultobj = 0;
33777 wxWindow *arg1 = (wxWindow *) 0 ;
33778 int arg2 ;
33779 int arg3 ;
33780 int arg4 = (int) wxSIZE_USE_EXISTING ;
33781 void *argp1 = 0 ;
33782 int res1 = 0 ;
33783 int val2 ;
33784 int ecode2 = 0 ;
33785 int val3 ;
33786 int ecode3 = 0 ;
33787 int val4 ;
33788 int ecode4 = 0 ;
33789 PyObject * obj0 = 0 ;
33790 PyObject * obj1 = 0 ;
33791 PyObject * obj2 = 0 ;
33792 PyObject * obj3 = 0 ;
33793 char * kwnames[] = {
33794 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33795 };
33796
33797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33799 if (!SWIG_IsOK(res1)) {
33800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33801 }
33802 arg1 = reinterpret_cast< wxWindow * >(argp1);
33803 ecode2 = SWIG_AsVal_int(obj1, &val2);
33804 if (!SWIG_IsOK(ecode2)) {
33805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33806 }
33807 arg2 = static_cast< int >(val2);
33808 ecode3 = SWIG_AsVal_int(obj2, &val3);
33809 if (!SWIG_IsOK(ecode3)) {
33810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33811 }
33812 arg3 = static_cast< int >(val3);
33813 if (obj3) {
33814 ecode4 = SWIG_AsVal_int(obj3, &val4);
33815 if (!SWIG_IsOK(ecode4)) {
33816 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33817 }
33818 arg4 = static_cast< int >(val4);
33819 }
33820 {
33821 PyThreadState* __tstate = wxPyBeginAllowThreads();
33822 (arg1)->Move(arg2,arg3,arg4);
33823 wxPyEndAllowThreads(__tstate);
33824 if (PyErr_Occurred()) SWIG_fail;
33825 }
33826 resultobj = SWIG_Py_Void();
33827 return resultobj;
33828fail:
33829 return NULL;
33830}
33831
33832
580080c5 33833SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
1bd55598
RD
33834 PyObject *resultobj = 0;
33835 wxWindow *arg1 = (wxWindow *) 0 ;
33836 wxSize const &arg2_defvalue = wxDefaultSize ;
33837 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33838 void *argp1 = 0 ;
33839 int res1 = 0 ;
33840 wxSize temp2 ;
33841 PyObject * obj0 = 0 ;
33842 PyObject * obj1 = 0 ;
33843 char * kwnames[] = {
33844 (char *) "self",(char *) "size", NULL
33845 };
33846
580080c5 33847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
1bd55598
RD
33848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33849 if (!SWIG_IsOK(res1)) {
580080c5 33850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
1bd55598
RD
33851 }
33852 arg1 = reinterpret_cast< wxWindow * >(argp1);
33853 if (obj1) {
d55e5bfc 33854 {
1bd55598
RD
33855 arg2 = &temp2;
33856 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
d55e5bfc 33857 }
1bd55598
RD
33858 }
33859 {
33860 PyThreadState* __tstate = wxPyBeginAllowThreads();
580080c5 33861 (arg1)->SetInitialSize((wxSize const &)*arg2);
1bd55598
RD
33862 wxPyEndAllowThreads(__tstate);
33863 if (PyErr_Occurred()) SWIG_fail;
33864 }
33865 resultobj = SWIG_Py_Void();
33866 return resultobj;
33867fail:
33868 return NULL;
d55e5bfc
RD
33869}
33870
33871
1bd55598
RD
33872SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33873 PyObject *resultobj = 0;
33874 wxWindow *arg1 = (wxWindow *) 0 ;
33875 void *argp1 = 0 ;
33876 int res1 = 0 ;
33877 PyObject *swig_obj[1] ;
33878
33879 if (!args) SWIG_fail;
33880 swig_obj[0] = args;
33881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33882 if (!SWIG_IsOK(res1)) {
33883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33884 }
33885 arg1 = reinterpret_cast< wxWindow * >(argp1);
33886 {
33887 PyThreadState* __tstate = wxPyBeginAllowThreads();
33888 (arg1)->Raise();
33889 wxPyEndAllowThreads(__tstate);
33890 if (PyErr_Occurred()) SWIG_fail;
33891 }
33892 resultobj = SWIG_Py_Void();
33893 return resultobj;
33894fail:
33895 return NULL;
d55e5bfc
RD
33896}
33897
33898
1bd55598
RD
33899SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33900 PyObject *resultobj = 0;
33901 wxWindow *arg1 = (wxWindow *) 0 ;
33902 void *argp1 = 0 ;
33903 int res1 = 0 ;
33904 PyObject *swig_obj[1] ;
33905
33906 if (!args) SWIG_fail;
33907 swig_obj[0] = args;
33908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33909 if (!SWIG_IsOK(res1)) {
33910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33911 }
33912 arg1 = reinterpret_cast< wxWindow * >(argp1);
33913 {
33914 PyThreadState* __tstate = wxPyBeginAllowThreads();
33915 (arg1)->Lower();
33916 wxPyEndAllowThreads(__tstate);
33917 if (PyErr_Occurred()) SWIG_fail;
33918 }
33919 resultobj = SWIG_Py_Void();
33920 return resultobj;
33921fail:
33922 return NULL;
33923}
33924
33925
33926SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33927 PyObject *resultobj = 0;
33928 wxWindow *arg1 = (wxWindow *) 0 ;
33929 wxSize *arg2 = 0 ;
33930 void *argp1 = 0 ;
33931 int res1 = 0 ;
33932 wxSize temp2 ;
33933 PyObject * obj0 = 0 ;
33934 PyObject * obj1 = 0 ;
33935 char * kwnames[] = {
33936 (char *) "self",(char *) "size", NULL
33937 };
33938
33939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
33940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33941 if (!SWIG_IsOK(res1)) {
33942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33943 }
33944 arg1 = reinterpret_cast< wxWindow * >(argp1);
33945 {
33946 arg2 = &temp2;
33947 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33948 }
33949 {
33950 PyThreadState* __tstate = wxPyBeginAllowThreads();
33951 (arg1)->SetClientSize((wxSize const &)*arg2);
33952 wxPyEndAllowThreads(__tstate);
33953 if (PyErr_Occurred()) SWIG_fail;
33954 }
33955 resultobj = SWIG_Py_Void();
33956 return resultobj;
33957fail:
33958 return NULL;
33959}
33960
33961
33962SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33963 PyObject *resultobj = 0;
33964 wxWindow *arg1 = (wxWindow *) 0 ;
33965 int arg2 ;
33966 int arg3 ;
33967 void *argp1 = 0 ;
33968 int res1 = 0 ;
33969 int val2 ;
33970 int ecode2 = 0 ;
33971 int val3 ;
33972 int ecode3 = 0 ;
33973 PyObject * obj0 = 0 ;
33974 PyObject * obj1 = 0 ;
33975 PyObject * obj2 = 0 ;
33976 char * kwnames[] = {
33977 (char *) "self",(char *) "width",(char *) "height", NULL
33978 };
33979
33980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33982 if (!SWIG_IsOK(res1)) {
33983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33984 }
33985 arg1 = reinterpret_cast< wxWindow * >(argp1);
33986 ecode2 = SWIG_AsVal_int(obj1, &val2);
33987 if (!SWIG_IsOK(ecode2)) {
33988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
33989 }
33990 arg2 = static_cast< int >(val2);
33991 ecode3 = SWIG_AsVal_int(obj2, &val3);
33992 if (!SWIG_IsOK(ecode3)) {
33993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
33994 }
33995 arg3 = static_cast< int >(val3);
33996 {
33997 PyThreadState* __tstate = wxPyBeginAllowThreads();
33998 (arg1)->SetClientSize(arg2,arg3);
33999 wxPyEndAllowThreads(__tstate);
34000 if (PyErr_Occurred()) SWIG_fail;
34001 }
34002 resultobj = SWIG_Py_Void();
34003 return resultobj;
34004fail:
34005 return NULL;
34006}
34007
34008
34009SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34010 PyObject *resultobj = 0;
34011 wxWindow *arg1 = (wxWindow *) 0 ;
34012 wxRect *arg2 = 0 ;
34013 void *argp1 = 0 ;
34014 int res1 = 0 ;
34015 wxRect temp2 ;
34016 PyObject * obj0 = 0 ;
34017 PyObject * obj1 = 0 ;
34018 char * kwnames[] = {
34019 (char *) "self",(char *) "rect", NULL
34020 };
34021
34022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34024 if (!SWIG_IsOK(res1)) {
34025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34026 }
34027 arg1 = reinterpret_cast< wxWindow * >(argp1);
34028 {
34029 arg2 = &temp2;
34030 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34031 }
34032 {
34033 PyThreadState* __tstate = wxPyBeginAllowThreads();
34034 (arg1)->SetClientSize((wxRect const &)*arg2);
34035 wxPyEndAllowThreads(__tstate);
34036 if (PyErr_Occurred()) SWIG_fail;
34037 }
34038 resultobj = SWIG_Py_Void();
34039 return resultobj;
34040fail:
34041 return NULL;
d55e5bfc
RD
34042}
34043
34044
1bd55598
RD
34045SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34046 PyObject *resultobj = 0;
34047 wxWindow *arg1 = (wxWindow *) 0 ;
34048 wxPoint result;
34049 void *argp1 = 0 ;
34050 int res1 = 0 ;
34051 PyObject *swig_obj[1] ;
34052
34053 if (!args) SWIG_fail;
34054 swig_obj[0] = args;
34055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34056 if (!SWIG_IsOK(res1)) {
1c71765a 34057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
1bd55598
RD
34058 }
34059 arg1 = reinterpret_cast< wxWindow * >(argp1);
34060 {
34061 PyThreadState* __tstate = wxPyBeginAllowThreads();
1c71765a 34062 result = ((wxWindow const *)arg1)->GetPosition();
1bd55598
RD
34063 wxPyEndAllowThreads(__tstate);
34064 if (PyErr_Occurred()) SWIG_fail;
34065 }
34066 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34067 return resultobj;
34068fail:
34069 return NULL;
34070}
34071
34072
34073SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34074 PyObject *resultobj = 0;
34075 wxWindow *arg1 = (wxWindow *) 0 ;
34076 int *arg2 = (int *) 0 ;
34077 int *arg3 = (int *) 0 ;
34078 void *argp1 = 0 ;
34079 int res1 = 0 ;
34080 int temp2 ;
34081 int res2 = SWIG_TMPOBJ ;
34082 int temp3 ;
34083 int res3 = SWIG_TMPOBJ ;
34084 PyObject *swig_obj[1] ;
34085
34086 arg2 = &temp2;
34087 arg3 = &temp3;
34088 if (!args) SWIG_fail;
34089 swig_obj[0] = args;
34090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34091 if (!SWIG_IsOK(res1)) {
1c71765a 34092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
1bd55598
RD
34093 }
34094 arg1 = reinterpret_cast< wxWindow * >(argp1);
34095 {
34096 PyThreadState* __tstate = wxPyBeginAllowThreads();
1c71765a
RD
34097 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34098 wxPyEndAllowThreads(__tstate);
34099 if (PyErr_Occurred()) SWIG_fail;
34100 }
34101 resultobj = SWIG_Py_Void();
34102 if (SWIG_IsTmpObj(res2)) {
34103 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34104 } else {
34105 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34106 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34107 }
34108 if (SWIG_IsTmpObj(res3)) {
34109 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34110 } else {
34111 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34112 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34113 }
34114 return resultobj;
34115fail:
34116 return NULL;
34117}
34118
34119
34120SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34121 PyObject *resultobj = 0;
34122 wxWindow *arg1 = (wxWindow *) 0 ;
34123 wxPoint result;
34124 void *argp1 = 0 ;
34125 int res1 = 0 ;
34126 PyObject *swig_obj[1] ;
34127
34128 if (!args) SWIG_fail;
34129 swig_obj[0] = args;
34130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34131 if (!SWIG_IsOK(res1)) {
34132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34133 }
34134 arg1 = reinterpret_cast< wxWindow * >(argp1);
34135 {
34136 PyThreadState* __tstate = wxPyBeginAllowThreads();
34137 result = ((wxWindow const *)arg1)->GetScreenPosition();
34138 wxPyEndAllowThreads(__tstate);
34139 if (PyErr_Occurred()) SWIG_fail;
34140 }
34141 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34142 return resultobj;
34143fail:
34144 return NULL;
34145}
34146
34147
34148SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34149 PyObject *resultobj = 0;
34150 wxWindow *arg1 = (wxWindow *) 0 ;
34151 int *arg2 = (int *) 0 ;
34152 int *arg3 = (int *) 0 ;
34153 void *argp1 = 0 ;
34154 int res1 = 0 ;
34155 int temp2 ;
34156 int res2 = SWIG_TMPOBJ ;
34157 int temp3 ;
34158 int res3 = SWIG_TMPOBJ ;
34159 PyObject *swig_obj[1] ;
34160
34161 arg2 = &temp2;
34162 arg3 = &temp3;
34163 if (!args) SWIG_fail;
34164 swig_obj[0] = args;
34165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34166 if (!SWIG_IsOK(res1)) {
34167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34168 }
34169 arg1 = reinterpret_cast< wxWindow * >(argp1);
34170 {
34171 PyThreadState* __tstate = wxPyBeginAllowThreads();
34172 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
1bd55598
RD
34173 wxPyEndAllowThreads(__tstate);
34174 if (PyErr_Occurred()) SWIG_fail;
34175 }
34176 resultobj = SWIG_Py_Void();
34177 if (SWIG_IsTmpObj(res2)) {
34178 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34179 } else {
34180 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34181 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34182 }
34183 if (SWIG_IsTmpObj(res3)) {
34184 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34185 } else {
34186 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34187 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34188 }
34189 return resultobj;
34190fail:
34191 return NULL;
d55e5bfc
RD
34192}
34193
34194
1c71765a
RD
34195SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34196 PyObject *resultobj = 0;
34197 wxWindow *arg1 = (wxWindow *) 0 ;
34198 wxRect result;
34199 void *argp1 = 0 ;
34200 int res1 = 0 ;
34201 PyObject *swig_obj[1] ;
34202
34203 if (!args) SWIG_fail;
34204 swig_obj[0] = args;
34205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34206 if (!SWIG_IsOK(res1)) {
34207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34208 }
34209 arg1 = reinterpret_cast< wxWindow * >(argp1);
34210 {
34211 PyThreadState* __tstate = wxPyBeginAllowThreads();
34212 result = ((wxWindow const *)arg1)->GetScreenRect();
34213 wxPyEndAllowThreads(__tstate);
34214 if (PyErr_Occurred()) SWIG_fail;
34215 }
34216 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34217 return resultobj;
34218fail:
34219 return NULL;
34220}
34221
34222
1bd55598
RD
34223SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34224 PyObject *resultobj = 0;
34225 wxWindow *arg1 = (wxWindow *) 0 ;
34226 wxSize result;
34227 void *argp1 = 0 ;
34228 int res1 = 0 ;
34229 PyObject *swig_obj[1] ;
34230
34231 if (!args) SWIG_fail;
34232 swig_obj[0] = args;
34233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34234 if (!SWIG_IsOK(res1)) {
34235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34236 }
34237 arg1 = reinterpret_cast< wxWindow * >(argp1);
34238 {
34239 PyThreadState* __tstate = wxPyBeginAllowThreads();
34240 result = ((wxWindow const *)arg1)->GetSize();
34241 wxPyEndAllowThreads(__tstate);
34242 if (PyErr_Occurred()) SWIG_fail;
34243 }
34244 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34245 return resultobj;
34246fail:
34247 return NULL;
34248}
34249
34250
34251SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34252 PyObject *resultobj = 0;
34253 wxWindow *arg1 = (wxWindow *) 0 ;
34254 int *arg2 = (int *) 0 ;
34255 int *arg3 = (int *) 0 ;
34256 void *argp1 = 0 ;
34257 int res1 = 0 ;
34258 int temp2 ;
34259 int res2 = SWIG_TMPOBJ ;
34260 int temp3 ;
34261 int res3 = SWIG_TMPOBJ ;
34262 PyObject *swig_obj[1] ;
34263
34264 arg2 = &temp2;
34265 arg3 = &temp3;
34266 if (!args) SWIG_fail;
34267 swig_obj[0] = args;
34268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34269 if (!SWIG_IsOK(res1)) {
34270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34271 }
34272 arg1 = reinterpret_cast< wxWindow * >(argp1);
34273 {
34274 PyThreadState* __tstate = wxPyBeginAllowThreads();
34275 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34276 wxPyEndAllowThreads(__tstate);
34277 if (PyErr_Occurred()) SWIG_fail;
34278 }
34279 resultobj = SWIG_Py_Void();
34280 if (SWIG_IsTmpObj(res2)) {
34281 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34282 } else {
34283 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34284 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34285 }
34286 if (SWIG_IsTmpObj(res3)) {
34287 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34288 } else {
34289 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34290 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34291 }
34292 return resultobj;
34293fail:
34294 return NULL;
d55e5bfc
RD
34295}
34296
34297
1bd55598
RD
34298SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34299 PyObject *resultobj = 0;
34300 wxWindow *arg1 = (wxWindow *) 0 ;
34301 wxRect result;
34302 void *argp1 = 0 ;
34303 int res1 = 0 ;
34304 PyObject *swig_obj[1] ;
34305
34306 if (!args) SWIG_fail;
34307 swig_obj[0] = args;
34308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34309 if (!SWIG_IsOK(res1)) {
34310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34311 }
34312 arg1 = reinterpret_cast< wxWindow * >(argp1);
34313 {
34314 PyThreadState* __tstate = wxPyBeginAllowThreads();
34315 result = ((wxWindow const *)arg1)->GetRect();
34316 wxPyEndAllowThreads(__tstate);
34317 if (PyErr_Occurred()) SWIG_fail;
34318 }
34319 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34320 return resultobj;
34321fail:
34322 return NULL;
d55e5bfc
RD
34323}
34324
34325
1bd55598
RD
34326SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34327 PyObject *resultobj = 0;
34328 wxWindow *arg1 = (wxWindow *) 0 ;
34329 wxSize result;
34330 void *argp1 = 0 ;
34331 int res1 = 0 ;
34332 PyObject *swig_obj[1] ;
34333
34334 if (!args) SWIG_fail;
34335 swig_obj[0] = args;
34336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34337 if (!SWIG_IsOK(res1)) {
34338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34339 }
34340 arg1 = reinterpret_cast< wxWindow * >(argp1);
34341 {
34342 PyThreadState* __tstate = wxPyBeginAllowThreads();
34343 result = ((wxWindow const *)arg1)->GetClientSize();
34344 wxPyEndAllowThreads(__tstate);
34345 if (PyErr_Occurred()) SWIG_fail;
34346 }
34347 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34348 return resultobj;
34349fail:
34350 return NULL;
34351}
34352
34353
34354SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34355 PyObject *resultobj = 0;
34356 wxWindow *arg1 = (wxWindow *) 0 ;
34357 int *arg2 = (int *) 0 ;
34358 int *arg3 = (int *) 0 ;
34359 void *argp1 = 0 ;
34360 int res1 = 0 ;
34361 int temp2 ;
34362 int res2 = SWIG_TMPOBJ ;
34363 int temp3 ;
34364 int res3 = SWIG_TMPOBJ ;
34365 PyObject *swig_obj[1] ;
34366
34367 arg2 = &temp2;
34368 arg3 = &temp3;
34369 if (!args) SWIG_fail;
34370 swig_obj[0] = args;
34371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34372 if (!SWIG_IsOK(res1)) {
34373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34374 }
34375 arg1 = reinterpret_cast< wxWindow * >(argp1);
34376 {
34377 PyThreadState* __tstate = wxPyBeginAllowThreads();
34378 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34379 wxPyEndAllowThreads(__tstate);
34380 if (PyErr_Occurred()) SWIG_fail;
34381 }
34382 resultobj = SWIG_Py_Void();
34383 if (SWIG_IsTmpObj(res2)) {
34384 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34385 } else {
34386 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34387 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34388 }
34389 if (SWIG_IsTmpObj(res3)) {
34390 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34391 } else {
34392 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34393 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34394 }
34395 return resultobj;
34396fail:
34397 return NULL;
d55e5bfc
RD
34398}
34399
34400
1bd55598
RD
34401SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34402 PyObject *resultobj = 0;
34403 wxWindow *arg1 = (wxWindow *) 0 ;
34404 wxPoint result;
34405 void *argp1 = 0 ;
34406 int res1 = 0 ;
34407 PyObject *swig_obj[1] ;
34408
34409 if (!args) SWIG_fail;
34410 swig_obj[0] = args;
34411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34412 if (!SWIG_IsOK(res1)) {
34413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34414 }
34415 arg1 = reinterpret_cast< wxWindow * >(argp1);
34416 {
34417 PyThreadState* __tstate = wxPyBeginAllowThreads();
34418 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34419 wxPyEndAllowThreads(__tstate);
34420 if (PyErr_Occurred()) SWIG_fail;
34421 }
34422 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34423 return resultobj;
34424fail:
34425 return NULL;
d55e5bfc
RD
34426}
34427
34428
1bd55598
RD
34429SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34430 PyObject *resultobj = 0;
34431 wxWindow *arg1 = (wxWindow *) 0 ;
34432 wxRect result;
34433 void *argp1 = 0 ;
34434 int res1 = 0 ;
34435 PyObject *swig_obj[1] ;
34436
34437 if (!args) SWIG_fail;
34438 swig_obj[0] = args;
34439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34440 if (!SWIG_IsOK(res1)) {
34441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34442 }
34443 arg1 = reinterpret_cast< wxWindow * >(argp1);
34444 {
34445 PyThreadState* __tstate = wxPyBeginAllowThreads();
34446 result = ((wxWindow const *)arg1)->GetClientRect();
34447 wxPyEndAllowThreads(__tstate);
34448 if (PyErr_Occurred()) SWIG_fail;
34449 }
34450 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34451 return resultobj;
34452fail:
34453 return NULL;
d55e5bfc
RD
34454}
34455
34456
1bd55598
RD
34457SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34458 PyObject *resultobj = 0;
34459 wxWindow *arg1 = (wxWindow *) 0 ;
34460 wxSize result;
34461 void *argp1 = 0 ;
34462 int res1 = 0 ;
34463 PyObject *swig_obj[1] ;
34464
34465 if (!args) SWIG_fail;
34466 swig_obj[0] = args;
34467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34468 if (!SWIG_IsOK(res1)) {
34469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34470 }
34471 arg1 = reinterpret_cast< wxWindow * >(argp1);
34472 {
34473 PyThreadState* __tstate = wxPyBeginAllowThreads();
34474 result = ((wxWindow const *)arg1)->GetBestSize();
34475 wxPyEndAllowThreads(__tstate);
34476 if (PyErr_Occurred()) SWIG_fail;
34477 }
34478 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34479 return resultobj;
34480fail:
34481 return NULL;
34482}
34483
34484
34485SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34486 PyObject *resultobj = 0;
34487 wxWindow *arg1 = (wxWindow *) 0 ;
34488 int *arg2 = (int *) 0 ;
34489 int *arg3 = (int *) 0 ;
34490 void *argp1 = 0 ;
34491 int res1 = 0 ;
34492 int temp2 ;
34493 int res2 = SWIG_TMPOBJ ;
34494 int temp3 ;
34495 int res3 = SWIG_TMPOBJ ;
34496 PyObject *swig_obj[1] ;
34497
34498 arg2 = &temp2;
34499 arg3 = &temp3;
34500 if (!args) SWIG_fail;
34501 swig_obj[0] = args;
34502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34503 if (!SWIG_IsOK(res1)) {
34504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34505 }
34506 arg1 = reinterpret_cast< wxWindow * >(argp1);
34507 {
34508 PyThreadState* __tstate = wxPyBeginAllowThreads();
34509 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34510 wxPyEndAllowThreads(__tstate);
34511 if (PyErr_Occurred()) SWIG_fail;
34512 }
34513 resultobj = SWIG_Py_Void();
34514 if (SWIG_IsTmpObj(res2)) {
34515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34516 } else {
34517 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34518 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34519 }
34520 if (SWIG_IsTmpObj(res3)) {
34521 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34522 } else {
34523 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34524 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34525 }
34526 return resultobj;
34527fail:
34528 return NULL;
d55e5bfc
RD
34529}
34530
34531
1bd55598
RD
34532SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34533 PyObject *resultobj = 0;
34534 wxWindow *arg1 = (wxWindow *) 0 ;
34535 void *argp1 = 0 ;
34536 int res1 = 0 ;
34537 PyObject *swig_obj[1] ;
34538
34539 if (!args) SWIG_fail;
34540 swig_obj[0] = args;
34541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34542 if (!SWIG_IsOK(res1)) {
34543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34544 }
34545 arg1 = reinterpret_cast< wxWindow * >(argp1);
34546 {
34547 PyThreadState* __tstate = wxPyBeginAllowThreads();
34548 (arg1)->InvalidateBestSize();
34549 wxPyEndAllowThreads(__tstate);
34550 if (PyErr_Occurred()) SWIG_fail;
34551 }
34552 resultobj = SWIG_Py_Void();
34553 return resultobj;
34554fail:
34555 return NULL;
34556}
34557
34558
34559SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34560 PyObject *resultobj = 0;
34561 wxWindow *arg1 = (wxWindow *) 0 ;
34562 wxSize *arg2 = 0 ;
34563 void *argp1 = 0 ;
34564 int res1 = 0 ;
34565 wxSize temp2 ;
34566 PyObject * obj0 = 0 ;
34567 PyObject * obj1 = 0 ;
34568 char * kwnames[] = {
34569 (char *) "self",(char *) "size", NULL
34570 };
34571
34572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34574 if (!SWIG_IsOK(res1)) {
34575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34576 }
34577 arg1 = reinterpret_cast< wxWindow * >(argp1);
34578 {
34579 arg2 = &temp2;
34580 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34581 }
34582 {
34583 PyThreadState* __tstate = wxPyBeginAllowThreads();
34584 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34585 wxPyEndAllowThreads(__tstate);
34586 if (PyErr_Occurred()) SWIG_fail;
34587 }
34588 resultobj = SWIG_Py_Void();
34589 return resultobj;
34590fail:
34591 return NULL;
d55e5bfc
RD
34592}
34593
34594
580080c5 34595SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1bd55598
RD
34596 PyObject *resultobj = 0;
34597 wxWindow *arg1 = (wxWindow *) 0 ;
34598 wxSize result;
34599 void *argp1 = 0 ;
34600 int res1 = 0 ;
34601 PyObject *swig_obj[1] ;
34602
34603 if (!args) SWIG_fail;
34604 swig_obj[0] = args;
34605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34606 if (!SWIG_IsOK(res1)) {
580080c5 34607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
1bd55598
RD
34608 }
34609 arg1 = reinterpret_cast< wxWindow * >(argp1);
34610 {
34611 PyThreadState* __tstate = wxPyBeginAllowThreads();
580080c5 34612 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
1bd55598
RD
34613 wxPyEndAllowThreads(__tstate);
34614 if (PyErr_Occurred()) SWIG_fail;
34615 }
34616 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34617 return resultobj;
34618fail:
34619 return NULL;
d55e5bfc
RD
34620}
34621
34622
1bd55598
RD
34623SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34624 PyObject *resultobj = 0;
34625 wxWindow *arg1 = (wxWindow *) 0 ;
34626 int arg2 = (int) wxBOTH ;
34627 void *argp1 = 0 ;
34628 int res1 = 0 ;
34629 int val2 ;
34630 int ecode2 = 0 ;
34631 PyObject * obj0 = 0 ;
34632 PyObject * obj1 = 0 ;
34633 char * kwnames[] = {
34634 (char *) "self",(char *) "direction", NULL
34635 };
34636
34637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34639 if (!SWIG_IsOK(res1)) {
34640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34641 }
34642 arg1 = reinterpret_cast< wxWindow * >(argp1);
34643 if (obj1) {
34644 ecode2 = SWIG_AsVal_int(obj1, &val2);
34645 if (!SWIG_IsOK(ecode2)) {
34646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34647 }
34648 arg2 = static_cast< int >(val2);
34649 }
34650 {
34651 PyThreadState* __tstate = wxPyBeginAllowThreads();
34652 (arg1)->Center(arg2);
34653 wxPyEndAllowThreads(__tstate);
34654 if (PyErr_Occurred()) SWIG_fail;
34655 }
34656 resultobj = SWIG_Py_Void();
34657 return resultobj;
34658fail:
34659 return NULL;
34660}
34661
34662
34663SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34664 PyObject *resultobj = 0;
34665 wxWindow *arg1 = (wxWindow *) 0 ;
34666 int arg2 = (int) wxBOTH ;
34667 void *argp1 = 0 ;
34668 int res1 = 0 ;
34669 int val2 ;
34670 int ecode2 = 0 ;
34671 PyObject * obj0 = 0 ;
34672 PyObject * obj1 = 0 ;
34673 char * kwnames[] = {
34674 (char *) "self",(char *) "dir", NULL
34675 };
34676
34677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34679 if (!SWIG_IsOK(res1)) {
34680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34681 }
34682 arg1 = reinterpret_cast< wxWindow * >(argp1);
34683 if (obj1) {
34684 ecode2 = SWIG_AsVal_int(obj1, &val2);
34685 if (!SWIG_IsOK(ecode2)) {
34686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34687 }
34688 arg2 = static_cast< int >(val2);
34689 }
34690 {
34691 PyThreadState* __tstate = wxPyBeginAllowThreads();
34692 (arg1)->CenterOnParent(arg2);
34693 wxPyEndAllowThreads(__tstate);
34694 if (PyErr_Occurred()) SWIG_fail;
34695 }
34696 resultobj = SWIG_Py_Void();
34697 return resultobj;
34698fail:
34699 return NULL;
d55e5bfc
RD
34700}
34701
34702
1bd55598
RD
34703SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34704 PyObject *resultobj = 0;
34705 wxWindow *arg1 = (wxWindow *) 0 ;
34706 void *argp1 = 0 ;
34707 int res1 = 0 ;
34708 PyObject *swig_obj[1] ;
34709
34710 if (!args) SWIG_fail;
34711 swig_obj[0] = args;
34712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34713 if (!SWIG_IsOK(res1)) {
34714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34715 }
34716 arg1 = reinterpret_cast< wxWindow * >(argp1);
34717 {
34718 PyThreadState* __tstate = wxPyBeginAllowThreads();
34719 (arg1)->Fit();
34720 wxPyEndAllowThreads(__tstate);
34721 if (PyErr_Occurred()) SWIG_fail;
34722 }
34723 resultobj = SWIG_Py_Void();
34724 return resultobj;
34725fail:
34726 return NULL;
d55e5bfc
RD
34727}
34728
34729
1bd55598
RD
34730SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34731 PyObject *resultobj = 0;
34732 wxWindow *arg1 = (wxWindow *) 0 ;
34733 void *argp1 = 0 ;
34734 int res1 = 0 ;
34735 PyObject *swig_obj[1] ;
34736
34737 if (!args) SWIG_fail;
34738 swig_obj[0] = args;
34739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34740 if (!SWIG_IsOK(res1)) {
34741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34742 }
34743 arg1 = reinterpret_cast< wxWindow * >(argp1);
34744 {
34745 PyThreadState* __tstate = wxPyBeginAllowThreads();
34746 (arg1)->FitInside();
34747 wxPyEndAllowThreads(__tstate);
34748 if (PyErr_Occurred()) SWIG_fail;
34749 }
34750 resultobj = SWIG_Py_Void();
34751 return resultobj;
34752fail:
34753 return NULL;
34754}
34755
34756
34757SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34758 PyObject *resultobj = 0;
34759 wxWindow *arg1 = (wxWindow *) 0 ;
34760 int arg2 ;
34761 int arg3 ;
34762 int arg4 = (int) -1 ;
34763 int arg5 = (int) -1 ;
34764 int arg6 = (int) -1 ;
34765 int arg7 = (int) -1 ;
34766 void *argp1 = 0 ;
34767 int res1 = 0 ;
34768 int val2 ;
34769 int ecode2 = 0 ;
34770 int val3 ;
34771 int ecode3 = 0 ;
34772 int val4 ;
34773 int ecode4 = 0 ;
34774 int val5 ;
34775 int ecode5 = 0 ;
34776 int val6 ;
34777 int ecode6 = 0 ;
34778 int val7 ;
34779 int ecode7 = 0 ;
34780 PyObject * obj0 = 0 ;
34781 PyObject * obj1 = 0 ;
34782 PyObject * obj2 = 0 ;
34783 PyObject * obj3 = 0 ;
34784 PyObject * obj4 = 0 ;
34785 PyObject * obj5 = 0 ;
34786 PyObject * obj6 = 0 ;
34787 char * kwnames[] = {
34788 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34789 };
34790
34791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34793 if (!SWIG_IsOK(res1)) {
34794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34795 }
34796 arg1 = reinterpret_cast< wxWindow * >(argp1);
34797 ecode2 = SWIG_AsVal_int(obj1, &val2);
34798 if (!SWIG_IsOK(ecode2)) {
34799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34800 }
34801 arg2 = static_cast< int >(val2);
34802 ecode3 = SWIG_AsVal_int(obj2, &val3);
34803 if (!SWIG_IsOK(ecode3)) {
34804 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34805 }
34806 arg3 = static_cast< int >(val3);
34807 if (obj3) {
34808 ecode4 = SWIG_AsVal_int(obj3, &val4);
34809 if (!SWIG_IsOK(ecode4)) {
34810 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34811 }
34812 arg4 = static_cast< int >(val4);
34813 }
34814 if (obj4) {
34815 ecode5 = SWIG_AsVal_int(obj4, &val5);
34816 if (!SWIG_IsOK(ecode5)) {
34817 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34818 }
34819 arg5 = static_cast< int >(val5);
34820 }
34821 if (obj5) {
34822 ecode6 = SWIG_AsVal_int(obj5, &val6);
34823 if (!SWIG_IsOK(ecode6)) {
34824 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34825 }
34826 arg6 = static_cast< int >(val6);
34827 }
34828 if (obj6) {
34829 ecode7 = SWIG_AsVal_int(obj6, &val7);
34830 if (!SWIG_IsOK(ecode7)) {
34831 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34832 }
34833 arg7 = static_cast< int >(val7);
34834 }
34835 {
34836 PyThreadState* __tstate = wxPyBeginAllowThreads();
34837 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34838 wxPyEndAllowThreads(__tstate);
34839 if (PyErr_Occurred()) SWIG_fail;
34840 }
34841 resultobj = SWIG_Py_Void();
34842 return resultobj;
34843fail:
34844 return NULL;
34845}
34846
34847
34848SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34849 PyObject *resultobj = 0;
34850 wxWindow *arg1 = (wxWindow *) 0 ;
34851 wxSize *arg2 = 0 ;
34852 wxSize const &arg3_defvalue = wxDefaultSize ;
34853 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34854 wxSize const &arg4_defvalue = wxDefaultSize ;
34855 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34856 void *argp1 = 0 ;
34857 int res1 = 0 ;
34858 wxSize temp2 ;
34859 wxSize temp3 ;
34860 wxSize temp4 ;
34861 PyObject * obj0 = 0 ;
34862 PyObject * obj1 = 0 ;
34863 PyObject * obj2 = 0 ;
34864 PyObject * obj3 = 0 ;
34865 char * kwnames[] = {
34866 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34867 };
34868
34869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34871 if (!SWIG_IsOK(res1)) {
34872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34873 }
34874 arg1 = reinterpret_cast< wxWindow * >(argp1);
34875 {
34876 arg2 = &temp2;
34877 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34878 }
34879 if (obj2) {
d55e5bfc 34880 {
1bd55598
RD
34881 arg3 = &temp3;
34882 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
d55e5bfc 34883 }
1bd55598
RD
34884 }
34885 if (obj3) {
d55e5bfc 34886 {
1bd55598
RD
34887 arg4 = &temp4;
34888 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
d55e5bfc 34889 }
1bd55598
RD
34890 }
34891 {
34892 PyThreadState* __tstate = wxPyBeginAllowThreads();
34893 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34894 wxPyEndAllowThreads(__tstate);
34895 if (PyErr_Occurred()) SWIG_fail;
34896 }
34897 resultobj = SWIG_Py_Void();
34898 return resultobj;
34899fail:
34900 return NULL;
34901}
34902
34903
34904SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34905 PyObject *resultobj = 0;
34906 wxWindow *arg1 = (wxWindow *) 0 ;
34907 int arg2 ;
34908 int arg3 ;
34909 int arg4 = (int) -1 ;
34910 int arg5 = (int) -1 ;
34911 void *argp1 = 0 ;
34912 int res1 = 0 ;
34913 int val2 ;
34914 int ecode2 = 0 ;
34915 int val3 ;
34916 int ecode3 = 0 ;
34917 int val4 ;
34918 int ecode4 = 0 ;
34919 int val5 ;
34920 int ecode5 = 0 ;
34921 PyObject * obj0 = 0 ;
34922 PyObject * obj1 = 0 ;
34923 PyObject * obj2 = 0 ;
34924 PyObject * obj3 = 0 ;
34925 PyObject * obj4 = 0 ;
34926 char * kwnames[] = {
34927 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
34928 };
34929
34930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34932 if (!SWIG_IsOK(res1)) {
34933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34934 }
34935 arg1 = reinterpret_cast< wxWindow * >(argp1);
34936 ecode2 = SWIG_AsVal_int(obj1, &val2);
34937 if (!SWIG_IsOK(ecode2)) {
34938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
34939 }
34940 arg2 = static_cast< int >(val2);
34941 ecode3 = SWIG_AsVal_int(obj2, &val3);
34942 if (!SWIG_IsOK(ecode3)) {
34943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
34944 }
34945 arg3 = static_cast< int >(val3);
34946 if (obj3) {
34947 ecode4 = SWIG_AsVal_int(obj3, &val4);
34948 if (!SWIG_IsOK(ecode4)) {
34949 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
34950 }
34951 arg4 = static_cast< int >(val4);
34952 }
34953 if (obj4) {
34954 ecode5 = SWIG_AsVal_int(obj4, &val5);
34955 if (!SWIG_IsOK(ecode5)) {
34956 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
34957 }
34958 arg5 = static_cast< int >(val5);
34959 }
34960 {
34961 PyThreadState* __tstate = wxPyBeginAllowThreads();
34962 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
34963 wxPyEndAllowThreads(__tstate);
34964 if (PyErr_Occurred()) SWIG_fail;
34965 }
34966 resultobj = SWIG_Py_Void();
34967 return resultobj;
34968fail:
34969 return NULL;
34970}
34971
34972
34973SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34974 PyObject *resultobj = 0;
34975 wxWindow *arg1 = (wxWindow *) 0 ;
34976 wxSize *arg2 = 0 ;
34977 wxSize const &arg3_defvalue = wxDefaultSize ;
34978 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34979 void *argp1 = 0 ;
34980 int res1 = 0 ;
34981 wxSize temp2 ;
34982 wxSize temp3 ;
34983 PyObject * obj0 = 0 ;
34984 PyObject * obj1 = 0 ;
34985 PyObject * obj2 = 0 ;
34986 char * kwnames[] = {
34987 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
34988 };
34989
34990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34992 if (!SWIG_IsOK(res1)) {
34993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34994 }
34995 arg1 = reinterpret_cast< wxWindow * >(argp1);
34996 {
34997 arg2 = &temp2;
34998 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34999 }
35000 if (obj2) {
d55e5bfc 35001 {
1bd55598
RD
35002 arg3 = &temp3;
35003 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
d55e5bfc 35004 }
1bd55598
RD
35005 }
35006 {
35007 PyThreadState* __tstate = wxPyBeginAllowThreads();
35008 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35009 wxPyEndAllowThreads(__tstate);
35010 if (PyErr_Occurred()) SWIG_fail;
35011 }
35012 resultobj = SWIG_Py_Void();
35013 return resultobj;
35014fail:
35015 return NULL;
d55e5bfc
RD
35016}
35017
35018
1bd55598
RD
35019SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35020 PyObject *resultobj = 0;
35021 wxWindow *arg1 = (wxWindow *) 0 ;
35022 wxSize result;
35023 void *argp1 = 0 ;
35024 int res1 = 0 ;
35025 PyObject *swig_obj[1] ;
35026
35027 if (!args) SWIG_fail;
35028 swig_obj[0] = args;
35029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35030 if (!SWIG_IsOK(res1)) {
35031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35032 }
35033 arg1 = reinterpret_cast< wxWindow * >(argp1);
35034 {
35035 PyThreadState* __tstate = wxPyBeginAllowThreads();
35036 result = ((wxWindow const *)arg1)->GetMaxSize();
35037 wxPyEndAllowThreads(__tstate);
35038 if (PyErr_Occurred()) SWIG_fail;
35039 }
35040 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35041 return resultobj;
35042fail:
35043 return NULL;
d55e5bfc
RD
35044}
35045
35046
1bd55598
RD
35047SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35048 PyObject *resultobj = 0;
35049 wxWindow *arg1 = (wxWindow *) 0 ;
35050 wxSize result;
35051 void *argp1 = 0 ;
35052 int res1 = 0 ;
35053 PyObject *swig_obj[1] ;
35054
35055 if (!args) SWIG_fail;
35056 swig_obj[0] = args;
35057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35058 if (!SWIG_IsOK(res1)) {
35059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35060 }
35061 arg1 = reinterpret_cast< wxWindow * >(argp1);
35062 {
35063 PyThreadState* __tstate = wxPyBeginAllowThreads();
35064 result = ((wxWindow const *)arg1)->GetMinSize();
35065 wxPyEndAllowThreads(__tstate);
35066 if (PyErr_Occurred()) SWIG_fail;
35067 }
35068 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35069 return resultobj;
35070fail:
35071 return NULL;
35072}
35073
35074
35075SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35076 PyObject *resultobj = 0;
35077 wxWindow *arg1 = (wxWindow *) 0 ;
35078 wxSize *arg2 = 0 ;
35079 void *argp1 = 0 ;
35080 int res1 = 0 ;
35081 wxSize temp2 ;
35082 PyObject * obj0 = 0 ;
35083 PyObject * obj1 = 0 ;
35084 char * kwnames[] = {
35085 (char *) "self",(char *) "minSize", NULL
35086 };
35087
35088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35090 if (!SWIG_IsOK(res1)) {
35091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35092 }
35093 arg1 = reinterpret_cast< wxWindow * >(argp1);
35094 {
35095 arg2 = &temp2;
35096 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35097 }
35098 {
35099 PyThreadState* __tstate = wxPyBeginAllowThreads();
35100 (arg1)->SetMinSize((wxSize const &)*arg2);
35101 wxPyEndAllowThreads(__tstate);
35102 if (PyErr_Occurred()) SWIG_fail;
35103 }
35104 resultobj = SWIG_Py_Void();
35105 return resultobj;
35106fail:
35107 return NULL;
35108}
35109
35110
35111SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35112 PyObject *resultobj = 0;
35113 wxWindow *arg1 = (wxWindow *) 0 ;
35114 wxSize *arg2 = 0 ;
35115 void *argp1 = 0 ;
35116 int res1 = 0 ;
35117 wxSize temp2 ;
35118 PyObject * obj0 = 0 ;
35119 PyObject * obj1 = 0 ;
35120 char * kwnames[] = {
35121 (char *) "self",(char *) "maxSize", NULL
35122 };
35123
35124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35126 if (!SWIG_IsOK(res1)) {
35127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35128 }
35129 arg1 = reinterpret_cast< wxWindow * >(argp1);
35130 {
35131 arg2 = &temp2;
35132 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35133 }
35134 {
35135 PyThreadState* __tstate = wxPyBeginAllowThreads();
35136 (arg1)->SetMaxSize((wxSize const &)*arg2);
35137 wxPyEndAllowThreads(__tstate);
35138 if (PyErr_Occurred()) SWIG_fail;
35139 }
35140 resultobj = SWIG_Py_Void();
35141 return resultobj;
35142fail:
35143 return NULL;
d55e5bfc
RD
35144}
35145
35146
1bd55598
RD
35147SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35148 PyObject *resultobj = 0;
35149 wxWindow *arg1 = (wxWindow *) 0 ;
35150 int result;
35151 void *argp1 = 0 ;
35152 int res1 = 0 ;
35153 PyObject *swig_obj[1] ;
35154
35155 if (!args) SWIG_fail;
35156 swig_obj[0] = args;
35157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35158 if (!SWIG_IsOK(res1)) {
35159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35160 }
35161 arg1 = reinterpret_cast< wxWindow * >(argp1);
35162 {
35163 PyThreadState* __tstate = wxPyBeginAllowThreads();
35164 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35165 wxPyEndAllowThreads(__tstate);
35166 if (PyErr_Occurred()) SWIG_fail;
35167 }
35168 resultobj = SWIG_From_int(static_cast< int >(result));
35169 return resultobj;
35170fail:
35171 return NULL;
d55e5bfc
RD
35172}
35173
35174
1bd55598
RD
35175SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35176 PyObject *resultobj = 0;
35177 wxWindow *arg1 = (wxWindow *) 0 ;
35178 int result;
35179 void *argp1 = 0 ;
35180 int res1 = 0 ;
35181 PyObject *swig_obj[1] ;
35182
35183 if (!args) SWIG_fail;
35184 swig_obj[0] = args;
35185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35186 if (!SWIG_IsOK(res1)) {
35187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35188 }
35189 arg1 = reinterpret_cast< wxWindow * >(argp1);
35190 {
35191 PyThreadState* __tstate = wxPyBeginAllowThreads();
35192 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35193 wxPyEndAllowThreads(__tstate);
35194 if (PyErr_Occurred()) SWIG_fail;
35195 }
35196 resultobj = SWIG_From_int(static_cast< int >(result));
35197 return resultobj;
35198fail:
35199 return NULL;
d55e5bfc
RD
35200}
35201
35202
1bd55598
RD
35203SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35204 PyObject *resultobj = 0;
35205 wxWindow *arg1 = (wxWindow *) 0 ;
35206 int result;
35207 void *argp1 = 0 ;
35208 int res1 = 0 ;
35209 PyObject *swig_obj[1] ;
35210
35211 if (!args) SWIG_fail;
35212 swig_obj[0] = args;
35213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35214 if (!SWIG_IsOK(res1)) {
35215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35216 }
35217 arg1 = reinterpret_cast< wxWindow * >(argp1);
35218 {
35219 PyThreadState* __tstate = wxPyBeginAllowThreads();
35220 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35221 wxPyEndAllowThreads(__tstate);
35222 if (PyErr_Occurred()) SWIG_fail;
35223 }
35224 resultobj = SWIG_From_int(static_cast< int >(result));
35225 return resultobj;
35226fail:
35227 return NULL;
d55e5bfc 35228}
1bd55598
RD
35229
35230
35231SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35232 PyObject *resultobj = 0;
35233 wxWindow *arg1 = (wxWindow *) 0 ;
35234 int result;
35235 void *argp1 = 0 ;
35236 int res1 = 0 ;
35237 PyObject *swig_obj[1] ;
35238
35239 if (!args) SWIG_fail;
35240 swig_obj[0] = args;
35241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35242 if (!SWIG_IsOK(res1)) {
35243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35244 }
35245 arg1 = reinterpret_cast< wxWindow * >(argp1);
35246 {
35247 PyThreadState* __tstate = wxPyBeginAllowThreads();
35248 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35249 wxPyEndAllowThreads(__tstate);
35250 if (PyErr_Occurred()) SWIG_fail;
35251 }
35252 resultobj = SWIG_From_int(static_cast< int >(result));
35253 return resultobj;
35254fail:
35255 return NULL;
35256}
35257
35258
35259SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35260 PyObject *resultobj = 0;
35261 wxWindow *arg1 = (wxWindow *) 0 ;
35262 wxSize *arg2 = 0 ;
35263 void *argp1 = 0 ;
35264 int res1 = 0 ;
35265 wxSize temp2 ;
35266 PyObject * obj0 = 0 ;
35267 PyObject * obj1 = 0 ;
35268 char * kwnames[] = {
35269 (char *) "self",(char *) "size", NULL
35270 };
35271
35272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35274 if (!SWIG_IsOK(res1)) {
35275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35276 }
35277 arg1 = reinterpret_cast< wxWindow * >(argp1);
35278 {
35279 arg2 = &temp2;
35280 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35281 }
35282 {
35283 PyThreadState* __tstate = wxPyBeginAllowThreads();
35284 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35285 wxPyEndAllowThreads(__tstate);
35286 if (PyErr_Occurred()) SWIG_fail;
35287 }
35288 resultobj = SWIG_Py_Void();
35289 return resultobj;
35290fail:
35291 return NULL;
35292}
35293
35294
35295SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35296 PyObject *resultobj = 0;
35297 wxWindow *arg1 = (wxWindow *) 0 ;
35298 int arg2 ;
35299 int arg3 ;
35300 void *argp1 = 0 ;
35301 int res1 = 0 ;
35302 int val2 ;
35303 int ecode2 = 0 ;
35304 int val3 ;
35305 int ecode3 = 0 ;
35306 PyObject * obj0 = 0 ;
35307 PyObject * obj1 = 0 ;
35308 PyObject * obj2 = 0 ;
35309 char * kwnames[] = {
35310 (char *) "self",(char *) "w",(char *) "h", NULL
35311 };
35312
35313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35315 if (!SWIG_IsOK(res1)) {
35316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35317 }
35318 arg1 = reinterpret_cast< wxWindow * >(argp1);
35319 ecode2 = SWIG_AsVal_int(obj1, &val2);
35320 if (!SWIG_IsOK(ecode2)) {
35321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35322 }
35323 arg2 = static_cast< int >(val2);
35324 ecode3 = SWIG_AsVal_int(obj2, &val3);
35325 if (!SWIG_IsOK(ecode3)) {
35326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35327 }
35328 arg3 = static_cast< int >(val3);
35329 {
35330 PyThreadState* __tstate = wxPyBeginAllowThreads();
35331 (arg1)->SetVirtualSize(arg2,arg3);
35332 wxPyEndAllowThreads(__tstate);
35333 if (PyErr_Occurred()) SWIG_fail;
35334 }
35335 resultobj = SWIG_Py_Void();
35336 return resultobj;
35337fail:
35338 return NULL;
d55e5bfc
RD
35339}
35340
35341
1bd55598
RD
35342SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35343 PyObject *resultobj = 0;
35344 wxWindow *arg1 = (wxWindow *) 0 ;
35345 wxSize result;
35346 void *argp1 = 0 ;
35347 int res1 = 0 ;
35348 PyObject *swig_obj[1] ;
35349
35350 if (!args) SWIG_fail;
35351 swig_obj[0] = args;
35352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35353 if (!SWIG_IsOK(res1)) {
35354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35355 }
35356 arg1 = reinterpret_cast< wxWindow * >(argp1);
35357 {
35358 PyThreadState* __tstate = wxPyBeginAllowThreads();
35359 result = ((wxWindow const *)arg1)->GetVirtualSize();
35360 wxPyEndAllowThreads(__tstate);
35361 if (PyErr_Occurred()) SWIG_fail;
35362 }
35363 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35364 return resultobj;
35365fail:
35366 return NULL;
35367}
35368
35369
35370SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35371 PyObject *resultobj = 0;
35372 wxWindow *arg1 = (wxWindow *) 0 ;
35373 int *arg2 = (int *) 0 ;
35374 int *arg3 = (int *) 0 ;
35375 void *argp1 = 0 ;
35376 int res1 = 0 ;
35377 int temp2 ;
35378 int res2 = SWIG_TMPOBJ ;
35379 int temp3 ;
35380 int res3 = SWIG_TMPOBJ ;
35381 PyObject *swig_obj[1] ;
35382
35383 arg2 = &temp2;
35384 arg3 = &temp3;
35385 if (!args) SWIG_fail;
35386 swig_obj[0] = args;
35387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35388 if (!SWIG_IsOK(res1)) {
35389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35390 }
35391 arg1 = reinterpret_cast< wxWindow * >(argp1);
35392 {
35393 PyThreadState* __tstate = wxPyBeginAllowThreads();
35394 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35395 wxPyEndAllowThreads(__tstate);
35396 if (PyErr_Occurred()) SWIG_fail;
35397 }
35398 resultobj = SWIG_Py_Void();
35399 if (SWIG_IsTmpObj(res2)) {
35400 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35401 } else {
35402 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35403 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35404 }
35405 if (SWIG_IsTmpObj(res3)) {
35406 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35407 } else {
35408 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35409 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35410 }
35411 return resultobj;
35412fail:
35413 return NULL;
d55e5bfc
RD
35414}
35415
35416
cbdf0fb0
RD
35417SWIGINTERN PyObject *_wrap_Window_GetWindowBorderSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35418 PyObject *resultobj = 0;
35419 wxWindow *arg1 = (wxWindow *) 0 ;
35420 wxSize result;
35421 void *argp1 = 0 ;
35422 int res1 = 0 ;
35423 PyObject *swig_obj[1] ;
35424
35425 if (!args) SWIG_fail;
35426 swig_obj[0] = args;
35427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35428 if (!SWIG_IsOK(res1)) {
35429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowBorderSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35430 }
35431 arg1 = reinterpret_cast< wxWindow * >(argp1);
35432 {
35433 PyThreadState* __tstate = wxPyBeginAllowThreads();
35434 result = ((wxWindow const *)arg1)->GetWindowBorderSize();
35435 wxPyEndAllowThreads(__tstate);
35436 if (PyErr_Occurred()) SWIG_fail;
35437 }
35438 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35439 return resultobj;
35440fail:
35441 return NULL;
35442}
35443
35444
1bd55598
RD
35445SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35446 PyObject *resultobj = 0;
35447 wxWindow *arg1 = (wxWindow *) 0 ;
35448 wxSize result;
35449 void *argp1 = 0 ;
35450 int res1 = 0 ;
35451 PyObject *swig_obj[1] ;
35452
35453 if (!args) SWIG_fail;
35454 swig_obj[0] = args;
35455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35456 if (!SWIG_IsOK(res1)) {
35457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35458 }
35459 arg1 = reinterpret_cast< wxWindow * >(argp1);
35460 {
35461 PyThreadState* __tstate = wxPyBeginAllowThreads();
35462 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35463 wxPyEndAllowThreads(__tstate);
35464 if (PyErr_Occurred()) SWIG_fail;
35465 }
35466 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35467 return resultobj;
35468fail:
35469 return NULL;
35470}
35471
35472
35473SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35474 PyObject *resultobj = 0;
35475 wxWindow *arg1 = (wxWindow *) 0 ;
35476 bool arg2 = (bool) true ;
35477 bool result;
35478 void *argp1 = 0 ;
35479 int res1 = 0 ;
35480 bool val2 ;
35481 int ecode2 = 0 ;
35482 PyObject * obj0 = 0 ;
35483 PyObject * obj1 = 0 ;
35484 char * kwnames[] = {
35485 (char *) "self",(char *) "show", NULL
35486 };
35487
35488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35490 if (!SWIG_IsOK(res1)) {
35491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35492 }
35493 arg1 = reinterpret_cast< wxWindow * >(argp1);
35494 if (obj1) {
35495 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35496 if (!SWIG_IsOK(ecode2)) {
35497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35498 }
35499 arg2 = static_cast< bool >(val2);
35500 }
35501 {
35502 PyThreadState* __tstate = wxPyBeginAllowThreads();
35503 result = (bool)(arg1)->Show(arg2);
35504 wxPyEndAllowThreads(__tstate);
35505 if (PyErr_Occurred()) SWIG_fail;
35506 }
35507 {
35508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35509 }
35510 return resultobj;
35511fail:
35512 return NULL;
d55e5bfc
RD
35513}
35514
35515
1bd55598
RD
35516SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35517 PyObject *resultobj = 0;
35518 wxWindow *arg1 = (wxWindow *) 0 ;
35519 bool result;
35520 void *argp1 = 0 ;
35521 int res1 = 0 ;
35522 PyObject *swig_obj[1] ;
35523
35524 if (!args) SWIG_fail;
35525 swig_obj[0] = args;
35526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35527 if (!SWIG_IsOK(res1)) {
35528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35529 }
35530 arg1 = reinterpret_cast< wxWindow * >(argp1);
35531 {
35532 PyThreadState* __tstate = wxPyBeginAllowThreads();
35533 result = (bool)(arg1)->Hide();
35534 wxPyEndAllowThreads(__tstate);
35535 if (PyErr_Occurred()) SWIG_fail;
35536 }
35537 {
35538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35539 }
35540 return resultobj;
35541fail:
35542 return NULL;
35543}
35544
35545
35546SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35547 PyObject *resultobj = 0;
35548 wxWindow *arg1 = (wxWindow *) 0 ;
35549 bool arg2 = (bool) true ;
35550 bool result;
35551 void *argp1 = 0 ;
35552 int res1 = 0 ;
35553 bool val2 ;
35554 int ecode2 = 0 ;
35555 PyObject * obj0 = 0 ;
35556 PyObject * obj1 = 0 ;
35557 char * kwnames[] = {
35558 (char *) "self",(char *) "enable", NULL
35559 };
35560
35561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35563 if (!SWIG_IsOK(res1)) {
35564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35565 }
35566 arg1 = reinterpret_cast< wxWindow * >(argp1);
35567 if (obj1) {
35568 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35569 if (!SWIG_IsOK(ecode2)) {
35570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35571 }
35572 arg2 = static_cast< bool >(val2);
35573 }
35574 {
35575 PyThreadState* __tstate = wxPyBeginAllowThreads();
35576 result = (bool)(arg1)->Enable(arg2);
35577 wxPyEndAllowThreads(__tstate);
35578 if (PyErr_Occurred()) SWIG_fail;
35579 }
35580 {
35581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35582 }
35583 return resultobj;
35584fail:
35585 return NULL;
b1fcee84
RD
35586}
35587
35588
1bd55598
RD
35589SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35590 PyObject *resultobj = 0;
35591 wxWindow *arg1 = (wxWindow *) 0 ;
35592 bool result;
35593 void *argp1 = 0 ;
35594 int res1 = 0 ;
35595 PyObject *swig_obj[1] ;
35596
35597 if (!args) SWIG_fail;
35598 swig_obj[0] = args;
35599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35600 if (!SWIG_IsOK(res1)) {
35601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35602 }
35603 arg1 = reinterpret_cast< wxWindow * >(argp1);
35604 {
35605 PyThreadState* __tstate = wxPyBeginAllowThreads();
35606 result = (bool)(arg1)->Disable();
35607 wxPyEndAllowThreads(__tstate);
35608 if (PyErr_Occurred()) SWIG_fail;
35609 }
35610 {
35611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35612 }
35613 return resultobj;
35614fail:
35615 return NULL;
d55e5bfc
RD
35616}
35617
35618
1bd55598
RD
35619SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35620 PyObject *resultobj = 0;
35621 wxWindow *arg1 = (wxWindow *) 0 ;
35622 bool result;
35623 void *argp1 = 0 ;
35624 int res1 = 0 ;
35625 PyObject *swig_obj[1] ;
35626
35627 if (!args) SWIG_fail;
35628 swig_obj[0] = args;
35629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35630 if (!SWIG_IsOK(res1)) {
35631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35632 }
35633 arg1 = reinterpret_cast< wxWindow * >(argp1);
35634 {
35635 PyThreadState* __tstate = wxPyBeginAllowThreads();
35636 result = (bool)((wxWindow const *)arg1)->IsShown();
35637 wxPyEndAllowThreads(__tstate);
35638 if (PyErr_Occurred()) SWIG_fail;
35639 }
35640 {
35641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35642 }
35643 return resultobj;
35644fail:
35645 return NULL;
d55e5bfc
RD
35646}
35647
35648
1bd55598
RD
35649SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35650 PyObject *resultobj = 0;
35651 wxWindow *arg1 = (wxWindow *) 0 ;
35652 bool result;
35653 void *argp1 = 0 ;
35654 int res1 = 0 ;
35655 PyObject *swig_obj[1] ;
35656
35657 if (!args) SWIG_fail;
35658 swig_obj[0] = args;
35659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35660 if (!SWIG_IsOK(res1)) {
35661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35662 }
35663 arg1 = reinterpret_cast< wxWindow * >(argp1);
35664 {
35665 PyThreadState* __tstate = wxPyBeginAllowThreads();
35666 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35667 wxPyEndAllowThreads(__tstate);
35668 if (PyErr_Occurred()) SWIG_fail;
35669 }
35670 {
35671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35672 }
35673 return resultobj;
35674fail:
35675 return NULL;
35676}
35677
35678
33d6fd3b
RD
35679SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35680 PyObject *resultobj = 0;
35681 wxWindow *arg1 = (wxWindow *) 0 ;
35682 bool result;
35683 void *argp1 = 0 ;
35684 int res1 = 0 ;
35685 PyObject *swig_obj[1] ;
35686
35687 if (!args) SWIG_fail;
35688 swig_obj[0] = args;
35689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35690 if (!SWIG_IsOK(res1)) {
35691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35692 }
35693 arg1 = reinterpret_cast< wxWindow * >(argp1);
35694 {
35695 PyThreadState* __tstate = wxPyBeginAllowThreads();
35696 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35697 wxPyEndAllowThreads(__tstate);
35698 if (PyErr_Occurred()) SWIG_fail;
35699 }
35700 {
35701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35702 }
35703 return resultobj;
35704fail:
35705 return NULL;
35706}
35707
35708
1bd55598
RD
35709SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35710 PyObject *resultobj = 0;
35711 wxWindow *arg1 = (wxWindow *) 0 ;
35712 long arg2 ;
35713 void *argp1 = 0 ;
35714 int res1 = 0 ;
35715 long val2 ;
35716 int ecode2 = 0 ;
35717 PyObject * obj0 = 0 ;
35718 PyObject * obj1 = 0 ;
35719 char * kwnames[] = {
35720 (char *) "self",(char *) "style", NULL
35721 };
35722
35723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35725 if (!SWIG_IsOK(res1)) {
35726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35727 }
35728 arg1 = reinterpret_cast< wxWindow * >(argp1);
35729 ecode2 = SWIG_AsVal_long(obj1, &val2);
35730 if (!SWIG_IsOK(ecode2)) {
35731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35732 }
35733 arg2 = static_cast< long >(val2);
35734 {
35735 PyThreadState* __tstate = wxPyBeginAllowThreads();
35736 (arg1)->SetWindowStyleFlag(arg2);
35737 wxPyEndAllowThreads(__tstate);
35738 if (PyErr_Occurred()) SWIG_fail;
35739 }
35740 resultobj = SWIG_Py_Void();
35741 return resultobj;
35742fail:
35743 return NULL;
d55e5bfc
RD
35744}
35745
35746
1bd55598
RD
35747SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35748 PyObject *resultobj = 0;
35749 wxWindow *arg1 = (wxWindow *) 0 ;
35750 long result;
35751 void *argp1 = 0 ;
35752 int res1 = 0 ;
35753 PyObject *swig_obj[1] ;
35754
35755 if (!args) SWIG_fail;
35756 swig_obj[0] = args;
35757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35758 if (!SWIG_IsOK(res1)) {
35759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35760 }
35761 arg1 = reinterpret_cast< wxWindow * >(argp1);
35762 {
35763 PyThreadState* __tstate = wxPyBeginAllowThreads();
35764 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35765 wxPyEndAllowThreads(__tstate);
35766 if (PyErr_Occurred()) SWIG_fail;
35767 }
35768 resultobj = SWIG_From_long(static_cast< long >(result));
35769 return resultobj;
35770fail:
35771 return NULL;
35772}
35773
35774
35775SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35776 PyObject *resultobj = 0;
35777 wxWindow *arg1 = (wxWindow *) 0 ;
35778 int arg2 ;
35779 bool result;
35780 void *argp1 = 0 ;
35781 int res1 = 0 ;
35782 int val2 ;
35783 int ecode2 = 0 ;
35784 PyObject * obj0 = 0 ;
35785 PyObject * obj1 = 0 ;
35786 char * kwnames[] = {
35787 (char *) "self",(char *) "flag", NULL
35788 };
35789
35790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35792 if (!SWIG_IsOK(res1)) {
35793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35794 }
35795 arg1 = reinterpret_cast< wxWindow * >(argp1);
35796 ecode2 = SWIG_AsVal_int(obj1, &val2);
35797 if (!SWIG_IsOK(ecode2)) {
35798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35799 }
35800 arg2 = static_cast< int >(val2);
35801 {
35802 PyThreadState* __tstate = wxPyBeginAllowThreads();
35803 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35804 wxPyEndAllowThreads(__tstate);
35805 if (PyErr_Occurred()) SWIG_fail;
35806 }
35807 {
35808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35809 }
35810 return resultobj;
35811fail:
35812 return NULL;
d55e5bfc
RD
35813}
35814
35815
1bd55598
RD
35816SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35817 PyObject *resultobj = 0;
35818 wxWindow *arg1 = (wxWindow *) 0 ;
35819 bool result;
35820 void *argp1 = 0 ;
35821 int res1 = 0 ;
35822 PyObject *swig_obj[1] ;
35823
35824 if (!args) SWIG_fail;
35825 swig_obj[0] = args;
35826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35827 if (!SWIG_IsOK(res1)) {
35828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35829 }
35830 arg1 = reinterpret_cast< wxWindow * >(argp1);
35831 {
35832 PyThreadState* __tstate = wxPyBeginAllowThreads();
35833 result = (bool)((wxWindow const *)arg1)->IsRetained();
35834 wxPyEndAllowThreads(__tstate);
35835 if (PyErr_Occurred()) SWIG_fail;
35836 }
35837 {
35838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35839 }
35840 return resultobj;
35841fail:
35842 return NULL;
35843}
35844
35845
5917d041
RD
35846SWIGINTERN PyObject *_wrap_Window_ToggleWindowStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35847 PyObject *resultobj = 0;
35848 wxWindow *arg1 = (wxWindow *) 0 ;
35849 int arg2 ;
35850 bool result;
35851 void *argp1 = 0 ;
35852 int res1 = 0 ;
35853 int val2 ;
35854 int ecode2 = 0 ;
35855 PyObject * obj0 = 0 ;
35856 PyObject * obj1 = 0 ;
35857 char * kwnames[] = {
35858 (char *) "self",(char *) "flag", NULL
35859 };
35860
35861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ToggleWindowStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35863 if (!SWIG_IsOK(res1)) {
35864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ToggleWindowStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35865 }
35866 arg1 = reinterpret_cast< wxWindow * >(argp1);
35867 ecode2 = SWIG_AsVal_int(obj1, &val2);
35868 if (!SWIG_IsOK(ecode2)) {
35869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ToggleWindowStyle" "', expected argument " "2"" of type '" "int""'");
35870 }
35871 arg2 = static_cast< int >(val2);
35872 {
35873 PyThreadState* __tstate = wxPyBeginAllowThreads();
35874 result = (bool)(arg1)->ToggleWindowStyle(arg2);
35875 wxPyEndAllowThreads(__tstate);
35876 if (PyErr_Occurred()) SWIG_fail;
35877 }
35878 {
35879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35880 }
35881 return resultobj;
35882fail:
35883 return NULL;
35884}
35885
35886
1bd55598
RD
35887SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35888 PyObject *resultobj = 0;
35889 wxWindow *arg1 = (wxWindow *) 0 ;
35890 long arg2 ;
35891 void *argp1 = 0 ;
35892 int res1 = 0 ;
35893 long val2 ;
35894 int ecode2 = 0 ;
35895 PyObject * obj0 = 0 ;
35896 PyObject * obj1 = 0 ;
35897 char * kwnames[] = {
35898 (char *) "self",(char *) "exStyle", NULL
35899 };
35900
35901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35903 if (!SWIG_IsOK(res1)) {
35904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35905 }
35906 arg1 = reinterpret_cast< wxWindow * >(argp1);
35907 ecode2 = SWIG_AsVal_long(obj1, &val2);
35908 if (!SWIG_IsOK(ecode2)) {
35909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35910 }
35911 arg2 = static_cast< long >(val2);
35912 {
35913 PyThreadState* __tstate = wxPyBeginAllowThreads();
35914 (arg1)->SetExtraStyle(arg2);
35915 wxPyEndAllowThreads(__tstate);
35916 if (PyErr_Occurred()) SWIG_fail;
35917 }
35918 resultobj = SWIG_Py_Void();
35919 return resultobj;
35920fail:
35921 return NULL;
b1fcee84
RD
35922}
35923
35924
1bd55598
RD
35925SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35926 PyObject *resultobj = 0;
35927 wxWindow *arg1 = (wxWindow *) 0 ;
35928 long result;
35929 void *argp1 = 0 ;
35930 int res1 = 0 ;
35931 PyObject *swig_obj[1] ;
35932
35933 if (!args) SWIG_fail;
35934 swig_obj[0] = args;
35935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35936 if (!SWIG_IsOK(res1)) {
35937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35938 }
35939 arg1 = reinterpret_cast< wxWindow * >(argp1);
35940 {
35941 PyThreadState* __tstate = wxPyBeginAllowThreads();
35942 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35943 wxPyEndAllowThreads(__tstate);
35944 if (PyErr_Occurred()) SWIG_fail;
35945 }
35946 resultobj = SWIG_From_long(static_cast< long >(result));
35947 return resultobj;
35948fail:
35949 return NULL;
35950}
35951
35952
35953SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35954 PyObject *resultobj = 0;
35955 wxWindow *arg1 = (wxWindow *) 0 ;
35956 bool arg2 = (bool) true ;
35957 void *argp1 = 0 ;
35958 int res1 = 0 ;
35959 bool val2 ;
35960 int ecode2 = 0 ;
35961 PyObject * obj0 = 0 ;
35962 PyObject * obj1 = 0 ;
35963 char * kwnames[] = {
35964 (char *) "self",(char *) "modal", NULL
35965 };
35966
35967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35969 if (!SWIG_IsOK(res1)) {
35970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35971 }
35972 arg1 = reinterpret_cast< wxWindow * >(argp1);
35973 if (obj1) {
35974 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35975 if (!SWIG_IsOK(ecode2)) {
35976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35977 }
35978 arg2 = static_cast< bool >(val2);
35979 }
35980 {
35981 PyThreadState* __tstate = wxPyBeginAllowThreads();
35982 (arg1)->MakeModal(arg2);
35983 wxPyEndAllowThreads(__tstate);
35984 if (PyErr_Occurred()) SWIG_fail;
35985 }
35986 resultobj = SWIG_Py_Void();
35987 return resultobj;
35988fail:
35989 return NULL;
35990}
35991
35992
35993SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35994 PyObject *resultobj = 0;
35995 wxWindow *arg1 = (wxWindow *) 0 ;
35996 bool arg2 ;
35997 void *argp1 = 0 ;
35998 int res1 = 0 ;
35999 bool val2 ;
36000 int ecode2 = 0 ;
36001 PyObject * obj0 = 0 ;
36002 PyObject * obj1 = 0 ;
36003 char * kwnames[] = {
36004 (char *) "self",(char *) "enableTheme", NULL
36005 };
36006
36007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36009 if (!SWIG_IsOK(res1)) {
36010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36011 }
36012 arg1 = reinterpret_cast< wxWindow * >(argp1);
36013 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36014 if (!SWIG_IsOK(ecode2)) {
36015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36016 }
36017 arg2 = static_cast< bool >(val2);
36018 {
36019 PyThreadState* __tstate = wxPyBeginAllowThreads();
36020 (arg1)->SetThemeEnabled(arg2);
36021 wxPyEndAllowThreads(__tstate);
36022 if (PyErr_Occurred()) SWIG_fail;
36023 }
36024 resultobj = SWIG_Py_Void();
36025 return resultobj;
36026fail:
36027 return NULL;
d55e5bfc
RD
36028}
36029
36030
1bd55598
RD
36031SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36032 PyObject *resultobj = 0;
36033 wxWindow *arg1 = (wxWindow *) 0 ;
36034 bool result;
36035 void *argp1 = 0 ;
36036 int res1 = 0 ;
36037 PyObject *swig_obj[1] ;
36038
36039 if (!args) SWIG_fail;
36040 swig_obj[0] = args;
36041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36042 if (!SWIG_IsOK(res1)) {
36043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36044 }
36045 arg1 = reinterpret_cast< wxWindow * >(argp1);
36046 {
36047 PyThreadState* __tstate = wxPyBeginAllowThreads();
36048 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36049 wxPyEndAllowThreads(__tstate);
36050 if (PyErr_Occurred()) SWIG_fail;
36051 }
36052 {
36053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36054 }
36055 return resultobj;
36056fail:
36057 return NULL;
d55e5bfc
RD
36058}
36059
36060
1bd55598
RD
36061SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36062 PyObject *resultobj = 0;
36063 wxWindow *arg1 = (wxWindow *) 0 ;
36064 void *argp1 = 0 ;
36065 int res1 = 0 ;
36066 PyObject *swig_obj[1] ;
36067
36068 if (!args) SWIG_fail;
36069 swig_obj[0] = args;
36070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36071 if (!SWIG_IsOK(res1)) {
36072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36073 }
36074 arg1 = reinterpret_cast< wxWindow * >(argp1);
36075 {
36076 PyThreadState* __tstate = wxPyBeginAllowThreads();
36077 (arg1)->SetFocus();
36078 wxPyEndAllowThreads(__tstate);
36079 if (PyErr_Occurred()) SWIG_fail;
36080 }
36081 resultobj = SWIG_Py_Void();
36082 return resultobj;
36083fail:
36084 return NULL;
b1fcee84
RD
36085}
36086
36087
1bd55598
RD
36088SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36089 PyObject *resultobj = 0;
36090 wxWindow *arg1 = (wxWindow *) 0 ;
36091 void *argp1 = 0 ;
36092 int res1 = 0 ;
36093 PyObject *swig_obj[1] ;
36094
36095 if (!args) SWIG_fail;
36096 swig_obj[0] = args;
36097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36098 if (!SWIG_IsOK(res1)) {
36099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36100 }
36101 arg1 = reinterpret_cast< wxWindow * >(argp1);
36102 {
36103 PyThreadState* __tstate = wxPyBeginAllowThreads();
36104 (arg1)->SetFocusFromKbd();
36105 wxPyEndAllowThreads(__tstate);
36106 if (PyErr_Occurred()) SWIG_fail;
36107 }
36108 resultobj = SWIG_Py_Void();
36109 return resultobj;
36110fail:
36111 return NULL;
d55e5bfc
RD
36112}
36113
36114
1bd55598
RD
36115SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36116 PyObject *resultobj = 0;
36117 wxWindow *result = 0 ;
36118
36119 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36120 {
36121 if (!wxPyCheckForApp()) SWIG_fail;
36122 PyThreadState* __tstate = wxPyBeginAllowThreads();
36123 result = (wxWindow *)wxWindow::FindFocus();
36124 wxPyEndAllowThreads(__tstate);
36125 if (PyErr_Occurred()) SWIG_fail;
36126 }
36127 {
36128 resultobj = wxPyMake_wxObject(result, 0);
36129 }
36130 return resultobj;
36131fail:
36132 return NULL;
d55e5bfc
RD
36133}
36134
36135
1bd55598
RD
36136SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36137 PyObject *resultobj = 0;
36138 wxWindow *arg1 = (wxWindow *) 0 ;
36139 bool result;
36140 void *argp1 = 0 ;
36141 int res1 = 0 ;
36142 PyObject *swig_obj[1] ;
36143
36144 if (!args) SWIG_fail;
36145 swig_obj[0] = args;
36146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36147 if (!SWIG_IsOK(res1)) {
36148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36149 }
36150 arg1 = reinterpret_cast< wxWindow * >(argp1);
36151 {
36152 PyThreadState* __tstate = wxPyBeginAllowThreads();
36153 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36154 wxPyEndAllowThreads(__tstate);
36155 if (PyErr_Occurred()) SWIG_fail;
36156 }
36157 {
36158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36159 }
36160 return resultobj;
36161fail:
36162 return NULL;
d55e5bfc
RD
36163}
36164
36165
1bd55598
RD
36166SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36167 PyObject *resultobj = 0;
36168 wxWindow *arg1 = (wxWindow *) 0 ;
36169 bool result;
36170 void *argp1 = 0 ;
36171 int res1 = 0 ;
36172 PyObject *swig_obj[1] ;
36173
36174 if (!args) SWIG_fail;
36175 swig_obj[0] = args;
36176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36177 if (!SWIG_IsOK(res1)) {
36178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36179 }
36180 arg1 = reinterpret_cast< wxWindow * >(argp1);
36181 {
36182 PyThreadState* __tstate = wxPyBeginAllowThreads();
36183 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36184 wxPyEndAllowThreads(__tstate);
36185 if (PyErr_Occurred()) SWIG_fail;
36186 }
36187 {
36188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36189 }
36190 return resultobj;
36191fail:
36192 return NULL;
d55e5bfc
RD
36193}
36194
36195
1bd55598
RD
36196SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36197 PyObject *resultobj = 0;
36198 wxWindow *arg1 = (wxWindow *) 0 ;
36199 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36200 bool result;
36201 void *argp1 = 0 ;
36202 int res1 = 0 ;
36203 int val2 ;
36204 int ecode2 = 0 ;
36205 PyObject * obj0 = 0 ;
36206 PyObject * obj1 = 0 ;
36207 char * kwnames[] = {
36208 (char *) "self",(char *) "flags", NULL
36209 };
36210
36211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36213 if (!SWIG_IsOK(res1)) {
36214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36215 }
36216 arg1 = reinterpret_cast< wxWindow * >(argp1);
36217 if (obj1) {
36218 ecode2 = SWIG_AsVal_int(obj1, &val2);
36219 if (!SWIG_IsOK(ecode2)) {
36220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36221 }
36222 arg2 = static_cast< int >(val2);
36223 }
36224 {
36225 PyThreadState* __tstate = wxPyBeginAllowThreads();
36226 result = (bool)(arg1)->Navigate(arg2);
36227 wxPyEndAllowThreads(__tstate);
36228 if (PyErr_Occurred()) SWIG_fail;
36229 }
36230 {
36231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36232 }
36233 return resultobj;
36234fail:
36235 return NULL;
36236}
36237
36238
36239SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36240 PyObject *resultobj = 0;
36241 wxWindow *arg1 = (wxWindow *) 0 ;
36242 wxWindow *arg2 = (wxWindow *) 0 ;
36243 void *argp1 = 0 ;
36244 int res1 = 0 ;
36245 void *argp2 = 0 ;
36246 int res2 = 0 ;
36247 PyObject * obj0 = 0 ;
36248 PyObject * obj1 = 0 ;
36249 char * kwnames[] = {
36250 (char *) "self",(char *) "win", NULL
36251 };
36252
36253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36255 if (!SWIG_IsOK(res1)) {
36256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36257 }
36258 arg1 = reinterpret_cast< wxWindow * >(argp1);
36259 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36260 if (!SWIG_IsOK(res2)) {
36261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36262 }
36263 arg2 = reinterpret_cast< wxWindow * >(argp2);
36264 {
36265 PyThreadState* __tstate = wxPyBeginAllowThreads();
36266 (arg1)->MoveAfterInTabOrder(arg2);
36267 wxPyEndAllowThreads(__tstate);
36268 if (PyErr_Occurred()) SWIG_fail;
36269 }
36270 resultobj = SWIG_Py_Void();
36271 return resultobj;
36272fail:
36273 return NULL;
36274}
36275
36276
36277SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36278 PyObject *resultobj = 0;
36279 wxWindow *arg1 = (wxWindow *) 0 ;
36280 wxWindow *arg2 = (wxWindow *) 0 ;
36281 void *argp1 = 0 ;
36282 int res1 = 0 ;
36283 void *argp2 = 0 ;
36284 int res2 = 0 ;
36285 PyObject * obj0 = 0 ;
36286 PyObject * obj1 = 0 ;
36287 char * kwnames[] = {
36288 (char *) "self",(char *) "win", NULL
36289 };
36290
36291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36293 if (!SWIG_IsOK(res1)) {
36294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36295 }
36296 arg1 = reinterpret_cast< wxWindow * >(argp1);
36297 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36298 if (!SWIG_IsOK(res2)) {
36299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36300 }
36301 arg2 = reinterpret_cast< wxWindow * >(argp2);
36302 {
36303 PyThreadState* __tstate = wxPyBeginAllowThreads();
36304 (arg1)->MoveBeforeInTabOrder(arg2);
36305 wxPyEndAllowThreads(__tstate);
36306 if (PyErr_Occurred()) SWIG_fail;
36307 }
36308 resultobj = SWIG_Py_Void();
36309 return resultobj;
36310fail:
36311 return NULL;
d55e5bfc
RD
36312}
36313
36314
1bd55598
RD
36315SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36316 PyObject *resultobj = 0;
36317 wxWindow *arg1 = (wxWindow *) 0 ;
36318 PyObject *result = 0 ;
36319 void *argp1 = 0 ;
36320 int res1 = 0 ;
36321 PyObject *swig_obj[1] ;
36322
36323 if (!args) SWIG_fail;
36324 swig_obj[0] = args;
36325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36326 if (!SWIG_IsOK(res1)) {
36327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36328 }
36329 arg1 = reinterpret_cast< wxWindow * >(argp1);
36330 {
36331 PyThreadState* __tstate = wxPyBeginAllowThreads();
36332 result = (PyObject *)wxWindow_GetChildren(arg1);
36333 wxPyEndAllowThreads(__tstate);
36334 if (PyErr_Occurred()) SWIG_fail;
36335 }
36336 resultobj = result;
36337 return resultobj;
36338fail:
36339 return NULL;
d55e5bfc
RD
36340}
36341
36342
1bd55598
RD
36343SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36344 PyObject *resultobj = 0;
36345 wxWindow *arg1 = (wxWindow *) 0 ;
36346 wxWindow *result = 0 ;
36347 void *argp1 = 0 ;
36348 int res1 = 0 ;
36349 PyObject *swig_obj[1] ;
36350
36351 if (!args) SWIG_fail;
36352 swig_obj[0] = args;
36353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36354 if (!SWIG_IsOK(res1)) {
36355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36356 }
36357 arg1 = reinterpret_cast< wxWindow * >(argp1);
36358 {
36359 PyThreadState* __tstate = wxPyBeginAllowThreads();
36360 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36361 wxPyEndAllowThreads(__tstate);
36362 if (PyErr_Occurred()) SWIG_fail;
36363 }
36364 {
36365 resultobj = wxPyMake_wxObject(result, 0);
36366 }
36367 return resultobj;
36368fail:
36369 return NULL;
d55e5bfc
RD
36370}
36371
36372
1bd55598
RD
36373SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36374 PyObject *resultobj = 0;
36375 wxWindow *arg1 = (wxWindow *) 0 ;
36376 wxWindow *result = 0 ;
36377 void *argp1 = 0 ;
36378 int res1 = 0 ;
36379 PyObject *swig_obj[1] ;
36380
36381 if (!args) SWIG_fail;
36382 swig_obj[0] = args;
36383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36384 if (!SWIG_IsOK(res1)) {
36385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36386 }
36387 arg1 = reinterpret_cast< wxWindow * >(argp1);
36388 {
36389 PyThreadState* __tstate = wxPyBeginAllowThreads();
36390 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36391 wxPyEndAllowThreads(__tstate);
36392 if (PyErr_Occurred()) SWIG_fail;
36393 }
36394 {
36395 resultobj = wxPyMake_wxObject(result, 0);
36396 }
36397 return resultobj;
36398fail:
36399 return NULL;
d55e5bfc
RD
36400}
36401
36402
1bd55598
RD
36403SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36404 PyObject *resultobj = 0;
36405 wxWindow *arg1 = (wxWindow *) 0 ;
36406 bool result;
36407 void *argp1 = 0 ;
36408 int res1 = 0 ;
36409 PyObject *swig_obj[1] ;
36410
36411 if (!args) SWIG_fail;
36412 swig_obj[0] = args;
36413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36414 if (!SWIG_IsOK(res1)) {
36415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36416 }
36417 arg1 = reinterpret_cast< wxWindow * >(argp1);
36418 {
36419 PyThreadState* __tstate = wxPyBeginAllowThreads();
36420 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36421 wxPyEndAllowThreads(__tstate);
36422 if (PyErr_Occurred()) SWIG_fail;
36423 }
36424 {
36425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36426 }
36427 return resultobj;
36428fail:
36429 return NULL;
36430}
36431
36432
36433SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36434 PyObject *resultobj = 0;
36435 wxWindow *arg1 = (wxWindow *) 0 ;
36436 wxWindow *arg2 = (wxWindow *) 0 ;
36437 bool result;
36438 void *argp1 = 0 ;
36439 int res1 = 0 ;
36440 void *argp2 = 0 ;
36441 int res2 = 0 ;
36442 PyObject * obj0 = 0 ;
36443 PyObject * obj1 = 0 ;
36444 char * kwnames[] = {
36445 (char *) "self",(char *) "newParent", NULL
36446 };
36447
36448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36450 if (!SWIG_IsOK(res1)) {
36451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36452 }
36453 arg1 = reinterpret_cast< wxWindow * >(argp1);
36454 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36455 if (!SWIG_IsOK(res2)) {
36456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36457 }
36458 arg2 = reinterpret_cast< wxWindow * >(argp2);
36459 {
36460 PyThreadState* __tstate = wxPyBeginAllowThreads();
36461 result = (bool)(arg1)->Reparent(arg2);
36462 wxPyEndAllowThreads(__tstate);
36463 if (PyErr_Occurred()) SWIG_fail;
36464 }
36465 {
36466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36467 }
36468 return resultobj;
36469fail:
36470 return NULL;
36471}
36472
36473
36474SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36475 PyObject *resultobj = 0;
36476 wxWindow *arg1 = (wxWindow *) 0 ;
36477 wxWindow *arg2 = (wxWindow *) 0 ;
36478 void *argp1 = 0 ;
36479 int res1 = 0 ;
36480 void *argp2 = 0 ;
36481 int res2 = 0 ;
36482 PyObject * obj0 = 0 ;
36483 PyObject * obj1 = 0 ;
36484 char * kwnames[] = {
36485 (char *) "self",(char *) "child", NULL
36486 };
36487
36488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36490 if (!SWIG_IsOK(res1)) {
36491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36492 }
36493 arg1 = reinterpret_cast< wxWindow * >(argp1);
36494 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36495 if (!SWIG_IsOK(res2)) {
36496 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36497 }
36498 arg2 = reinterpret_cast< wxWindow * >(argp2);
36499 {
36500 PyThreadState* __tstate = wxPyBeginAllowThreads();
36501 (arg1)->AddChild(arg2);
36502 wxPyEndAllowThreads(__tstate);
36503 if (PyErr_Occurred()) SWIG_fail;
36504 }
36505 resultobj = SWIG_Py_Void();
36506 return resultobj;
36507fail:
36508 return NULL;
36509}
36510
36511
36512SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36513 PyObject *resultobj = 0;
36514 wxWindow *arg1 = (wxWindow *) 0 ;
36515 wxWindow *arg2 = (wxWindow *) 0 ;
36516 void *argp1 = 0 ;
36517 int res1 = 0 ;
36518 void *argp2 = 0 ;
36519 int res2 = 0 ;
36520 PyObject * obj0 = 0 ;
36521 PyObject * obj1 = 0 ;
36522 char * kwnames[] = {
36523 (char *) "self",(char *) "child", NULL
36524 };
36525
36526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36528 if (!SWIG_IsOK(res1)) {
36529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36530 }
36531 arg1 = reinterpret_cast< wxWindow * >(argp1);
36532 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36533 if (!SWIG_IsOK(res2)) {
36534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36535 }
36536 arg2 = reinterpret_cast< wxWindow * >(argp2);
36537 {
36538 PyThreadState* __tstate = wxPyBeginAllowThreads();
36539 (arg1)->RemoveChild(arg2);
36540 wxPyEndAllowThreads(__tstate);
36541 if (PyErr_Occurred()) SWIG_fail;
36542 }
36543 resultobj = SWIG_Py_Void();
36544 return resultobj;
36545fail:
36546 return NULL;
36547}
36548
36549
704eda0c
RD
36550SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36551 PyObject *resultobj = 0;
36552 wxWindow *arg1 = (wxWindow *) 0 ;
36553 bool arg2 ;
36554 void *argp1 = 0 ;
36555 int res1 = 0 ;
36556 bool val2 ;
36557 int ecode2 = 0 ;
36558 PyObject * obj0 = 0 ;
36559 PyObject * obj1 = 0 ;
36560 char * kwnames[] = {
36561 (char *) "self",(char *) "on", NULL
36562 };
36563
36564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36566 if (!SWIG_IsOK(res1)) {
36567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36568 }
36569 arg1 = reinterpret_cast< wxWindow * >(argp1);
36570 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36571 if (!SWIG_IsOK(ecode2)) {
36572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36573 }
36574 arg2 = static_cast< bool >(val2);
36575 {
36576 PyThreadState* __tstate = wxPyBeginAllowThreads();
36577 wxWindow_SetDoubleBuffered(arg1,arg2);
36578 wxPyEndAllowThreads(__tstate);
36579 if (PyErr_Occurred()) SWIG_fail;
36580 }
36581 resultobj = SWIG_Py_Void();
36582 return resultobj;
36583fail:
36584 return NULL;
36585}
36586
36587
1bd55598
RD
36588SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36589 PyObject *resultobj = 0;
36590 wxWindow *arg1 = (wxWindow *) 0 ;
36591 long arg2 ;
36592 wxWindow *result = 0 ;
36593 void *argp1 = 0 ;
36594 int res1 = 0 ;
36595 long val2 ;
36596 int ecode2 = 0 ;
36597 PyObject * obj0 = 0 ;
36598 PyObject * obj1 = 0 ;
36599 char * kwnames[] = {
36600 (char *) "self",(char *) "winid", NULL
36601 };
36602
36603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36605 if (!SWIG_IsOK(res1)) {
36606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36607 }
36608 arg1 = reinterpret_cast< wxWindow * >(argp1);
36609 ecode2 = SWIG_AsVal_long(obj1, &val2);
36610 if (!SWIG_IsOK(ecode2)) {
36611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36612 }
36613 arg2 = static_cast< long >(val2);
36614 {
36615 PyThreadState* __tstate = wxPyBeginAllowThreads();
36616 result = (wxWindow *)(arg1)->FindWindow(arg2);
36617 wxPyEndAllowThreads(__tstate);
36618 if (PyErr_Occurred()) SWIG_fail;
36619 }
36620 {
36621 resultobj = wxPyMake_wxObject(result, 0);
36622 }
36623 return resultobj;
36624fail:
36625 return NULL;
36626}
36627
36628
36629SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36630 PyObject *resultobj = 0;
36631 wxWindow *arg1 = (wxWindow *) 0 ;
36632 wxString *arg2 = 0 ;
36633 wxWindow *result = 0 ;
36634 void *argp1 = 0 ;
36635 int res1 = 0 ;
36636 bool temp2 = false ;
36637 PyObject * obj0 = 0 ;
36638 PyObject * obj1 = 0 ;
36639 char * kwnames[] = {
36640 (char *) "self",(char *) "name", NULL
36641 };
36642
36643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36645 if (!SWIG_IsOK(res1)) {
36646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36647 }
36648 arg1 = reinterpret_cast< wxWindow * >(argp1);
36649 {
36650 arg2 = wxString_in_helper(obj1);
36651 if (arg2 == NULL) SWIG_fail;
36652 temp2 = true;
36653 }
36654 {
36655 PyThreadState* __tstate = wxPyBeginAllowThreads();
36656 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36657 wxPyEndAllowThreads(__tstate);
36658 if (PyErr_Occurred()) SWIG_fail;
36659 }
36660 {
36661 resultobj = wxPyMake_wxObject(result, 0);
36662 }
36663 {
36664 if (temp2)
36665 delete arg2;
36666 }
36667 return resultobj;
36668fail:
36669 {
36670 if (temp2)
36671 delete arg2;
36672 }
36673 return NULL;
d55e5bfc
RD
36674}
36675
36676
1bd55598
RD
36677SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36678 PyObject *resultobj = 0;
36679 wxWindow *arg1 = (wxWindow *) 0 ;
36680 wxEvtHandler *result = 0 ;
36681 void *argp1 = 0 ;
36682 int res1 = 0 ;
36683 PyObject *swig_obj[1] ;
36684
36685 if (!args) SWIG_fail;
36686 swig_obj[0] = args;
36687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36688 if (!SWIG_IsOK(res1)) {
36689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36690 }
36691 arg1 = reinterpret_cast< wxWindow * >(argp1);
36692 {
36693 PyThreadState* __tstate = wxPyBeginAllowThreads();
36694 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36695 wxPyEndAllowThreads(__tstate);
36696 if (PyErr_Occurred()) SWIG_fail;
36697 }
36698 {
36699 resultobj = wxPyMake_wxObject(result, 0);
36700 }
36701 return resultobj;
36702fail:
36703 return NULL;
36704}
36705
36706
36707SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36708 PyObject *resultobj = 0;
36709 wxWindow *arg1 = (wxWindow *) 0 ;
36710 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36711 void *argp1 = 0 ;
36712 int res1 = 0 ;
36713 void *argp2 = 0 ;
36714 int res2 = 0 ;
36715 PyObject * obj0 = 0 ;
36716 PyObject * obj1 = 0 ;
36717 char * kwnames[] = {
36718 (char *) "self",(char *) "handler", NULL
36719 };
36720
36721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36723 if (!SWIG_IsOK(res1)) {
36724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36725 }
36726 arg1 = reinterpret_cast< wxWindow * >(argp1);
36727 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36728 if (!SWIG_IsOK(res2)) {
36729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36730 }
36731 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36732 {
36733 PyThreadState* __tstate = wxPyBeginAllowThreads();
36734 (arg1)->SetEventHandler(arg2);
36735 wxPyEndAllowThreads(__tstate);
36736 if (PyErr_Occurred()) SWIG_fail;
36737 }
36738 resultobj = SWIG_Py_Void();
36739 return resultobj;
36740fail:
36741 return NULL;
36742}
36743
36744
36745SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36746 PyObject *resultobj = 0;
36747 wxWindow *arg1 = (wxWindow *) 0 ;
36748 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36749 void *argp1 = 0 ;
36750 int res1 = 0 ;
36751 void *argp2 = 0 ;
36752 int res2 = 0 ;
36753 PyObject * obj0 = 0 ;
36754 PyObject * obj1 = 0 ;
36755 char * kwnames[] = {
36756 (char *) "self",(char *) "handler", NULL
36757 };
36758
36759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36761 if (!SWIG_IsOK(res1)) {
36762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36763 }
36764 arg1 = reinterpret_cast< wxWindow * >(argp1);
36765 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36766 if (!SWIG_IsOK(res2)) {
36767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36768 }
36769 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36770 {
36771 PyThreadState* __tstate = wxPyBeginAllowThreads();
36772 (arg1)->PushEventHandler(arg2);
36773 wxPyEndAllowThreads(__tstate);
36774 if (PyErr_Occurred()) SWIG_fail;
36775 }
36776 resultobj = SWIG_Py_Void();
36777 return resultobj;
36778fail:
36779 return NULL;
36780}
36781
36782
36783SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36784 PyObject *resultobj = 0;
36785 wxWindow *arg1 = (wxWindow *) 0 ;
36786 bool arg2 = (bool) false ;
36787 wxEvtHandler *result = 0 ;
36788 void *argp1 = 0 ;
36789 int res1 = 0 ;
36790 bool val2 ;
36791 int ecode2 = 0 ;
36792 PyObject * obj0 = 0 ;
36793 PyObject * obj1 = 0 ;
36794 char * kwnames[] = {
36795 (char *) "self",(char *) "deleteHandler", NULL
36796 };
36797
36798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36800 if (!SWIG_IsOK(res1)) {
36801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36802 }
36803 arg1 = reinterpret_cast< wxWindow * >(argp1);
36804 if (obj1) {
36805 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36806 if (!SWIG_IsOK(ecode2)) {
36807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36808 }
36809 arg2 = static_cast< bool >(val2);
36810 }
36811 {
36812 PyThreadState* __tstate = wxPyBeginAllowThreads();
36813 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36814 wxPyEndAllowThreads(__tstate);
36815 if (PyErr_Occurred()) SWIG_fail;
36816 }
36817 {
36818 resultobj = wxPyMake_wxObject(result, 0);
36819 }
36820 return resultobj;
36821fail:
36822 return NULL;
36823}
36824
36825
36826SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36827 PyObject *resultobj = 0;
36828 wxWindow *arg1 = (wxWindow *) 0 ;
36829 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36830 bool result;
36831 void *argp1 = 0 ;
36832 int res1 = 0 ;
36833 void *argp2 = 0 ;
36834 int res2 = 0 ;
36835 PyObject * obj0 = 0 ;
36836 PyObject * obj1 = 0 ;
36837 char * kwnames[] = {
36838 (char *) "self",(char *) "handler", NULL
36839 };
36840
36841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36843 if (!SWIG_IsOK(res1)) {
36844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36845 }
36846 arg1 = reinterpret_cast< wxWindow * >(argp1);
36847 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36848 if (!SWIG_IsOK(res2)) {
36849 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36850 }
36851 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36852 {
36853 PyThreadState* __tstate = wxPyBeginAllowThreads();
36854 result = (bool)(arg1)->RemoveEventHandler(arg2);
36855 wxPyEndAllowThreads(__tstate);
36856 if (PyErr_Occurred()) SWIG_fail;
36857 }
36858 {
36859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36860 }
36861 return resultobj;
36862fail:
36863 return NULL;
36864}
36865
36866
36867SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36868 PyObject *resultobj = 0;
36869 wxWindow *arg1 = (wxWindow *) 0 ;
36870 wxValidator *arg2 = 0 ;
36871 void *argp1 = 0 ;
36872 int res1 = 0 ;
36873 void *argp2 = 0 ;
36874 int res2 = 0 ;
36875 PyObject * obj0 = 0 ;
36876 PyObject * obj1 = 0 ;
36877 char * kwnames[] = {
36878 (char *) "self",(char *) "validator", NULL
36879 };
36880
36881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36883 if (!SWIG_IsOK(res1)) {
36884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36885 }
36886 arg1 = reinterpret_cast< wxWindow * >(argp1);
36887 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36888 if (!SWIG_IsOK(res2)) {
36889 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36890 }
36891 if (!argp2) {
36892 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36893 }
36894 arg2 = reinterpret_cast< wxValidator * >(argp2);
36895 {
36896 PyThreadState* __tstate = wxPyBeginAllowThreads();
36897 (arg1)->SetValidator((wxValidator const &)*arg2);
36898 wxPyEndAllowThreads(__tstate);
36899 if (PyErr_Occurred()) SWIG_fail;
36900 }
36901 resultobj = SWIG_Py_Void();
36902 return resultobj;
36903fail:
36904 return NULL;
d55e5bfc
RD
36905}
36906
36907
1bd55598
RD
36908SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36909 PyObject *resultobj = 0;
36910 wxWindow *arg1 = (wxWindow *) 0 ;
36911 wxValidator *result = 0 ;
36912 void *argp1 = 0 ;
36913 int res1 = 0 ;
36914 PyObject *swig_obj[1] ;
36915
36916 if (!args) SWIG_fail;
36917 swig_obj[0] = args;
36918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36919 if (!SWIG_IsOK(res1)) {
36920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36921 }
36922 arg1 = reinterpret_cast< wxWindow * >(argp1);
36923 {
36924 PyThreadState* __tstate = wxPyBeginAllowThreads();
36925 result = (wxValidator *)(arg1)->GetValidator();
36926 wxPyEndAllowThreads(__tstate);
36927 if (PyErr_Occurred()) SWIG_fail;
36928 }
36929 {
36930 resultobj = wxPyMake_wxObject(result, (bool)0);
36931 }
36932 return resultobj;
36933fail:
36934 return NULL;
d55e5bfc
RD
36935}
36936
36937
1bd55598
RD
36938SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36939 PyObject *resultobj = 0;
36940 wxWindow *arg1 = (wxWindow *) 0 ;
36941 bool result;
36942 void *argp1 = 0 ;
36943 int res1 = 0 ;
36944 PyObject *swig_obj[1] ;
36945
36946 if (!args) SWIG_fail;
36947 swig_obj[0] = args;
36948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36949 if (!SWIG_IsOK(res1)) {
36950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36951 }
36952 arg1 = reinterpret_cast< wxWindow * >(argp1);
36953 {
36954 PyThreadState* __tstate = wxPyBeginAllowThreads();
36955 result = (bool)(arg1)->Validate();
36956 wxPyEndAllowThreads(__tstate);
36957 if (PyErr_Occurred()) SWIG_fail;
36958 }
36959 {
36960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36961 }
36962 return resultobj;
36963fail:
36964 return NULL;
d55e5bfc
RD
36965}
36966
36967
1bd55598
RD
36968SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36969 PyObject *resultobj = 0;
36970 wxWindow *arg1 = (wxWindow *) 0 ;
36971 bool result;
36972 void *argp1 = 0 ;
36973 int res1 = 0 ;
36974 PyObject *swig_obj[1] ;
36975
36976 if (!args) SWIG_fail;
36977 swig_obj[0] = args;
36978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36979 if (!SWIG_IsOK(res1)) {
36980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36981 }
36982 arg1 = reinterpret_cast< wxWindow * >(argp1);
36983 {
36984 PyThreadState* __tstate = wxPyBeginAllowThreads();
36985 result = (bool)(arg1)->TransferDataToWindow();
36986 wxPyEndAllowThreads(__tstate);
36987 if (PyErr_Occurred()) SWIG_fail;
36988 }
36989 {
36990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36991 }
36992 return resultobj;
36993fail:
36994 return NULL;
d55e5bfc
RD
36995}
36996
36997
1bd55598
RD
36998SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36999 PyObject *resultobj = 0;
37000 wxWindow *arg1 = (wxWindow *) 0 ;
37001 bool result;
37002 void *argp1 = 0 ;
37003 int res1 = 0 ;
37004 PyObject *swig_obj[1] ;
37005
37006 if (!args) SWIG_fail;
37007 swig_obj[0] = args;
37008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37009 if (!SWIG_IsOK(res1)) {
37010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37011 }
37012 arg1 = reinterpret_cast< wxWindow * >(argp1);
37013 {
37014 PyThreadState* __tstate = wxPyBeginAllowThreads();
37015 result = (bool)(arg1)->TransferDataFromWindow();
37016 wxPyEndAllowThreads(__tstate);
37017 if (PyErr_Occurred()) SWIG_fail;
37018 }
37019 {
37020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37021 }
37022 return resultobj;
37023fail:
37024 return NULL;
d55e5bfc
RD
37025}
37026
37027
1bd55598
RD
37028SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37029 PyObject *resultobj = 0;
37030 wxWindow *arg1 = (wxWindow *) 0 ;
37031 void *argp1 = 0 ;
37032 int res1 = 0 ;
37033 PyObject *swig_obj[1] ;
37034
37035 if (!args) SWIG_fail;
37036 swig_obj[0] = args;
37037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37038 if (!SWIG_IsOK(res1)) {
37039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37040 }
37041 arg1 = reinterpret_cast< wxWindow * >(argp1);
37042 {
37043 PyThreadState* __tstate = wxPyBeginAllowThreads();
37044 (arg1)->InitDialog();
37045 wxPyEndAllowThreads(__tstate);
37046 if (PyErr_Occurred()) SWIG_fail;
37047 }
37048 resultobj = SWIG_Py_Void();
37049 return resultobj;
37050fail:
37051 return NULL;
37052}
37053
37054
37055SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37056 PyObject *resultobj = 0;
37057 wxWindow *arg1 = (wxWindow *) 0 ;
37058 wxAcceleratorTable *arg2 = 0 ;
37059 void *argp1 = 0 ;
37060 int res1 = 0 ;
37061 void *argp2 = 0 ;
37062 int res2 = 0 ;
37063 PyObject * obj0 = 0 ;
37064 PyObject * obj1 = 0 ;
37065 char * kwnames[] = {
37066 (char *) "self",(char *) "accel", NULL
37067 };
37068
37069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37071 if (!SWIG_IsOK(res1)) {
37072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37073 }
37074 arg1 = reinterpret_cast< wxWindow * >(argp1);
37075 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37076 if (!SWIG_IsOK(res2)) {
37077 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37078 }
37079 if (!argp2) {
37080 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37081 }
37082 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37083 {
37084 PyThreadState* __tstate = wxPyBeginAllowThreads();
37085 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37086 wxPyEndAllowThreads(__tstate);
37087 if (PyErr_Occurred()) SWIG_fail;
37088 }
37089 resultobj = SWIG_Py_Void();
37090 return resultobj;
37091fail:
37092 return NULL;
d55e5bfc
RD
37093}
37094
37095
1bd55598
RD
37096SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37097 PyObject *resultobj = 0;
37098 wxWindow *arg1 = (wxWindow *) 0 ;
37099 wxAcceleratorTable *result = 0 ;
37100 void *argp1 = 0 ;
37101 int res1 = 0 ;
37102 PyObject *swig_obj[1] ;
37103
37104 if (!args) SWIG_fail;
37105 swig_obj[0] = args;
37106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37107 if (!SWIG_IsOK(res1)) {
37108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37109 }
37110 arg1 = reinterpret_cast< wxWindow * >(argp1);
37111 {
37112 PyThreadState* __tstate = wxPyBeginAllowThreads();
37113 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37114 wxPyEndAllowThreads(__tstate);
37115 if (PyErr_Occurred()) SWIG_fail;
37116 }
37117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37118 return resultobj;
37119fail:
37120 return NULL;
37121}
37122
37123
37124SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37125 PyObject *resultobj = 0;
37126 wxWindow *arg1 = (wxWindow *) 0 ;
37127 int arg2 ;
37128 int arg3 ;
37129 int arg4 ;
37130 bool result;
37131 void *argp1 = 0 ;
37132 int res1 = 0 ;
37133 int val2 ;
37134 int ecode2 = 0 ;
37135 int val3 ;
37136 int ecode3 = 0 ;
37137 int val4 ;
37138 int ecode4 = 0 ;
37139 PyObject * obj0 = 0 ;
37140 PyObject * obj1 = 0 ;
37141 PyObject * obj2 = 0 ;
37142 PyObject * obj3 = 0 ;
37143 char * kwnames[] = {
37144 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37145 };
37146
37147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37149 if (!SWIG_IsOK(res1)) {
37150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37151 }
37152 arg1 = reinterpret_cast< wxWindow * >(argp1);
37153 ecode2 = SWIG_AsVal_int(obj1, &val2);
37154 if (!SWIG_IsOK(ecode2)) {
37155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37156 }
37157 arg2 = static_cast< int >(val2);
37158 ecode3 = SWIG_AsVal_int(obj2, &val3);
37159 if (!SWIG_IsOK(ecode3)) {
37160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37161 }
37162 arg3 = static_cast< int >(val3);
37163 ecode4 = SWIG_AsVal_int(obj3, &val4);
37164 if (!SWIG_IsOK(ecode4)) {
37165 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37166 }
37167 arg4 = static_cast< int >(val4);
37168 {
37169 PyThreadState* __tstate = wxPyBeginAllowThreads();
37170 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37171 wxPyEndAllowThreads(__tstate);
37172 if (PyErr_Occurred()) SWIG_fail;
37173 }
37174 {
37175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37176 }
37177 return resultobj;
37178fail:
37179 return NULL;
37180}
37181
37182
37183SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37184 PyObject *resultobj = 0;
37185 wxWindow *arg1 = (wxWindow *) 0 ;
37186 int arg2 ;
37187 bool result;
37188 void *argp1 = 0 ;
37189 int res1 = 0 ;
37190 int val2 ;
37191 int ecode2 = 0 ;
37192 PyObject * obj0 = 0 ;
37193 PyObject * obj1 = 0 ;
37194 char * kwnames[] = {
37195 (char *) "self",(char *) "hotkeyId", NULL
37196 };
37197
37198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37200 if (!SWIG_IsOK(res1)) {
37201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37202 }
37203 arg1 = reinterpret_cast< wxWindow * >(argp1);
37204 ecode2 = SWIG_AsVal_int(obj1, &val2);
37205 if (!SWIG_IsOK(ecode2)) {
37206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37207 }
37208 arg2 = static_cast< int >(val2);
37209 {
37210 PyThreadState* __tstate = wxPyBeginAllowThreads();
37211 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37212 wxPyEndAllowThreads(__tstate);
37213 if (PyErr_Occurred()) SWIG_fail;
37214 }
37215 {
37216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37217 }
37218 return resultobj;
37219fail:
37220 return NULL;
37221}
37222
37223
37224SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37225 PyObject *resultobj = 0;
37226 wxWindow *arg1 = (wxWindow *) 0 ;
37227 wxPoint *arg2 = 0 ;
37228 wxPoint result;
37229 void *argp1 = 0 ;
37230 int res1 = 0 ;
37231 wxPoint temp2 ;
37232 PyObject * obj0 = 0 ;
37233 PyObject * obj1 = 0 ;
37234 char * kwnames[] = {
37235 (char *) "self",(char *) "pt", NULL
37236 };
37237
37238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37240 if (!SWIG_IsOK(res1)) {
37241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37242 }
37243 arg1 = reinterpret_cast< wxWindow * >(argp1);
37244 {
37245 arg2 = &temp2;
37246 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37247 }
37248 {
37249 PyThreadState* __tstate = wxPyBeginAllowThreads();
37250 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37251 wxPyEndAllowThreads(__tstate);
37252 if (PyErr_Occurred()) SWIG_fail;
37253 }
37254 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37255 return resultobj;
37256fail:
37257 return NULL;
37258}
37259
37260
37261SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37262 PyObject *resultobj = 0;
37263 wxWindow *arg1 = (wxWindow *) 0 ;
37264 wxSize *arg2 = 0 ;
37265 wxSize result;
37266 void *argp1 = 0 ;
37267 int res1 = 0 ;
37268 wxSize temp2 ;
37269 PyObject * obj0 = 0 ;
37270 PyObject * obj1 = 0 ;
37271 char * kwnames[] = {
37272 (char *) "self",(char *) "sz", NULL
37273 };
37274
37275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37277 if (!SWIG_IsOK(res1)) {
37278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37279 }
37280 arg1 = reinterpret_cast< wxWindow * >(argp1);
37281 {
37282 arg2 = &temp2;
37283 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37284 }
37285 {
37286 PyThreadState* __tstate = wxPyBeginAllowThreads();
37287 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37288 wxPyEndAllowThreads(__tstate);
37289 if (PyErr_Occurred()) SWIG_fail;
37290 }
37291 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37292 return resultobj;
37293fail:
37294 return NULL;
37295}
37296
37297
37298SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37299 PyObject *resultobj = 0;
37300 wxWindow *arg1 = (wxWindow *) 0 ;
37301 wxPoint *arg2 = 0 ;
37302 wxPoint result;
37303 void *argp1 = 0 ;
37304 int res1 = 0 ;
37305 wxPoint temp2 ;
37306 PyObject * obj0 = 0 ;
37307 PyObject * obj1 = 0 ;
37308 char * kwnames[] = {
37309 (char *) "self",(char *) "pt", NULL
37310 };
37311
37312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37314 if (!SWIG_IsOK(res1)) {
37315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37316 }
37317 arg1 = reinterpret_cast< wxWindow * >(argp1);
37318 {
37319 arg2 = &temp2;
37320 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37321 }
37322 {
37323 PyThreadState* __tstate = wxPyBeginAllowThreads();
37324 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37325 wxPyEndAllowThreads(__tstate);
37326 if (PyErr_Occurred()) SWIG_fail;
37327 }
37328 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37329 return resultobj;
37330fail:
37331 return NULL;
37332}
37333
37334
37335SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37336 PyObject *resultobj = 0;
37337 wxWindow *arg1 = (wxWindow *) 0 ;
37338 wxSize *arg2 = 0 ;
37339 wxSize result;
37340 void *argp1 = 0 ;
37341 int res1 = 0 ;
37342 wxSize temp2 ;
37343 PyObject * obj0 = 0 ;
37344 PyObject * obj1 = 0 ;
37345 char * kwnames[] = {
37346 (char *) "self",(char *) "sz", NULL
37347 };
37348
37349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37351 if (!SWIG_IsOK(res1)) {
37352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37353 }
37354 arg1 = reinterpret_cast< wxWindow * >(argp1);
37355 {
37356 arg2 = &temp2;
37357 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37358 }
37359 {
37360 PyThreadState* __tstate = wxPyBeginAllowThreads();
37361 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37362 wxPyEndAllowThreads(__tstate);
37363 if (PyErr_Occurred()) SWIG_fail;
37364 }
37365 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37366 return resultobj;
37367fail:
37368 return NULL;
37369}
37370
37371
37372SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37373 PyObject *resultobj = 0;
37374 wxWindow *arg1 = (wxWindow *) 0 ;
37375 wxPoint *arg2 = 0 ;
37376 wxPoint result;
37377 void *argp1 = 0 ;
37378 int res1 = 0 ;
37379 wxPoint temp2 ;
37380 PyObject * obj0 = 0 ;
37381 PyObject * obj1 = 0 ;
37382 char * kwnames[] = {
37383 (char *) "self",(char *) "pt", NULL
37384 };
37385
37386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37388 if (!SWIG_IsOK(res1)) {
37389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37390 }
37391 arg1 = reinterpret_cast< wxWindow * >(argp1);
37392 {
37393 arg2 = &temp2;
37394 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37395 }
37396 {
37397 PyThreadState* __tstate = wxPyBeginAllowThreads();
37398 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37399 wxPyEndAllowThreads(__tstate);
37400 if (PyErr_Occurred()) SWIG_fail;
37401 }
37402 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37403 return resultobj;
37404fail:
37405 return NULL;
37406}
37407
37408
37409SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37410 PyObject *resultobj = 0;
37411 wxWindow *arg1 = (wxWindow *) 0 ;
37412 wxSize *arg2 = 0 ;
37413 wxSize result;
37414 void *argp1 = 0 ;
37415 int res1 = 0 ;
37416 wxSize temp2 ;
37417 PyObject * obj0 = 0 ;
37418 PyObject * obj1 = 0 ;
37419 char * kwnames[] = {
37420 (char *) "self",(char *) "sz", NULL
37421 };
37422
37423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37425 if (!SWIG_IsOK(res1)) {
37426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37427 }
37428 arg1 = reinterpret_cast< wxWindow * >(argp1);
37429 {
37430 arg2 = &temp2;
37431 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37432 }
37433 {
37434 PyThreadState* __tstate = wxPyBeginAllowThreads();
37435 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37436 wxPyEndAllowThreads(__tstate);
37437 if (PyErr_Occurred()) SWIG_fail;
37438 }
37439 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37440 return resultobj;
37441fail:
37442 return NULL;
37443}
37444
37445
37446SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37447 PyObject *resultobj = 0;
37448 wxWindow *arg1 = (wxWindow *) 0 ;
37449 int arg2 ;
37450 int arg3 ;
37451 void *argp1 = 0 ;
37452 int res1 = 0 ;
37453 int val2 ;
37454 int ecode2 = 0 ;
37455 int val3 ;
37456 int ecode3 = 0 ;
37457 PyObject * obj0 = 0 ;
37458 PyObject * obj1 = 0 ;
37459 PyObject * obj2 = 0 ;
37460 char * kwnames[] = {
37461 (char *) "self",(char *) "x",(char *) "y", NULL
37462 };
37463
37464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37466 if (!SWIG_IsOK(res1)) {
37467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37468 }
37469 arg1 = reinterpret_cast< wxWindow * >(argp1);
37470 ecode2 = SWIG_AsVal_int(obj1, &val2);
37471 if (!SWIG_IsOK(ecode2)) {
37472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37473 }
37474 arg2 = static_cast< int >(val2);
37475 ecode3 = SWIG_AsVal_int(obj2, &val3);
37476 if (!SWIG_IsOK(ecode3)) {
37477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37478 }
37479 arg3 = static_cast< int >(val3);
37480 {
37481 PyThreadState* __tstate = wxPyBeginAllowThreads();
37482 (arg1)->WarpPointer(arg2,arg3);
37483 wxPyEndAllowThreads(__tstate);
37484 if (PyErr_Occurred()) SWIG_fail;
37485 }
37486 resultobj = SWIG_Py_Void();
37487 return resultobj;
37488fail:
37489 return NULL;
d55e5bfc
RD
37490}
37491
37492
1bd55598
RD
37493SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37494 PyObject *resultobj = 0;
37495 wxWindow *arg1 = (wxWindow *) 0 ;
37496 void *argp1 = 0 ;
37497 int res1 = 0 ;
37498 PyObject *swig_obj[1] ;
37499
37500 if (!args) SWIG_fail;
37501 swig_obj[0] = args;
37502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37503 if (!SWIG_IsOK(res1)) {
37504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37505 }
37506 arg1 = reinterpret_cast< wxWindow * >(argp1);
37507 {
37508 PyThreadState* __tstate = wxPyBeginAllowThreads();
37509 (arg1)->CaptureMouse();
37510 wxPyEndAllowThreads(__tstate);
37511 if (PyErr_Occurred()) SWIG_fail;
37512 }
37513 resultobj = SWIG_Py_Void();
37514 return resultobj;
37515fail:
37516 return NULL;
d55e5bfc
RD
37517}
37518
37519
1bd55598
RD
37520SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37521 PyObject *resultobj = 0;
37522 wxWindow *arg1 = (wxWindow *) 0 ;
37523 void *argp1 = 0 ;
37524 int res1 = 0 ;
37525 PyObject *swig_obj[1] ;
37526
37527 if (!args) SWIG_fail;
37528 swig_obj[0] = args;
37529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37530 if (!SWIG_IsOK(res1)) {
37531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37532 }
37533 arg1 = reinterpret_cast< wxWindow * >(argp1);
37534 {
37535 PyThreadState* __tstate = wxPyBeginAllowThreads();
37536 (arg1)->ReleaseMouse();
37537 wxPyEndAllowThreads(__tstate);
37538 if (PyErr_Occurred()) SWIG_fail;
37539 }
37540 resultobj = SWIG_Py_Void();
37541 return resultobj;
37542fail:
37543 return NULL;
d55e5bfc
RD
37544}
37545
37546
1bd55598
RD
37547SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37548 PyObject *resultobj = 0;
37549 wxWindow *result = 0 ;
37550
37551 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37552 {
37553 if (!wxPyCheckForApp()) SWIG_fail;
37554 PyThreadState* __tstate = wxPyBeginAllowThreads();
37555 result = (wxWindow *)wxWindow::GetCapture();
37556 wxPyEndAllowThreads(__tstate);
37557 if (PyErr_Occurred()) SWIG_fail;
37558 }
37559 {
37560 resultobj = wxPyMake_wxObject(result, 0);
37561 }
37562 return resultobj;
37563fail:
37564 return NULL;
d55e5bfc
RD
37565}
37566
37567
1bd55598
RD
37568SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37569 PyObject *resultobj = 0;
37570 wxWindow *arg1 = (wxWindow *) 0 ;
37571 bool result;
37572 void *argp1 = 0 ;
37573 int res1 = 0 ;
37574 PyObject *swig_obj[1] ;
37575
37576 if (!args) SWIG_fail;
37577 swig_obj[0] = args;
37578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37579 if (!SWIG_IsOK(res1)) {
37580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37581 }
37582 arg1 = reinterpret_cast< wxWindow * >(argp1);
37583 {
37584 PyThreadState* __tstate = wxPyBeginAllowThreads();
37585 result = (bool)((wxWindow const *)arg1)->HasCapture();
37586 wxPyEndAllowThreads(__tstate);
37587 if (PyErr_Occurred()) SWIG_fail;
37588 }
37589 {
37590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37591 }
37592 return resultobj;
37593fail:
37594 return NULL;
37595}
37596
37597
37598SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37599 PyObject *resultobj = 0;
37600 wxWindow *arg1 = (wxWindow *) 0 ;
37601 bool arg2 = (bool) true ;
37602 wxRect *arg3 = (wxRect *) NULL ;
37603 void *argp1 = 0 ;
37604 int res1 = 0 ;
37605 bool val2 ;
37606 int ecode2 = 0 ;
37607 void *argp3 = 0 ;
37608 int res3 = 0 ;
37609 PyObject * obj0 = 0 ;
37610 PyObject * obj1 = 0 ;
37611 PyObject * obj2 = 0 ;
37612 char * kwnames[] = {
37613 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37614 };
37615
37616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37618 if (!SWIG_IsOK(res1)) {
37619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37620 }
37621 arg1 = reinterpret_cast< wxWindow * >(argp1);
37622 if (obj1) {
37623 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37624 if (!SWIG_IsOK(ecode2)) {
37625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37626 }
37627 arg2 = static_cast< bool >(val2);
37628 }
37629 if (obj2) {
37630 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37631 if (!SWIG_IsOK(res3)) {
37632 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
d55e5bfc 37633 }
1bd55598
RD
37634 arg3 = reinterpret_cast< wxRect * >(argp3);
37635 }
37636 {
37637 PyThreadState* __tstate = wxPyBeginAllowThreads();
37638 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37639 wxPyEndAllowThreads(__tstate);
37640 if (PyErr_Occurred()) SWIG_fail;
37641 }
37642 resultobj = SWIG_Py_Void();
37643 return resultobj;
37644fail:
37645 return NULL;
37646}
37647
37648
37649SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37650 PyObject *resultobj = 0;
37651 wxWindow *arg1 = (wxWindow *) 0 ;
37652 wxRect *arg2 = 0 ;
37653 bool arg3 = (bool) true ;
37654 void *argp1 = 0 ;
37655 int res1 = 0 ;
37656 wxRect temp2 ;
37657 bool val3 ;
37658 int ecode3 = 0 ;
37659 PyObject * obj0 = 0 ;
37660 PyObject * obj1 = 0 ;
37661 PyObject * obj2 = 0 ;
37662 char * kwnames[] = {
37663 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37664 };
37665
37666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37668 if (!SWIG_IsOK(res1)) {
37669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37670 }
37671 arg1 = reinterpret_cast< wxWindow * >(argp1);
37672 {
37673 arg2 = &temp2;
37674 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37675 }
37676 if (obj2) {
37677 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37678 if (!SWIG_IsOK(ecode3)) {
37679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37680 }
37681 arg3 = static_cast< bool >(val3);
37682 }
37683 {
37684 PyThreadState* __tstate = wxPyBeginAllowThreads();
37685 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37686 wxPyEndAllowThreads(__tstate);
37687 if (PyErr_Occurred()) SWIG_fail;
37688 }
37689 resultobj = SWIG_Py_Void();
37690 return resultobj;
37691fail:
37692 return NULL;
d55e5bfc
RD
37693}
37694
37695
1bd55598
RD
37696SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37697 PyObject *resultobj = 0;
37698 wxWindow *arg1 = (wxWindow *) 0 ;
37699 void *argp1 = 0 ;
37700 int res1 = 0 ;
37701 PyObject *swig_obj[1] ;
37702
37703 if (!args) SWIG_fail;
37704 swig_obj[0] = args;
37705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37706 if (!SWIG_IsOK(res1)) {
37707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37708 }
37709 arg1 = reinterpret_cast< wxWindow * >(argp1);
37710 {
37711 PyThreadState* __tstate = wxPyBeginAllowThreads();
37712 (arg1)->Update();
37713 wxPyEndAllowThreads(__tstate);
37714 if (PyErr_Occurred()) SWIG_fail;
37715 }
37716 resultobj = SWIG_Py_Void();
37717 return resultobj;
37718fail:
37719 return NULL;
d55e5bfc
RD
37720}
37721
37722
1bd55598
RD
37723SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37724 PyObject *resultobj = 0;
37725 wxWindow *arg1 = (wxWindow *) 0 ;
37726 void *argp1 = 0 ;
37727 int res1 = 0 ;
37728 PyObject *swig_obj[1] ;
37729
37730 if (!args) SWIG_fail;
37731 swig_obj[0] = args;
37732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37733 if (!SWIG_IsOK(res1)) {
37734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37735 }
37736 arg1 = reinterpret_cast< wxWindow * >(argp1);
37737 {
37738 PyThreadState* __tstate = wxPyBeginAllowThreads();
37739 (arg1)->ClearBackground();
37740 wxPyEndAllowThreads(__tstate);
37741 if (PyErr_Occurred()) SWIG_fail;
37742 }
37743 resultobj = SWIG_Py_Void();
37744 return resultobj;
37745fail:
37746 return NULL;
d55e5bfc
RD
37747}
37748
37749
1bd55598
RD
37750SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37751 PyObject *resultobj = 0;
37752 wxWindow *arg1 = (wxWindow *) 0 ;
37753 void *argp1 = 0 ;
37754 int res1 = 0 ;
37755 PyObject *swig_obj[1] ;
37756
37757 if (!args) SWIG_fail;
37758 swig_obj[0] = args;
37759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37760 if (!SWIG_IsOK(res1)) {
37761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37762 }
37763 arg1 = reinterpret_cast< wxWindow * >(argp1);
37764 {
37765 PyThreadState* __tstate = wxPyBeginAllowThreads();
37766 (arg1)->Freeze();
37767 wxPyEndAllowThreads(__tstate);
37768 if (PyErr_Occurred()) SWIG_fail;
37769 }
37770 resultobj = SWIG_Py_Void();
37771 return resultobj;
37772fail:
37773 return NULL;
68350608
RD
37774}
37775
37776
33d6fd3b
RD
37777SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37778 PyObject *resultobj = 0;
37779 wxWindow *arg1 = (wxWindow *) 0 ;
37780 bool result;
37781 void *argp1 = 0 ;
37782 int res1 = 0 ;
37783 PyObject *swig_obj[1] ;
37784
37785 if (!args) SWIG_fail;
37786 swig_obj[0] = args;
37787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37788 if (!SWIG_IsOK(res1)) {
37789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37790 }
37791 arg1 = reinterpret_cast< wxWindow * >(argp1);
37792 {
37793 PyThreadState* __tstate = wxPyBeginAllowThreads();
37794 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37795 wxPyEndAllowThreads(__tstate);
37796 if (PyErr_Occurred()) SWIG_fail;
37797 }
37798 {
37799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37800 }
37801 return resultobj;
37802fail:
37803 return NULL;
37804}
37805
37806
1bd55598
RD
37807SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37808 PyObject *resultobj = 0;
37809 wxWindow *arg1 = (wxWindow *) 0 ;
37810 void *argp1 = 0 ;
37811 int res1 = 0 ;
37812 PyObject *swig_obj[1] ;
37813
37814 if (!args) SWIG_fail;
37815 swig_obj[0] = args;
37816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37817 if (!SWIG_IsOK(res1)) {
37818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37819 }
37820 arg1 = reinterpret_cast< wxWindow * >(argp1);
37821 {
37822 PyThreadState* __tstate = wxPyBeginAllowThreads();
37823 (arg1)->Thaw();
37824 wxPyEndAllowThreads(__tstate);
37825 if (PyErr_Occurred()) SWIG_fail;
37826 }
37827 resultobj = SWIG_Py_Void();
37828 return resultobj;
37829fail:
37830 return NULL;
37831}
37832
37833
37834SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37835 PyObject *resultobj = 0;
37836 wxWindow *arg1 = (wxWindow *) 0 ;
37837 wxDC *arg2 = 0 ;
37838 void *argp1 = 0 ;
37839 int res1 = 0 ;
37840 void *argp2 = 0 ;
37841 int res2 = 0 ;
37842 PyObject * obj0 = 0 ;
37843 PyObject * obj1 = 0 ;
37844 char * kwnames[] = {
37845 (char *) "self",(char *) "dc", NULL
37846 };
37847
37848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37850 if (!SWIG_IsOK(res1)) {
37851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37852 }
37853 arg1 = reinterpret_cast< wxWindow * >(argp1);
37854 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37855 if (!SWIG_IsOK(res2)) {
37856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37857 }
37858 if (!argp2) {
37859 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37860 }
37861 arg2 = reinterpret_cast< wxDC * >(argp2);
37862 {
37863 PyThreadState* __tstate = wxPyBeginAllowThreads();
37864 (arg1)->PrepareDC(*arg2);
37865 wxPyEndAllowThreads(__tstate);
37866 if (PyErr_Occurred()) SWIG_fail;
37867 }
37868 resultobj = SWIG_Py_Void();
37869 return resultobj;
37870fail:
37871 return NULL;
68350608
RD
37872}
37873
37874
b39fe951
RD
37875SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37876 PyObject *resultobj = 0;
37877 wxWindow *arg1 = (wxWindow *) 0 ;
37878 bool result;
37879 void *argp1 = 0 ;
37880 int res1 = 0 ;
37881 PyObject *swig_obj[1] ;
37882
37883 if (!args) SWIG_fail;
37884 swig_obj[0] = args;
37885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37886 if (!SWIG_IsOK(res1)) {
37887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37888 }
37889 arg1 = reinterpret_cast< wxWindow * >(argp1);
37890 {
37891 PyThreadState* __tstate = wxPyBeginAllowThreads();
37892 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37893 wxPyEndAllowThreads(__tstate);
37894 if (PyErr_Occurred()) SWIG_fail;
37895 }
37896 {
37897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37898 }
37899 return resultobj;
37900fail:
37901 return NULL;
37902}
37903
37904
1bd55598
RD
37905SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37906 PyObject *resultobj = 0;
37907 wxWindow *arg1 = (wxWindow *) 0 ;
37908 wxRegion *result = 0 ;
37909 void *argp1 = 0 ;
37910 int res1 = 0 ;
37911 PyObject *swig_obj[1] ;
37912
37913 if (!args) SWIG_fail;
37914 swig_obj[0] = args;
37915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37916 if (!SWIG_IsOK(res1)) {
37917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37918 }
37919 arg1 = reinterpret_cast< wxWindow * >(argp1);
37920 {
37921 PyThreadState* __tstate = wxPyBeginAllowThreads();
908b74cd 37922 {
1bd55598
RD
37923 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37924 result = (wxRegion *) &_result_ref;
908b74cd 37925 }
1bd55598
RD
37926 wxPyEndAllowThreads(__tstate);
37927 if (PyErr_Occurred()) SWIG_fail;
37928 }
37929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37930 return resultobj;
37931fail:
37932 return NULL;
908b74cd
RD
37933}
37934
37935
1bd55598
RD
37936SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37937 PyObject *resultobj = 0;
37938 wxWindow *arg1 = (wxWindow *) 0 ;
37939 wxRect result;
37940 void *argp1 = 0 ;
37941 int res1 = 0 ;
37942 PyObject *swig_obj[1] ;
37943
37944 if (!args) SWIG_fail;
37945 swig_obj[0] = args;
37946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37947 if (!SWIG_IsOK(res1)) {
37948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37949 }
37950 arg1 = reinterpret_cast< wxWindow * >(argp1);
37951 {
37952 PyThreadState* __tstate = wxPyBeginAllowThreads();
37953 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37954 wxPyEndAllowThreads(__tstate);
37955 if (PyErr_Occurred()) SWIG_fail;
37956 }
37957 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37958 return resultobj;
37959fail:
37960 return NULL;
37961}
37962
37963
37964SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37965 PyObject *resultobj = 0;
37966 wxWindow *arg1 = (wxWindow *) 0 ;
37967 int arg2 ;
37968 int arg3 ;
37969 int arg4 = (int) 1 ;
37970 int arg5 = (int) 1 ;
37971 bool result;
37972 void *argp1 = 0 ;
37973 int res1 = 0 ;
37974 int val2 ;
37975 int ecode2 = 0 ;
37976 int val3 ;
37977 int ecode3 = 0 ;
37978 int val4 ;
37979 int ecode4 = 0 ;
37980 int val5 ;
37981 int ecode5 = 0 ;
37982 PyObject * obj0 = 0 ;
37983 PyObject * obj1 = 0 ;
37984 PyObject * obj2 = 0 ;
37985 PyObject * obj3 = 0 ;
37986 PyObject * obj4 = 0 ;
37987 char * kwnames[] = {
37988 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
37989 };
37990
37991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37993 if (!SWIG_IsOK(res1)) {
37994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
37995 }
37996 arg1 = reinterpret_cast< wxWindow * >(argp1);
37997 ecode2 = SWIG_AsVal_int(obj1, &val2);
37998 if (!SWIG_IsOK(ecode2)) {
37999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38000 }
38001 arg2 = static_cast< int >(val2);
38002 ecode3 = SWIG_AsVal_int(obj2, &val3);
38003 if (!SWIG_IsOK(ecode3)) {
38004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38005 }
38006 arg3 = static_cast< int >(val3);
38007 if (obj3) {
38008 ecode4 = SWIG_AsVal_int(obj3, &val4);
38009 if (!SWIG_IsOK(ecode4)) {
38010 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38011 }
38012 arg4 = static_cast< int >(val4);
38013 }
38014 if (obj4) {
38015 ecode5 = SWIG_AsVal_int(obj4, &val5);
38016 if (!SWIG_IsOK(ecode5)) {
38017 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38018 }
38019 arg5 = static_cast< int >(val5);
38020 }
38021 {
38022 PyThreadState* __tstate = wxPyBeginAllowThreads();
38023 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38024 wxPyEndAllowThreads(__tstate);
38025 if (PyErr_Occurred()) SWIG_fail;
38026 }
38027 {
38028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38029 }
38030 return resultobj;
38031fail:
38032 return NULL;
38033}
38034
38035
38036SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38037 PyObject *resultobj = 0;
38038 wxWindow *arg1 = (wxWindow *) 0 ;
38039 wxPoint *arg2 = 0 ;
38040 bool result;
38041 void *argp1 = 0 ;
38042 int res1 = 0 ;
38043 wxPoint temp2 ;
38044 PyObject * obj0 = 0 ;
38045 PyObject * obj1 = 0 ;
38046 char * kwnames[] = {
38047 (char *) "self",(char *) "pt", NULL
38048 };
38049
38050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38052 if (!SWIG_IsOK(res1)) {
38053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38054 }
38055 arg1 = reinterpret_cast< wxWindow * >(argp1);
38056 {
38057 arg2 = &temp2;
38058 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38059 }
38060 {
38061 PyThreadState* __tstate = wxPyBeginAllowThreads();
38062 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38063 wxPyEndAllowThreads(__tstate);
38064 if (PyErr_Occurred()) SWIG_fail;
38065 }
38066 {
38067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38068 }
38069 return resultobj;
38070fail:
38071 return NULL;
38072}
38073
38074
38075SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38076 PyObject *resultobj = 0;
38077 wxWindow *arg1 = (wxWindow *) 0 ;
38078 wxRect *arg2 = 0 ;
38079 bool result;
38080 void *argp1 = 0 ;
38081 int res1 = 0 ;
38082 wxRect temp2 ;
38083 PyObject * obj0 = 0 ;
38084 PyObject * obj1 = 0 ;
38085 char * kwnames[] = {
38086 (char *) "self",(char *) "rect", NULL
38087 };
38088
38089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38091 if (!SWIG_IsOK(res1)) {
38092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38093 }
38094 arg1 = reinterpret_cast< wxWindow * >(argp1);
38095 {
38096 arg2 = &temp2;
38097 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38098 }
38099 {
38100 PyThreadState* __tstate = wxPyBeginAllowThreads();
38101 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38102 wxPyEndAllowThreads(__tstate);
38103 if (PyErr_Occurred()) SWIG_fail;
38104 }
38105 {
38106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38107 }
38108 return resultobj;
38109fail:
38110 return NULL;
d55e5bfc
RD
38111}
38112
38113
1bd55598
RD
38114SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38115 PyObject *resultobj = 0;
38116 wxWindow *arg1 = (wxWindow *) 0 ;
38117 SwigValueWrapper<wxVisualAttributes > result;
38118 void *argp1 = 0 ;
38119 int res1 = 0 ;
38120 PyObject *swig_obj[1] ;
38121
38122 if (!args) SWIG_fail;
38123 swig_obj[0] = args;
38124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38125 if (!SWIG_IsOK(res1)) {
38126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38127 }
38128 arg1 = reinterpret_cast< wxWindow * >(argp1);
38129 {
38130 PyThreadState* __tstate = wxPyBeginAllowThreads();
38131 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38132 wxPyEndAllowThreads(__tstate);
38133 if (PyErr_Occurred()) SWIG_fail;
38134 }
38135 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38136 return resultobj;
38137fail:
38138 return NULL;
38139}
38140
38141
38142SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38143 PyObject *resultobj = 0;
38144 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38145 SwigValueWrapper<wxVisualAttributes > result;
38146 int val1 ;
38147 int ecode1 = 0 ;
38148 PyObject * obj0 = 0 ;
38149 char * kwnames[] = {
38150 (char *) "variant", NULL
38151 };
38152
38153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38154 if (obj0) {
38155 ecode1 = SWIG_AsVal_int(obj0, &val1);
38156 if (!SWIG_IsOK(ecode1)) {
38157 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38158 }
38159 arg1 = static_cast< wxWindowVariant >(val1);
38160 }
38161 {
38162 if (!wxPyCheckForApp()) SWIG_fail;
38163 PyThreadState* __tstate = wxPyBeginAllowThreads();
38164 result = wxWindow::GetClassDefaultAttributes(arg1);
38165 wxPyEndAllowThreads(__tstate);
38166 if (PyErr_Occurred()) SWIG_fail;
38167 }
38168 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38169 return resultobj;
38170fail:
38171 return NULL;
38172}
38173
38174
38175SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38176 PyObject *resultobj = 0;
38177 wxWindow *arg1 = (wxWindow *) 0 ;
38178 wxColour *arg2 = 0 ;
38179 bool result;
38180 void *argp1 = 0 ;
38181 int res1 = 0 ;
38182 wxColour temp2 ;
38183 PyObject * obj0 = 0 ;
38184 PyObject * obj1 = 0 ;
38185 char * kwnames[] = {
38186 (char *) "self",(char *) "colour", NULL
38187 };
38188
38189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38191 if (!SWIG_IsOK(res1)) {
38192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38193 }
38194 arg1 = reinterpret_cast< wxWindow * >(argp1);
38195 {
38196 arg2 = &temp2;
38197 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38198 }
38199 {
38200 PyThreadState* __tstate = wxPyBeginAllowThreads();
38201 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38202 wxPyEndAllowThreads(__tstate);
38203 if (PyErr_Occurred()) SWIG_fail;
38204 }
38205 {
38206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38207 }
38208 return resultobj;
38209fail:
38210 return NULL;
38211}
38212
38213
38214SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38215 PyObject *resultobj = 0;
38216 wxWindow *arg1 = (wxWindow *) 0 ;
38217 wxColour *arg2 = 0 ;
38218 void *argp1 = 0 ;
38219 int res1 = 0 ;
38220 wxColour temp2 ;
38221 PyObject * obj0 = 0 ;
38222 PyObject * obj1 = 0 ;
38223 char * kwnames[] = {
38224 (char *) "self",(char *) "colour", NULL
38225 };
38226
38227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38229 if (!SWIG_IsOK(res1)) {
38230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38231 }
38232 arg1 = reinterpret_cast< wxWindow * >(argp1);
38233 {
38234 arg2 = &temp2;
38235 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38236 }
38237 {
38238 PyThreadState* __tstate = wxPyBeginAllowThreads();
38239 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38240 wxPyEndAllowThreads(__tstate);
38241 if (PyErr_Occurred()) SWIG_fail;
38242 }
38243 resultobj = SWIG_Py_Void();
38244 return resultobj;
38245fail:
38246 return NULL;
38247}
38248
38249
38250SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38251 PyObject *resultobj = 0;
38252 wxWindow *arg1 = (wxWindow *) 0 ;
38253 wxColour *arg2 = 0 ;
38254 bool result;
38255 void *argp1 = 0 ;
38256 int res1 = 0 ;
38257 wxColour temp2 ;
38258 PyObject * obj0 = 0 ;
38259 PyObject * obj1 = 0 ;
38260 char * kwnames[] = {
38261 (char *) "self",(char *) "colour", NULL
38262 };
38263
38264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38266 if (!SWIG_IsOK(res1)) {
38267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38268 }
38269 arg1 = reinterpret_cast< wxWindow * >(argp1);
38270 {
38271 arg2 = &temp2;
38272 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38273 }
38274 {
38275 PyThreadState* __tstate = wxPyBeginAllowThreads();
38276 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38277 wxPyEndAllowThreads(__tstate);
38278 if (PyErr_Occurred()) SWIG_fail;
38279 }
38280 {
38281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38282 }
38283 return resultobj;
38284fail:
38285 return NULL;
38286}
38287
38288
38289SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38290 PyObject *resultobj = 0;
38291 wxWindow *arg1 = (wxWindow *) 0 ;
38292 wxColour *arg2 = 0 ;
38293 void *argp1 = 0 ;
38294 int res1 = 0 ;
38295 wxColour temp2 ;
38296 PyObject * obj0 = 0 ;
38297 PyObject * obj1 = 0 ;
38298 char * kwnames[] = {
38299 (char *) "self",(char *) "colour", NULL
38300 };
38301
38302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38304 if (!SWIG_IsOK(res1)) {
38305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38306 }
38307 arg1 = reinterpret_cast< wxWindow * >(argp1);
38308 {
38309 arg2 = &temp2;
38310 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38311 }
38312 {
38313 PyThreadState* __tstate = wxPyBeginAllowThreads();
38314 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38315 wxPyEndAllowThreads(__tstate);
38316 if (PyErr_Occurred()) SWIG_fail;
38317 }
38318 resultobj = SWIG_Py_Void();
38319 return resultobj;
38320fail:
38321 return NULL;
d55e5bfc
RD
38322}
38323
38324
1bd55598
RD
38325SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38326 PyObject *resultobj = 0;
38327 wxWindow *arg1 = (wxWindow *) 0 ;
38328 wxColour result;
38329 void *argp1 = 0 ;
38330 int res1 = 0 ;
38331 PyObject *swig_obj[1] ;
38332
38333 if (!args) SWIG_fail;
38334 swig_obj[0] = args;
38335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38336 if (!SWIG_IsOK(res1)) {
38337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38338 }
38339 arg1 = reinterpret_cast< wxWindow * >(argp1);
38340 {
38341 PyThreadState* __tstate = wxPyBeginAllowThreads();
38342 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38343 wxPyEndAllowThreads(__tstate);
38344 if (PyErr_Occurred()) SWIG_fail;
38345 }
38346 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38347 return resultobj;
38348fail:
38349 return NULL;
d55e5bfc
RD
38350}
38351
38352
1bd55598
RD
38353SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38354 PyObject *resultobj = 0;
38355 wxWindow *arg1 = (wxWindow *) 0 ;
38356 wxColour result;
38357 void *argp1 = 0 ;
38358 int res1 = 0 ;
38359 PyObject *swig_obj[1] ;
38360
38361 if (!args) SWIG_fail;
38362 swig_obj[0] = args;
38363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38364 if (!SWIG_IsOK(res1)) {
38365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38366 }
38367 arg1 = reinterpret_cast< wxWindow * >(argp1);
38368 {
38369 PyThreadState* __tstate = wxPyBeginAllowThreads();
38370 result = ((wxWindow const *)arg1)->GetForegroundColour();
38371 wxPyEndAllowThreads(__tstate);
38372 if (PyErr_Occurred()) SWIG_fail;
38373 }
38374 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38375 return resultobj;
38376fail:
38377 return NULL;
d55e5bfc
RD
38378}
38379
38380
1bd55598
RD
38381SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38382 PyObject *resultobj = 0;
38383 wxWindow *arg1 = (wxWindow *) 0 ;
38384 bool result;
38385 void *argp1 = 0 ;
38386 int res1 = 0 ;
38387 PyObject *swig_obj[1] ;
38388
38389 if (!args) SWIG_fail;
38390 swig_obj[0] = args;
38391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38392 if (!SWIG_IsOK(res1)) {
38393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38394 }
38395 arg1 = reinterpret_cast< wxWindow * >(argp1);
38396 {
38397 PyThreadState* __tstate = wxPyBeginAllowThreads();
38398 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38399 wxPyEndAllowThreads(__tstate);
38400 if (PyErr_Occurred()) SWIG_fail;
38401 }
38402 {
38403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38404 }
38405 return resultobj;
38406fail:
38407 return NULL;
d55e5bfc 38408}
1bd55598
RD
38409
38410
38411SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38412 PyObject *resultobj = 0;
38413 wxWindow *arg1 = (wxWindow *) 0 ;
38414 bool result;
38415 void *argp1 = 0 ;
38416 int res1 = 0 ;
38417 PyObject *swig_obj[1] ;
38418
38419 if (!args) SWIG_fail;
38420 swig_obj[0] = args;
38421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38422 if (!SWIG_IsOK(res1)) {
38423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38424 }
38425 arg1 = reinterpret_cast< wxWindow * >(argp1);
38426 {
38427 PyThreadState* __tstate = wxPyBeginAllowThreads();
38428 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38429 wxPyEndAllowThreads(__tstate);
38430 if (PyErr_Occurred()) SWIG_fail;
38431 }
38432 {
38433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38434 }
38435 return resultobj;
38436fail:
38437 return NULL;
38438}
38439
38440
38441SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38442 PyObject *resultobj = 0;
38443 wxWindow *arg1 = (wxWindow *) 0 ;
38444 wxBackgroundStyle arg2 ;
38445 bool result;
38446 void *argp1 = 0 ;
38447 int res1 = 0 ;
38448 int val2 ;
38449 int ecode2 = 0 ;
38450 PyObject * obj0 = 0 ;
38451 PyObject * obj1 = 0 ;
38452 char * kwnames[] = {
38453 (char *) "self",(char *) "style", NULL
38454 };
38455
38456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38458 if (!SWIG_IsOK(res1)) {
38459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38460 }
38461 arg1 = reinterpret_cast< wxWindow * >(argp1);
38462 ecode2 = SWIG_AsVal_int(obj1, &val2);
38463 if (!SWIG_IsOK(ecode2)) {
38464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38465 }
38466 arg2 = static_cast< wxBackgroundStyle >(val2);
38467 {
38468 PyThreadState* __tstate = wxPyBeginAllowThreads();
38469 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38470 wxPyEndAllowThreads(__tstate);
38471 if (PyErr_Occurred()) SWIG_fail;
38472 }
38473 {
38474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38475 }
38476 return resultobj;
38477fail:
38478 return NULL;
d55e5bfc
RD
38479}
38480
38481
1bd55598
RD
38482SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38483 PyObject *resultobj = 0;
38484 wxWindow *arg1 = (wxWindow *) 0 ;
38485 wxBackgroundStyle result;
38486 void *argp1 = 0 ;
38487 int res1 = 0 ;
38488 PyObject *swig_obj[1] ;
38489
38490 if (!args) SWIG_fail;
38491 swig_obj[0] = args;
38492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38493 if (!SWIG_IsOK(res1)) {
38494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38495 }
38496 arg1 = reinterpret_cast< wxWindow * >(argp1);
38497 {
38498 PyThreadState* __tstate = wxPyBeginAllowThreads();
38499 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38500 wxPyEndAllowThreads(__tstate);
38501 if (PyErr_Occurred()) SWIG_fail;
38502 }
38503 resultobj = SWIG_From_int(static_cast< int >(result));
38504 return resultobj;
38505fail:
38506 return NULL;
d55e5bfc
RD
38507}
38508
38509
1bd55598
RD
38510SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38511 PyObject *resultobj = 0;
38512 wxWindow *arg1 = (wxWindow *) 0 ;
38513 bool result;
38514 void *argp1 = 0 ;
38515 int res1 = 0 ;
38516 PyObject *swig_obj[1] ;
38517
38518 if (!args) SWIG_fail;
38519 swig_obj[0] = args;
38520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38521 if (!SWIG_IsOK(res1)) {
38522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38523 }
38524 arg1 = reinterpret_cast< wxWindow * >(argp1);
38525 {
38526 PyThreadState* __tstate = wxPyBeginAllowThreads();
38527 result = (bool)(arg1)->HasTransparentBackground();
38528 wxPyEndAllowThreads(__tstate);
38529 if (PyErr_Occurred()) SWIG_fail;
38530 }
38531 {
38532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38533 }
38534 return resultobj;
38535fail:
38536 return NULL;
38537}
38538
38539
38540SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38541 PyObject *resultobj = 0;
38542 wxWindow *arg1 = (wxWindow *) 0 ;
38543 wxCursor *arg2 = 0 ;
38544 bool result;
38545 void *argp1 = 0 ;
38546 int res1 = 0 ;
38547 void *argp2 = 0 ;
38548 int res2 = 0 ;
38549 PyObject * obj0 = 0 ;
38550 PyObject * obj1 = 0 ;
38551 char * kwnames[] = {
38552 (char *) "self",(char *) "cursor", NULL
38553 };
38554
38555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38557 if (!SWIG_IsOK(res1)) {
38558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38559 }
38560 arg1 = reinterpret_cast< wxWindow * >(argp1);
38561 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38562 if (!SWIG_IsOK(res2)) {
38563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38564 }
38565 if (!argp2) {
38566 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38567 }
38568 arg2 = reinterpret_cast< wxCursor * >(argp2);
38569 {
38570 PyThreadState* __tstate = wxPyBeginAllowThreads();
38571 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38572 wxPyEndAllowThreads(__tstate);
38573 if (PyErr_Occurred()) SWIG_fail;
38574 }
38575 {
38576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38577 }
38578 return resultobj;
38579fail:
38580 return NULL;
d55e5bfc
RD
38581}
38582
38583
1bd55598
RD
38584SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38585 PyObject *resultobj = 0;
38586 wxWindow *arg1 = (wxWindow *) 0 ;
38587 wxCursor result;
38588 void *argp1 = 0 ;
38589 int res1 = 0 ;
38590 PyObject *swig_obj[1] ;
38591
38592 if (!args) SWIG_fail;
38593 swig_obj[0] = args;
38594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38595 if (!SWIG_IsOK(res1)) {
38596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38597 }
38598 arg1 = reinterpret_cast< wxWindow * >(argp1);
38599 {
38600 PyThreadState* __tstate = wxPyBeginAllowThreads();
38601 result = (arg1)->GetCursor();
38602 wxPyEndAllowThreads(__tstate);
38603 if (PyErr_Occurred()) SWIG_fail;
38604 }
38605 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38606 return resultobj;
38607fail:
38608 return NULL;
38609}
38610
38611
38612SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38613 PyObject *resultobj = 0;
38614 wxWindow *arg1 = (wxWindow *) 0 ;
38615 wxFont *arg2 = 0 ;
38616 bool result;
38617 void *argp1 = 0 ;
38618 int res1 = 0 ;
38619 void *argp2 = 0 ;
38620 int res2 = 0 ;
38621 PyObject * obj0 = 0 ;
38622 PyObject * obj1 = 0 ;
38623 char * kwnames[] = {
38624 (char *) "self",(char *) "font", NULL
38625 };
38626
38627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38629 if (!SWIG_IsOK(res1)) {
38630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38631 }
38632 arg1 = reinterpret_cast< wxWindow * >(argp1);
38633 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38634 if (!SWIG_IsOK(res2)) {
38635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38636 }
38637 if (!argp2) {
38638 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38639 }
38640 arg2 = reinterpret_cast< wxFont * >(argp2);
38641 {
38642 PyThreadState* __tstate = wxPyBeginAllowThreads();
38643 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38644 wxPyEndAllowThreads(__tstate);
38645 if (PyErr_Occurred()) SWIG_fail;
38646 }
38647 {
38648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38649 }
38650 return resultobj;
38651fail:
38652 return NULL;
38653}
38654
38655
38656SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38657 PyObject *resultobj = 0;
38658 wxWindow *arg1 = (wxWindow *) 0 ;
38659 wxFont *arg2 = 0 ;
38660 void *argp1 = 0 ;
38661 int res1 = 0 ;
38662 void *argp2 = 0 ;
38663 int res2 = 0 ;
38664 PyObject * obj0 = 0 ;
38665 PyObject * obj1 = 0 ;
38666 char * kwnames[] = {
38667 (char *) "self",(char *) "font", NULL
38668 };
38669
38670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38672 if (!SWIG_IsOK(res1)) {
38673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38674 }
38675 arg1 = reinterpret_cast< wxWindow * >(argp1);
38676 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38677 if (!SWIG_IsOK(res2)) {
38678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38679 }
38680 if (!argp2) {
38681 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38682 }
38683 arg2 = reinterpret_cast< wxFont * >(argp2);
38684 {
38685 PyThreadState* __tstate = wxPyBeginAllowThreads();
38686 (arg1)->SetOwnFont((wxFont const &)*arg2);
38687 wxPyEndAllowThreads(__tstate);
38688 if (PyErr_Occurred()) SWIG_fail;
38689 }
38690 resultobj = SWIG_Py_Void();
38691 return resultobj;
38692fail:
38693 return NULL;
d55e5bfc
RD
38694}
38695
38696
1bd55598
RD
38697SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38698 PyObject *resultobj = 0;
38699 wxWindow *arg1 = (wxWindow *) 0 ;
38700 wxFont result;
38701 void *argp1 = 0 ;
38702 int res1 = 0 ;
38703 PyObject *swig_obj[1] ;
38704
38705 if (!args) SWIG_fail;
38706 swig_obj[0] = args;
38707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38708 if (!SWIG_IsOK(res1)) {
38709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38710 }
38711 arg1 = reinterpret_cast< wxWindow * >(argp1);
38712 {
38713 PyThreadState* __tstate = wxPyBeginAllowThreads();
38714 result = (arg1)->GetFont();
38715 wxPyEndAllowThreads(__tstate);
38716 if (PyErr_Occurred()) SWIG_fail;
38717 }
38718 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38719 return resultobj;
38720fail:
38721 return NULL;
38722}
38723
38724
38725SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38726 PyObject *resultobj = 0;
38727 wxWindow *arg1 = (wxWindow *) 0 ;
38728 wxCaret *arg2 = (wxCaret *) 0 ;
38729 void *argp1 = 0 ;
38730 int res1 = 0 ;
38731 int res2 = 0 ;
38732 PyObject * obj0 = 0 ;
38733 PyObject * obj1 = 0 ;
38734 char * kwnames[] = {
38735 (char *) "self",(char *) "caret", NULL
38736 };
38737
38738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38740 if (!SWIG_IsOK(res1)) {
38741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38742 }
38743 arg1 = reinterpret_cast< wxWindow * >(argp1);
38744 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38745 if (!SWIG_IsOK(res2)) {
38746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38747 }
38748 {
38749 PyThreadState* __tstate = wxPyBeginAllowThreads();
38750 (arg1)->SetCaret(arg2);
38751 wxPyEndAllowThreads(__tstate);
38752 if (PyErr_Occurred()) SWIG_fail;
38753 }
38754 resultobj = SWIG_Py_Void();
38755 return resultobj;
38756fail:
38757 return NULL;
d55e5bfc
RD
38758}
38759
38760
1bd55598
RD
38761SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38762 PyObject *resultobj = 0;
38763 wxWindow *arg1 = (wxWindow *) 0 ;
38764 wxCaret *result = 0 ;
38765 void *argp1 = 0 ;
38766 int res1 = 0 ;
38767 PyObject *swig_obj[1] ;
38768
38769 if (!args) SWIG_fail;
38770 swig_obj[0] = args;
38771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38772 if (!SWIG_IsOK(res1)) {
38773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38774 }
38775 arg1 = reinterpret_cast< wxWindow * >(argp1);
38776 {
38777 PyThreadState* __tstate = wxPyBeginAllowThreads();
38778 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38779 wxPyEndAllowThreads(__tstate);
38780 if (PyErr_Occurred()) SWIG_fail;
38781 }
38782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38783 return resultobj;
38784fail:
38785 return NULL;
d55e5bfc 38786}
1bd55598
RD
38787
38788
38789SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38790 PyObject *resultobj = 0;
38791 wxWindow *arg1 = (wxWindow *) 0 ;
38792 int result;
38793 void *argp1 = 0 ;
38794 int res1 = 0 ;
38795 PyObject *swig_obj[1] ;
38796
38797 if (!args) SWIG_fail;
38798 swig_obj[0] = args;
38799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38800 if (!SWIG_IsOK(res1)) {
38801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38802 }
38803 arg1 = reinterpret_cast< wxWindow * >(argp1);
38804 {
38805 PyThreadState* __tstate = wxPyBeginAllowThreads();
38806 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38807 wxPyEndAllowThreads(__tstate);
38808 if (PyErr_Occurred()) SWIG_fail;
38809 }
38810 resultobj = SWIG_From_int(static_cast< int >(result));
38811 return resultobj;
38812fail:
38813 return NULL;
d55e5bfc
RD
38814}
38815
38816
1bd55598
RD
38817SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38818 PyObject *resultobj = 0;
38819 wxWindow *arg1 = (wxWindow *) 0 ;
38820 int result;
38821 void *argp1 = 0 ;
38822 int res1 = 0 ;
38823 PyObject *swig_obj[1] ;
38824
38825 if (!args) SWIG_fail;
38826 swig_obj[0] = args;
38827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38828 if (!SWIG_IsOK(res1)) {
38829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38830 }
38831 arg1 = reinterpret_cast< wxWindow * >(argp1);
38832 {
38833 PyThreadState* __tstate = wxPyBeginAllowThreads();
38834 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38835 wxPyEndAllowThreads(__tstate);
38836 if (PyErr_Occurred()) SWIG_fail;
38837 }
38838 resultobj = SWIG_From_int(static_cast< int >(result));
38839 return resultobj;
38840fail:
38841 return NULL;
38842}
38843
38844
38845SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38846 PyObject *resultobj = 0;
38847 wxWindow *arg1 = (wxWindow *) 0 ;
38848 wxString *arg2 = 0 ;
38849 int *arg3 = (int *) 0 ;
38850 int *arg4 = (int *) 0 ;
38851 void *argp1 = 0 ;
38852 int res1 = 0 ;
38853 bool temp2 = false ;
38854 int temp3 ;
38855 int res3 = SWIG_TMPOBJ ;
38856 int temp4 ;
38857 int res4 = SWIG_TMPOBJ ;
38858 PyObject * obj0 = 0 ;
38859 PyObject * obj1 = 0 ;
38860 char * kwnames[] = {
38861 (char *) "self",(char *) "string", NULL
38862 };
38863
38864 arg3 = &temp3;
38865 arg4 = &temp4;
38866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38868 if (!SWIG_IsOK(res1)) {
38869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38870 }
38871 arg1 = reinterpret_cast< wxWindow * >(argp1);
38872 {
38873 arg2 = wxString_in_helper(obj1);
38874 if (arg2 == NULL) SWIG_fail;
38875 temp2 = true;
38876 }
38877 {
38878 PyThreadState* __tstate = wxPyBeginAllowThreads();
38879 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38880 wxPyEndAllowThreads(__tstate);
38881 if (PyErr_Occurred()) SWIG_fail;
38882 }
38883 resultobj = SWIG_Py_Void();
38884 if (SWIG_IsTmpObj(res3)) {
38885 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38886 } else {
38887 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38888 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38889 }
38890 if (SWIG_IsTmpObj(res4)) {
38891 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38892 } else {
38893 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38894 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38895 }
38896 {
38897 if (temp2)
38898 delete arg2;
38899 }
38900 return resultobj;
38901fail:
38902 {
38903 if (temp2)
38904 delete arg2;
38905 }
38906 return NULL;
38907}
38908
38909
38910SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38911 PyObject *resultobj = 0;
38912 wxWindow *arg1 = (wxWindow *) 0 ;
38913 wxString *arg2 = 0 ;
38914 int *arg3 = (int *) 0 ;
38915 int *arg4 = (int *) 0 ;
38916 int *arg5 = (int *) 0 ;
38917 int *arg6 = (int *) 0 ;
38918 wxFont *arg7 = (wxFont *) NULL ;
38919 void *argp1 = 0 ;
38920 int res1 = 0 ;
38921 bool temp2 = false ;
38922 int temp3 ;
38923 int res3 = SWIG_TMPOBJ ;
38924 int temp4 ;
38925 int res4 = SWIG_TMPOBJ ;
38926 int temp5 ;
38927 int res5 = SWIG_TMPOBJ ;
38928 int temp6 ;
38929 int res6 = SWIG_TMPOBJ ;
38930 void *argp7 = 0 ;
38931 int res7 = 0 ;
38932 PyObject * obj0 = 0 ;
38933 PyObject * obj1 = 0 ;
38934 PyObject * obj2 = 0 ;
38935 char * kwnames[] = {
38936 (char *) "self",(char *) "string",(char *) "font", NULL
38937 };
38938
38939 arg3 = &temp3;
38940 arg4 = &temp4;
38941 arg5 = &temp5;
38942 arg6 = &temp6;
38943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38945 if (!SWIG_IsOK(res1)) {
38946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38947 }
38948 arg1 = reinterpret_cast< wxWindow * >(argp1);
38949 {
38950 arg2 = wxString_in_helper(obj1);
38951 if (arg2 == NULL) SWIG_fail;
38952 temp2 = true;
38953 }
38954 if (obj2) {
38955 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38956 if (!SWIG_IsOK(res7)) {
38957 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
d55e5bfc 38958 }
1bd55598
RD
38959 arg7 = reinterpret_cast< wxFont * >(argp7);
38960 }
38961 {
38962 PyThreadState* __tstate = wxPyBeginAllowThreads();
38963 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38964 wxPyEndAllowThreads(__tstate);
38965 if (PyErr_Occurred()) SWIG_fail;
38966 }
38967 resultobj = SWIG_Py_Void();
38968 if (SWIG_IsTmpObj(res3)) {
38969 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38970 } else {
38971 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38973 }
38974 if (SWIG_IsTmpObj(res4)) {
38975 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38976 } else {
38977 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38978 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38979 }
38980 if (SWIG_IsTmpObj(res5)) {
38981 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
38982 } else {
38983 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38984 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
38985 }
38986 if (SWIG_IsTmpObj(res6)) {
38987 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
38988 } else {
38989 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38990 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
38991 }
38992 {
38993 if (temp2)
38994 delete arg2;
38995 }
38996 return resultobj;
38997fail:
38998 {
38999 if (temp2)
39000 delete arg2;
39001 }
39002 return NULL;
39003}
39004
39005
39006SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39007 PyObject *resultobj = 0;
39008 wxWindow *arg1 = (wxWindow *) 0 ;
39009 int *arg2 = (int *) 0 ;
39010 int *arg3 = (int *) 0 ;
39011 void *argp1 = 0 ;
39012 int res1 = 0 ;
39013 int temp2 ;
39014 int res2 = 0 ;
39015 int temp3 ;
39016 int res3 = 0 ;
39017 PyObject * obj0 = 0 ;
39018 PyObject * obj1 = 0 ;
39019 PyObject * obj2 = 0 ;
39020 char * kwnames[] = {
39021 (char *) "self",(char *) "x",(char *) "y", NULL
39022 };
39023
39024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39026 if (!SWIG_IsOK(res1)) {
39027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39028 }
39029 arg1 = reinterpret_cast< wxWindow * >(argp1);
39030 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39031 int val;
39032 int ecode = SWIG_AsVal_int(obj1, &val);
39033 if (!SWIG_IsOK(ecode)) {
39034 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39035 }
39036 temp2 = static_cast< int >(val);
39037 arg2 = &temp2;
39038 res2 = SWIG_AddTmpMask(ecode);
39039 }
39040 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39041 int val;
39042 int ecode = SWIG_AsVal_int(obj2, &val);
39043 if (!SWIG_IsOK(ecode)) {
39044 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39045 }
39046 temp3 = static_cast< int >(val);
39047 arg3 = &temp3;
39048 res3 = SWIG_AddTmpMask(ecode);
39049 }
39050 {
39051 PyThreadState* __tstate = wxPyBeginAllowThreads();
39052 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39053 wxPyEndAllowThreads(__tstate);
39054 if (PyErr_Occurred()) SWIG_fail;
39055 }
39056 resultobj = SWIG_Py_Void();
39057 if (SWIG_IsTmpObj(res2)) {
39058 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39059 } else {
39060 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39061 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39062 }
39063 if (SWIG_IsTmpObj(res3)) {
39064 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39065 } else {
39066 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39067 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39068 }
39069 return resultobj;
39070fail:
39071 return NULL;
39072}
39073
39074
39075SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39076 PyObject *resultobj = 0;
39077 wxWindow *arg1 = (wxWindow *) 0 ;
39078 int *arg2 = (int *) 0 ;
39079 int *arg3 = (int *) 0 ;
39080 void *argp1 = 0 ;
39081 int res1 = 0 ;
39082 int temp2 ;
39083 int res2 = 0 ;
39084 int temp3 ;
39085 int res3 = 0 ;
39086 PyObject * obj0 = 0 ;
39087 PyObject * obj1 = 0 ;
39088 PyObject * obj2 = 0 ;
39089 char * kwnames[] = {
39090 (char *) "self",(char *) "x",(char *) "y", NULL
39091 };
39092
39093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39095 if (!SWIG_IsOK(res1)) {
39096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39097 }
39098 arg1 = reinterpret_cast< wxWindow * >(argp1);
39099 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39100 int val;
39101 int ecode = SWIG_AsVal_int(obj1, &val);
39102 if (!SWIG_IsOK(ecode)) {
39103 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39104 }
39105 temp2 = static_cast< int >(val);
39106 arg2 = &temp2;
39107 res2 = SWIG_AddTmpMask(ecode);
39108 }
39109 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39110 int val;
39111 int ecode = SWIG_AsVal_int(obj2, &val);
39112 if (!SWIG_IsOK(ecode)) {
39113 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39114 }
39115 temp3 = static_cast< int >(val);
39116 arg3 = &temp3;
39117 res3 = SWIG_AddTmpMask(ecode);
39118 }
39119 {
39120 PyThreadState* __tstate = wxPyBeginAllowThreads();
39121 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39122 wxPyEndAllowThreads(__tstate);
39123 if (PyErr_Occurred()) SWIG_fail;
39124 }
39125 resultobj = SWIG_Py_Void();
39126 if (SWIG_IsTmpObj(res2)) {
39127 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39128 } else {
39129 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39130 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39131 }
39132 if (SWIG_IsTmpObj(res3)) {
39133 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39134 } else {
39135 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39136 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39137 }
39138 return resultobj;
39139fail:
39140 return NULL;
39141}
39142
39143
39144SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39145 PyObject *resultobj = 0;
39146 wxWindow *arg1 = (wxWindow *) 0 ;
39147 wxPoint *arg2 = 0 ;
39148 wxPoint result;
39149 void *argp1 = 0 ;
39150 int res1 = 0 ;
39151 wxPoint temp2 ;
39152 PyObject * obj0 = 0 ;
39153 PyObject * obj1 = 0 ;
39154 char * kwnames[] = {
39155 (char *) "self",(char *) "pt", NULL
39156 };
39157
39158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39160 if (!SWIG_IsOK(res1)) {
39161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39162 }
39163 arg1 = reinterpret_cast< wxWindow * >(argp1);
39164 {
39165 arg2 = &temp2;
39166 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39167 }
39168 {
39169 PyThreadState* __tstate = wxPyBeginAllowThreads();
39170 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39171 wxPyEndAllowThreads(__tstate);
39172 if (PyErr_Occurred()) SWIG_fail;
39173 }
39174 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39175 return resultobj;
39176fail:
39177 return NULL;
39178}
39179
39180
39181SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39182 PyObject *resultobj = 0;
39183 wxWindow *arg1 = (wxWindow *) 0 ;
39184 wxPoint *arg2 = 0 ;
39185 wxPoint result;
39186 void *argp1 = 0 ;
39187 int res1 = 0 ;
39188 wxPoint temp2 ;
39189 PyObject * obj0 = 0 ;
39190 PyObject * obj1 = 0 ;
39191 char * kwnames[] = {
39192 (char *) "self",(char *) "pt", NULL
39193 };
39194
39195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39197 if (!SWIG_IsOK(res1)) {
39198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39199 }
39200 arg1 = reinterpret_cast< wxWindow * >(argp1);
39201 {
39202 arg2 = &temp2;
39203 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39204 }
39205 {
39206 PyThreadState* __tstate = wxPyBeginAllowThreads();
39207 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39208 wxPyEndAllowThreads(__tstate);
39209 if (PyErr_Occurred()) SWIG_fail;
39210 }
39211 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39212 return resultobj;
39213fail:
39214 return NULL;
39215}
39216
39217
39218SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39219 PyObject *resultobj = 0;
39220 wxWindow *arg1 = (wxWindow *) 0 ;
39221 int arg2 ;
39222 int arg3 ;
39223 wxHitTest result;
39224 void *argp1 = 0 ;
39225 int res1 = 0 ;
39226 int val2 ;
39227 int ecode2 = 0 ;
39228 int val3 ;
39229 int ecode3 = 0 ;
39230 PyObject * obj0 = 0 ;
39231 PyObject * obj1 = 0 ;
39232 PyObject * obj2 = 0 ;
39233 char * kwnames[] = {
39234 (char *) "self",(char *) "x",(char *) "y", NULL
39235 };
39236
39237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39239 if (!SWIG_IsOK(res1)) {
39240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39241 }
39242 arg1 = reinterpret_cast< wxWindow * >(argp1);
39243 ecode2 = SWIG_AsVal_int(obj1, &val2);
39244 if (!SWIG_IsOK(ecode2)) {
39245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39246 }
39247 arg2 = static_cast< int >(val2);
39248 ecode3 = SWIG_AsVal_int(obj2, &val3);
39249 if (!SWIG_IsOK(ecode3)) {
39250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39251 }
39252 arg3 = static_cast< int >(val3);
39253 {
39254 PyThreadState* __tstate = wxPyBeginAllowThreads();
39255 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39256 wxPyEndAllowThreads(__tstate);
39257 if (PyErr_Occurred()) SWIG_fail;
39258 }
39259 resultobj = SWIG_From_int(static_cast< int >(result));
39260 return resultobj;
39261fail:
39262 return NULL;
39263}
39264
39265
39266SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39267 PyObject *resultobj = 0;
39268 wxWindow *arg1 = (wxWindow *) 0 ;
39269 wxPoint *arg2 = 0 ;
39270 wxHitTest result;
39271 void *argp1 = 0 ;
39272 int res1 = 0 ;
39273 wxPoint temp2 ;
39274 PyObject * obj0 = 0 ;
39275 PyObject * obj1 = 0 ;
39276 char * kwnames[] = {
39277 (char *) "self",(char *) "pt", NULL
39278 };
39279
39280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39282 if (!SWIG_IsOK(res1)) {
39283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39284 }
39285 arg1 = reinterpret_cast< wxWindow * >(argp1);
39286 {
39287 arg2 = &temp2;
39288 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39289 }
39290 {
39291 PyThreadState* __tstate = wxPyBeginAllowThreads();
39292 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39293 wxPyEndAllowThreads(__tstate);
39294 if (PyErr_Occurred()) SWIG_fail;
39295 }
39296 resultobj = SWIG_From_int(static_cast< int >(result));
39297 return resultobj;
39298fail:
39299 return NULL;
39300}
39301
39302
39303SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39304 PyObject *resultobj = 0;
39305 wxWindow *arg1 = (wxWindow *) 0 ;
39306 long arg2 ;
39307 wxBorder result;
39308 void *argp1 = 0 ;
39309 int res1 = 0 ;
39310 long val2 ;
39311 int ecode2 = 0 ;
39312
39313 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39315 if (!SWIG_IsOK(res1)) {
39316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39317 }
39318 arg1 = reinterpret_cast< wxWindow * >(argp1);
39319 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39320 if (!SWIG_IsOK(ecode2)) {
39321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39322 }
39323 arg2 = static_cast< long >(val2);
39324 {
39325 PyThreadState* __tstate = wxPyBeginAllowThreads();
39326 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39327 wxPyEndAllowThreads(__tstate);
39328 if (PyErr_Occurred()) SWIG_fail;
39329 }
39330 resultobj = SWIG_From_int(static_cast< int >(result));
39331 return resultobj;
39332fail:
39333 return NULL;
d55e5bfc
RD
39334}
39335
39336
1bd55598
RD
39337SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39338 PyObject *resultobj = 0;
39339 wxWindow *arg1 = (wxWindow *) 0 ;
39340 wxBorder result;
39341 void *argp1 = 0 ;
39342 int res1 = 0 ;
39343
39344 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39346 if (!SWIG_IsOK(res1)) {
39347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39348 }
39349 arg1 = reinterpret_cast< wxWindow * >(argp1);
39350 {
39351 PyThreadState* __tstate = wxPyBeginAllowThreads();
39352 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39353 wxPyEndAllowThreads(__tstate);
39354 if (PyErr_Occurred()) SWIG_fail;
39355 }
39356 resultobj = SWIG_From_int(static_cast< int >(result));
39357 return resultobj;
39358fail:
39359 return NULL;
d55e5bfc
RD
39360}
39361
39362
1bd55598
RD
39363SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39364 int argc;
39365 PyObject *argv[3];
39366
39367 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39368 --argc;
39369 if (argc == 1) {
39370 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39371 }
39372 if (argc == 2) {
39373 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39374 }
39375
39376fail:
39377 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39378 return NULL;
39379}
39380
39381
39382SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39383 PyObject *resultobj = 0;
39384 wxWindow *arg1 = (wxWindow *) 0 ;
39385 long arg2 = (long) wxUPDATE_UI_NONE ;
39386 void *argp1 = 0 ;
39387 int res1 = 0 ;
39388 long val2 ;
39389 int ecode2 = 0 ;
39390 PyObject * obj0 = 0 ;
39391 PyObject * obj1 = 0 ;
39392 char * kwnames[] = {
39393 (char *) "self",(char *) "flags", NULL
39394 };
39395
39396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39398 if (!SWIG_IsOK(res1)) {
39399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39400 }
39401 arg1 = reinterpret_cast< wxWindow * >(argp1);
39402 if (obj1) {
39403 ecode2 = SWIG_AsVal_long(obj1, &val2);
39404 if (!SWIG_IsOK(ecode2)) {
39405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39406 }
39407 arg2 = static_cast< long >(val2);
39408 }
39409 {
39410 PyThreadState* __tstate = wxPyBeginAllowThreads();
39411 (arg1)->UpdateWindowUI(arg2);
39412 wxPyEndAllowThreads(__tstate);
39413 if (PyErr_Occurred()) SWIG_fail;
39414 }
39415 resultobj = SWIG_Py_Void();
39416 return resultobj;
39417fail:
39418 return NULL;
39419}
39420
39421
39422SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39423 PyObject *resultobj = 0;
39424 wxWindow *arg1 = (wxWindow *) 0 ;
39425 wxMenu *arg2 = (wxMenu *) 0 ;
39426 int arg3 = (int) -1 ;
39427 int arg4 = (int) -1 ;
39428 bool result;
39429 void *argp1 = 0 ;
39430 int res1 = 0 ;
39431 void *argp2 = 0 ;
39432 int res2 = 0 ;
39433 int val3 ;
39434 int ecode3 = 0 ;
39435 int val4 ;
39436 int ecode4 = 0 ;
39437 PyObject * obj0 = 0 ;
39438 PyObject * obj1 = 0 ;
39439 PyObject * obj2 = 0 ;
39440 PyObject * obj3 = 0 ;
39441 char * kwnames[] = {
39442 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39443 };
39444
39445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39447 if (!SWIG_IsOK(res1)) {
39448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39449 }
39450 arg1 = reinterpret_cast< wxWindow * >(argp1);
39451 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39452 if (!SWIG_IsOK(res2)) {
39453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39454 }
39455 arg2 = reinterpret_cast< wxMenu * >(argp2);
39456 if (obj2) {
39457 ecode3 = SWIG_AsVal_int(obj2, &val3);
39458 if (!SWIG_IsOK(ecode3)) {
39459 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39460 }
39461 arg3 = static_cast< int >(val3);
39462 }
39463 if (obj3) {
39464 ecode4 = SWIG_AsVal_int(obj3, &val4);
39465 if (!SWIG_IsOK(ecode4)) {
39466 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39467 }
39468 arg4 = static_cast< int >(val4);
39469 }
39470 {
39471 PyThreadState* __tstate = wxPyBeginAllowThreads();
39472 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39473 wxPyEndAllowThreads(__tstate);
39474 if (PyErr_Occurred()) SWIG_fail;
39475 }
39476 {
39477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39478 }
39479 return resultobj;
39480fail:
39481 return NULL;
39482}
39483
39484
39485SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39486 PyObject *resultobj = 0;
39487 wxWindow *arg1 = (wxWindow *) 0 ;
39488 wxMenu *arg2 = (wxMenu *) 0 ;
39489 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39490 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39491 bool result;
39492 void *argp1 = 0 ;
39493 int res1 = 0 ;
39494 void *argp2 = 0 ;
39495 int res2 = 0 ;
39496 wxPoint temp3 ;
39497 PyObject * obj0 = 0 ;
39498 PyObject * obj1 = 0 ;
39499 PyObject * obj2 = 0 ;
39500 char * kwnames[] = {
39501 (char *) "self",(char *) "menu",(char *) "pos", NULL
39502 };
39503
39504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39506 if (!SWIG_IsOK(res1)) {
39507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39508 }
39509 arg1 = reinterpret_cast< wxWindow * >(argp1);
39510 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39511 if (!SWIG_IsOK(res2)) {
39512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39513 }
39514 arg2 = reinterpret_cast< wxMenu * >(argp2);
39515 if (obj2) {
d55e5bfc 39516 {
1bd55598
RD
39517 arg3 = &temp3;
39518 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
d55e5bfc 39519 }
1bd55598
RD
39520 }
39521 {
39522 PyThreadState* __tstate = wxPyBeginAllowThreads();
39523 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39524 wxPyEndAllowThreads(__tstate);
39525 if (PyErr_Occurred()) SWIG_fail;
39526 }
39527 {
39528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39529 }
39530 return resultobj;
39531fail:
39532 return NULL;
d55e5bfc
RD
39533}
39534
39535
1eeb270e
RD
39536SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39537 PyObject *resultobj = 0;
39538 wxWindow *arg1 = (wxWindow *) 0 ;
39539 bool result;
39540 void *argp1 = 0 ;
39541 int res1 = 0 ;
39542 PyObject *swig_obj[1] ;
39543
39544 if (!args) SWIG_fail;
39545 swig_obj[0] = args;
39546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39547 if (!SWIG_IsOK(res1)) {
39548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39549 }
39550 arg1 = reinterpret_cast< wxWindow * >(argp1);
39551 {
39552 PyThreadState* __tstate = wxPyBeginAllowThreads();
39553 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39554 wxPyEndAllowThreads(__tstate);
39555 if (PyErr_Occurred()) SWIG_fail;
39556 }
39557 {
39558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39559 }
39560 return resultobj;
39561fail:
39562 return NULL;
39563}
39564
39565
1bd55598
RD
39566SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39567 PyObject *resultobj = 0;
39568 wxWindow *arg1 = (wxWindow *) 0 ;
39569 long result;
39570 void *argp1 = 0 ;
39571 int res1 = 0 ;
39572 PyObject *swig_obj[1] ;
39573
39574 if (!args) SWIG_fail;
39575 swig_obj[0] = args;
39576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39577 if (!SWIG_IsOK(res1)) {
39578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39579 }
39580 arg1 = reinterpret_cast< wxWindow * >(argp1);
39581 {
39582 PyThreadState* __tstate = wxPyBeginAllowThreads();
39583 result = (long)wxWindow_GetHandle(arg1);
39584 wxPyEndAllowThreads(__tstate);
39585 if (PyErr_Occurred()) SWIG_fail;
39586 }
39587 resultobj = SWIG_From_long(static_cast< long >(result));
39588 return resultobj;
39589fail:
39590 return NULL;
39591}
39592
39593
39594SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39595 PyObject *resultobj = 0;
39596 wxWindow *arg1 = (wxWindow *) 0 ;
39597 long arg2 ;
39598 void *argp1 = 0 ;
39599 int res1 = 0 ;
39600 long val2 ;
39601 int ecode2 = 0 ;
39602 PyObject * obj0 = 0 ;
39603 PyObject * obj1 = 0 ;
39604 char * kwnames[] = {
39605 (char *) "self",(char *) "handle", NULL
39606 };
39607
39608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39610 if (!SWIG_IsOK(res1)) {
39611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39612 }
39613 arg1 = reinterpret_cast< wxWindow * >(argp1);
39614 ecode2 = SWIG_AsVal_long(obj1, &val2);
39615 if (!SWIG_IsOK(ecode2)) {
39616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39617 }
39618 arg2 = static_cast< long >(val2);
39619 {
39620 PyThreadState* __tstate = wxPyBeginAllowThreads();
39621 wxWindow_AssociateHandle(arg1,arg2);
39622 wxPyEndAllowThreads(__tstate);
39623 if (PyErr_Occurred()) SWIG_fail;
39624 }
39625 resultobj = SWIG_Py_Void();
39626 return resultobj;
39627fail:
39628 return NULL;
d55e5bfc
RD
39629}
39630
39631
1bd55598
RD
39632SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39633 PyObject *resultobj = 0;
39634 wxWindow *arg1 = (wxWindow *) 0 ;
39635 void *argp1 = 0 ;
39636 int res1 = 0 ;
39637 PyObject *swig_obj[1] ;
39638
39639 if (!args) SWIG_fail;
39640 swig_obj[0] = args;
39641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39642 if (!SWIG_IsOK(res1)) {
39643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39644 }
39645 arg1 = reinterpret_cast< wxWindow * >(argp1);
39646 {
39647 PyThreadState* __tstate = wxPyBeginAllowThreads();
39648 (arg1)->DissociateHandle();
39649 wxPyEndAllowThreads(__tstate);
39650 if (PyErr_Occurred()) SWIG_fail;
39651 }
39652 resultobj = SWIG_Py_Void();
39653 return resultobj;
39654fail:
39655 return NULL;
39656}
39657
39658
39659SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39660 PyObject *resultobj = 0;
39661 wxWindow *arg1 = (wxWindow *) 0 ;
39662 int arg2 ;
39663 bool result;
39664 void *argp1 = 0 ;
39665 int res1 = 0 ;
39666 int val2 ;
39667 int ecode2 = 0 ;
39668 PyObject * obj0 = 0 ;
39669 PyObject * obj1 = 0 ;
39670 char * kwnames[] = {
39671 (char *) "self",(char *) "orient", NULL
39672 };
39673
39674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39676 if (!SWIG_IsOK(res1)) {
39677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39678 }
39679 arg1 = reinterpret_cast< wxWindow * >(argp1);
39680 ecode2 = SWIG_AsVal_int(obj1, &val2);
39681 if (!SWIG_IsOK(ecode2)) {
39682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39683 }
39684 arg2 = static_cast< int >(val2);
39685 {
39686 PyThreadState* __tstate = wxPyBeginAllowThreads();
39687 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39688 wxPyEndAllowThreads(__tstate);
39689 if (PyErr_Occurred()) SWIG_fail;
39690 }
39691 {
39692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39693 }
39694 return resultobj;
39695fail:
39696 return NULL;
39697}
39698
39699
39700SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39701 PyObject *resultobj = 0;
39702 wxWindow *arg1 = (wxWindow *) 0 ;
39703 int arg2 ;
39704 int arg3 ;
39705 int arg4 ;
39706 int arg5 ;
39707 bool arg6 = (bool) true ;
39708 void *argp1 = 0 ;
39709 int res1 = 0 ;
39710 int val2 ;
39711 int ecode2 = 0 ;
39712 int val3 ;
39713 int ecode3 = 0 ;
39714 int val4 ;
39715 int ecode4 = 0 ;
39716 int val5 ;
39717 int ecode5 = 0 ;
39718 bool val6 ;
39719 int ecode6 = 0 ;
39720 PyObject * obj0 = 0 ;
39721 PyObject * obj1 = 0 ;
39722 PyObject * obj2 = 0 ;
39723 PyObject * obj3 = 0 ;
39724 PyObject * obj4 = 0 ;
39725 PyObject * obj5 = 0 ;
39726 char * kwnames[] = {
39727 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39728 };
39729
39730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39732 if (!SWIG_IsOK(res1)) {
39733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39734 }
39735 arg1 = reinterpret_cast< wxWindow * >(argp1);
39736 ecode2 = SWIG_AsVal_int(obj1, &val2);
39737 if (!SWIG_IsOK(ecode2)) {
39738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39739 }
39740 arg2 = static_cast< int >(val2);
39741 ecode3 = SWIG_AsVal_int(obj2, &val3);
39742 if (!SWIG_IsOK(ecode3)) {
39743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39744 }
39745 arg3 = static_cast< int >(val3);
39746 ecode4 = SWIG_AsVal_int(obj3, &val4);
39747 if (!SWIG_IsOK(ecode4)) {
39748 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39749 }
39750 arg4 = static_cast< int >(val4);
39751 ecode5 = SWIG_AsVal_int(obj4, &val5);
39752 if (!SWIG_IsOK(ecode5)) {
39753 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39754 }
39755 arg5 = static_cast< int >(val5);
39756 if (obj5) {
39757 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39758 if (!SWIG_IsOK(ecode6)) {
39759 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39760 }
39761 arg6 = static_cast< bool >(val6);
39762 }
39763 {
39764 PyThreadState* __tstate = wxPyBeginAllowThreads();
39765 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39766 wxPyEndAllowThreads(__tstate);
39767 if (PyErr_Occurred()) SWIG_fail;
39768 }
39769 resultobj = SWIG_Py_Void();
39770 return resultobj;
39771fail:
39772 return NULL;
39773}
39774
39775
39776SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39777 PyObject *resultobj = 0;
39778 wxWindow *arg1 = (wxWindow *) 0 ;
39779 int arg2 ;
39780 int arg3 ;
39781 bool arg4 = (bool) true ;
39782 void *argp1 = 0 ;
39783 int res1 = 0 ;
39784 int val2 ;
39785 int ecode2 = 0 ;
39786 int val3 ;
39787 int ecode3 = 0 ;
39788 bool val4 ;
39789 int ecode4 = 0 ;
39790 PyObject * obj0 = 0 ;
39791 PyObject * obj1 = 0 ;
39792 PyObject * obj2 = 0 ;
39793 PyObject * obj3 = 0 ;
39794 char * kwnames[] = {
39795 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39796 };
39797
39798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39800 if (!SWIG_IsOK(res1)) {
39801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39802 }
39803 arg1 = reinterpret_cast< wxWindow * >(argp1);
39804 ecode2 = SWIG_AsVal_int(obj1, &val2);
39805 if (!SWIG_IsOK(ecode2)) {
39806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39807 }
39808 arg2 = static_cast< int >(val2);
39809 ecode3 = SWIG_AsVal_int(obj2, &val3);
39810 if (!SWIG_IsOK(ecode3)) {
39811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39812 }
39813 arg3 = static_cast< int >(val3);
39814 if (obj3) {
39815 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39816 if (!SWIG_IsOK(ecode4)) {
39817 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39818 }
39819 arg4 = static_cast< bool >(val4);
39820 }
39821 {
39822 PyThreadState* __tstate = wxPyBeginAllowThreads();
39823 (arg1)->SetScrollPos(arg2,arg3,arg4);
39824 wxPyEndAllowThreads(__tstate);
39825 if (PyErr_Occurred()) SWIG_fail;
39826 }
39827 resultobj = SWIG_Py_Void();
39828 return resultobj;
39829fail:
39830 return NULL;
39831}
39832
39833
39834SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39835 PyObject *resultobj = 0;
39836 wxWindow *arg1 = (wxWindow *) 0 ;
39837 int arg2 ;
39838 int result;
39839 void *argp1 = 0 ;
39840 int res1 = 0 ;
39841 int val2 ;
39842 int ecode2 = 0 ;
39843 PyObject * obj0 = 0 ;
39844 PyObject * obj1 = 0 ;
39845 char * kwnames[] = {
39846 (char *) "self",(char *) "orientation", NULL
39847 };
39848
39849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39851 if (!SWIG_IsOK(res1)) {
39852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39853 }
39854 arg1 = reinterpret_cast< wxWindow * >(argp1);
39855 ecode2 = SWIG_AsVal_int(obj1, &val2);
39856 if (!SWIG_IsOK(ecode2)) {
39857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39858 }
39859 arg2 = static_cast< int >(val2);
39860 {
39861 PyThreadState* __tstate = wxPyBeginAllowThreads();
39862 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39863 wxPyEndAllowThreads(__tstate);
39864 if (PyErr_Occurred()) SWIG_fail;
39865 }
39866 resultobj = SWIG_From_int(static_cast< int >(result));
39867 return resultobj;
39868fail:
39869 return NULL;
39870}
39871
39872
39873SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39874 PyObject *resultobj = 0;
39875 wxWindow *arg1 = (wxWindow *) 0 ;
39876 int arg2 ;
39877 int result;
39878 void *argp1 = 0 ;
39879 int res1 = 0 ;
39880 int val2 ;
39881 int ecode2 = 0 ;
39882 PyObject * obj0 = 0 ;
39883 PyObject * obj1 = 0 ;
39884 char * kwnames[] = {
39885 (char *) "self",(char *) "orientation", NULL
39886 };
39887
39888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39890 if (!SWIG_IsOK(res1)) {
39891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39892 }
39893 arg1 = reinterpret_cast< wxWindow * >(argp1);
39894 ecode2 = SWIG_AsVal_int(obj1, &val2);
39895 if (!SWIG_IsOK(ecode2)) {
39896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39897 }
39898 arg2 = static_cast< int >(val2);
39899 {
39900 PyThreadState* __tstate = wxPyBeginAllowThreads();
39901 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39902 wxPyEndAllowThreads(__tstate);
39903 if (PyErr_Occurred()) SWIG_fail;
39904 }
39905 resultobj = SWIG_From_int(static_cast< int >(result));
39906 return resultobj;
39907fail:
39908 return NULL;
39909}
39910
39911
39912SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39913 PyObject *resultobj = 0;
39914 wxWindow *arg1 = (wxWindow *) 0 ;
39915 int arg2 ;
39916 int result;
39917 void *argp1 = 0 ;
39918 int res1 = 0 ;
39919 int val2 ;
39920 int ecode2 = 0 ;
39921 PyObject * obj0 = 0 ;
39922 PyObject * obj1 = 0 ;
39923 char * kwnames[] = {
39924 (char *) "self",(char *) "orientation", NULL
39925 };
39926
39927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39929 if (!SWIG_IsOK(res1)) {
39930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39931 }
39932 arg1 = reinterpret_cast< wxWindow * >(argp1);
39933 ecode2 = SWIG_AsVal_int(obj1, &val2);
39934 if (!SWIG_IsOK(ecode2)) {
39935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39936 }
39937 arg2 = static_cast< int >(val2);
39938 {
39939 PyThreadState* __tstate = wxPyBeginAllowThreads();
39940 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39941 wxPyEndAllowThreads(__tstate);
39942 if (PyErr_Occurred()) SWIG_fail;
39943 }
39944 resultobj = SWIG_From_int(static_cast< int >(result));
39945 return resultobj;
39946fail:
39947 return NULL;
39948}
39949
39950
39951SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39952 PyObject *resultobj = 0;
39953 wxWindow *arg1 = (wxWindow *) 0 ;
39954 int arg2 ;
39955 int arg3 ;
39956 wxRect *arg4 = (wxRect *) NULL ;
39957 void *argp1 = 0 ;
39958 int res1 = 0 ;
39959 int val2 ;
39960 int ecode2 = 0 ;
39961 int val3 ;
39962 int ecode3 = 0 ;
39963 void *argp4 = 0 ;
39964 int res4 = 0 ;
39965 PyObject * obj0 = 0 ;
39966 PyObject * obj1 = 0 ;
39967 PyObject * obj2 = 0 ;
39968 PyObject * obj3 = 0 ;
39969 char * kwnames[] = {
39970 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
39971 };
39972
39973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39975 if (!SWIG_IsOK(res1)) {
39976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
39977 }
39978 arg1 = reinterpret_cast< wxWindow * >(argp1);
39979 ecode2 = SWIG_AsVal_int(obj1, &val2);
39980 if (!SWIG_IsOK(ecode2)) {
39981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
39982 }
39983 arg2 = static_cast< int >(val2);
39984 ecode3 = SWIG_AsVal_int(obj2, &val3);
39985 if (!SWIG_IsOK(ecode3)) {
39986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
39987 }
39988 arg3 = static_cast< int >(val3);
39989 if (obj3) {
39990 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
39991 if (!SWIG_IsOK(res4)) {
39992 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
d55e5bfc 39993 }
1bd55598
RD
39994 arg4 = reinterpret_cast< wxRect * >(argp4);
39995 }
39996 {
39997 PyThreadState* __tstate = wxPyBeginAllowThreads();
39998 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
39999 wxPyEndAllowThreads(__tstate);
40000 if (PyErr_Occurred()) SWIG_fail;
40001 }
40002 resultobj = SWIG_Py_Void();
40003 return resultobj;
40004fail:
40005 return NULL;
40006}
40007
40008
40009SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40010 PyObject *resultobj = 0;
40011 wxWindow *arg1 = (wxWindow *) 0 ;
40012 int arg2 ;
40013 bool result;
40014 void *argp1 = 0 ;
40015 int res1 = 0 ;
40016 int val2 ;
40017 int ecode2 = 0 ;
40018 PyObject * obj0 = 0 ;
40019 PyObject * obj1 = 0 ;
40020 char * kwnames[] = {
40021 (char *) "self",(char *) "lines", NULL
40022 };
40023
40024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40026 if (!SWIG_IsOK(res1)) {
40027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40028 }
40029 arg1 = reinterpret_cast< wxWindow * >(argp1);
40030 ecode2 = SWIG_AsVal_int(obj1, &val2);
40031 if (!SWIG_IsOK(ecode2)) {
40032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40033 }
40034 arg2 = static_cast< int >(val2);
40035 {
40036 PyThreadState* __tstate = wxPyBeginAllowThreads();
40037 result = (bool)(arg1)->ScrollLines(arg2);
40038 wxPyEndAllowThreads(__tstate);
40039 if (PyErr_Occurred()) SWIG_fail;
40040 }
40041 {
40042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40043 }
40044 return resultobj;
40045fail:
40046 return NULL;
40047}
40048
40049
40050SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40051 PyObject *resultobj = 0;
40052 wxWindow *arg1 = (wxWindow *) 0 ;
40053 int arg2 ;
40054 bool result;
40055 void *argp1 = 0 ;
40056 int res1 = 0 ;
40057 int val2 ;
40058 int ecode2 = 0 ;
40059 PyObject * obj0 = 0 ;
40060 PyObject * obj1 = 0 ;
40061 char * kwnames[] = {
40062 (char *) "self",(char *) "pages", NULL
40063 };
40064
40065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40067 if (!SWIG_IsOK(res1)) {
40068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40069 }
40070 arg1 = reinterpret_cast< wxWindow * >(argp1);
40071 ecode2 = SWIG_AsVal_int(obj1, &val2);
40072 if (!SWIG_IsOK(ecode2)) {
40073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40074 }
40075 arg2 = static_cast< int >(val2);
40076 {
40077 PyThreadState* __tstate = wxPyBeginAllowThreads();
40078 result = (bool)(arg1)->ScrollPages(arg2);
40079 wxPyEndAllowThreads(__tstate);
40080 if (PyErr_Occurred()) SWIG_fail;
40081 }
40082 {
40083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40084 }
40085 return resultobj;
40086fail:
40087 return NULL;
d55e5bfc
RD
40088}
40089
40090
1bd55598
RD
40091SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40092 PyObject *resultobj = 0;
40093 wxWindow *arg1 = (wxWindow *) 0 ;
40094 bool result;
40095 void *argp1 = 0 ;
40096 int res1 = 0 ;
40097 PyObject *swig_obj[1] ;
40098
40099 if (!args) SWIG_fail;
40100 swig_obj[0] = args;
40101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40102 if (!SWIG_IsOK(res1)) {
40103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40104 }
40105 arg1 = reinterpret_cast< wxWindow * >(argp1);
40106 {
40107 PyThreadState* __tstate = wxPyBeginAllowThreads();
40108 result = (bool)(arg1)->LineUp();
40109 wxPyEndAllowThreads(__tstate);
40110 if (PyErr_Occurred()) SWIG_fail;
40111 }
40112 {
40113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40114 }
40115 return resultobj;
40116fail:
40117 return NULL;
d55e5bfc
RD
40118}
40119
40120
1bd55598
RD
40121SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40122 PyObject *resultobj = 0;
40123 wxWindow *arg1 = (wxWindow *) 0 ;
40124 bool result;
40125 void *argp1 = 0 ;
40126 int res1 = 0 ;
40127 PyObject *swig_obj[1] ;
40128
40129 if (!args) SWIG_fail;
40130 swig_obj[0] = args;
40131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40132 if (!SWIG_IsOK(res1)) {
40133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40134 }
40135 arg1 = reinterpret_cast< wxWindow * >(argp1);
40136 {
40137 PyThreadState* __tstate = wxPyBeginAllowThreads();
40138 result = (bool)(arg1)->LineDown();
40139 wxPyEndAllowThreads(__tstate);
40140 if (PyErr_Occurred()) SWIG_fail;
40141 }
40142 {
40143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40144 }
40145 return resultobj;
40146fail:
40147 return NULL;
d55e5bfc
RD
40148}
40149
40150
1bd55598
RD
40151SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40152 PyObject *resultobj = 0;
40153 wxWindow *arg1 = (wxWindow *) 0 ;
40154 bool result;
40155 void *argp1 = 0 ;
40156 int res1 = 0 ;
40157 PyObject *swig_obj[1] ;
40158
40159 if (!args) SWIG_fail;
40160 swig_obj[0] = args;
40161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40162 if (!SWIG_IsOK(res1)) {
40163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40164 }
40165 arg1 = reinterpret_cast< wxWindow * >(argp1);
40166 {
40167 PyThreadState* __tstate = wxPyBeginAllowThreads();
40168 result = (bool)(arg1)->PageUp();
40169 wxPyEndAllowThreads(__tstate);
40170 if (PyErr_Occurred()) SWIG_fail;
40171 }
40172 {
40173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40174 }
40175 return resultobj;
40176fail:
40177 return NULL;
d55e5bfc
RD
40178}
40179
40180
1bd55598
RD
40181SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40182 PyObject *resultobj = 0;
40183 wxWindow *arg1 = (wxWindow *) 0 ;
40184 bool result;
40185 void *argp1 = 0 ;
40186 int res1 = 0 ;
40187 PyObject *swig_obj[1] ;
40188
40189 if (!args) SWIG_fail;
40190 swig_obj[0] = args;
40191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40192 if (!SWIG_IsOK(res1)) {
40193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40194 }
40195 arg1 = reinterpret_cast< wxWindow * >(argp1);
40196 {
40197 PyThreadState* __tstate = wxPyBeginAllowThreads();
40198 result = (bool)(arg1)->PageDown();
40199 wxPyEndAllowThreads(__tstate);
40200 if (PyErr_Occurred()) SWIG_fail;
40201 }
40202 {
40203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40204 }
40205 return resultobj;
40206fail:
40207 return NULL;
40208}
40209
40210
40211SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40212 PyObject *resultobj = 0;
40213 wxWindow *arg1 = (wxWindow *) 0 ;
40214 wxString *arg2 = 0 ;
40215 void *argp1 = 0 ;
40216 int res1 = 0 ;
40217 bool temp2 = false ;
40218 PyObject * obj0 = 0 ;
40219 PyObject * obj1 = 0 ;
40220 char * kwnames[] = {
40221 (char *) "self",(char *) "text", NULL
40222 };
40223
40224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40226 if (!SWIG_IsOK(res1)) {
40227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40228 }
40229 arg1 = reinterpret_cast< wxWindow * >(argp1);
40230 {
40231 arg2 = wxString_in_helper(obj1);
40232 if (arg2 == NULL) SWIG_fail;
40233 temp2 = true;
40234 }
40235 {
40236 PyThreadState* __tstate = wxPyBeginAllowThreads();
40237 (arg1)->SetHelpText((wxString const &)*arg2);
40238 wxPyEndAllowThreads(__tstate);
40239 if (PyErr_Occurred()) SWIG_fail;
40240 }
40241 resultobj = SWIG_Py_Void();
40242 {
40243 if (temp2)
40244 delete arg2;
40245 }
40246 return resultobj;
40247fail:
40248 {
40249 if (temp2)
40250 delete arg2;
40251 }
40252 return NULL;
d55e5bfc
RD
40253}
40254
40255
1bd55598
RD
40256SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40257 PyObject *resultobj = 0;
40258 wxWindow *arg1 = (wxWindow *) 0 ;
40259 wxString *arg2 = 0 ;
40260 void *argp1 = 0 ;
40261 int res1 = 0 ;
40262 bool temp2 = false ;
40263 PyObject * obj0 = 0 ;
40264 PyObject * obj1 = 0 ;
40265 char * kwnames[] = {
40266 (char *) "self",(char *) "text", NULL
40267 };
40268
40269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40271 if (!SWIG_IsOK(res1)) {
40272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40273 }
40274 arg1 = reinterpret_cast< wxWindow * >(argp1);
40275 {
40276 arg2 = wxString_in_helper(obj1);
40277 if (arg2 == NULL) SWIG_fail;
40278 temp2 = true;
40279 }
40280 {
40281 PyThreadState* __tstate = wxPyBeginAllowThreads();
40282 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40283 wxPyEndAllowThreads(__tstate);
40284 if (PyErr_Occurred()) SWIG_fail;
40285 }
40286 resultobj = SWIG_Py_Void();
40287 {
40288 if (temp2)
40289 delete arg2;
40290 }
40291 return resultobj;
40292fail:
40293 {
40294 if (temp2)
40295 delete arg2;
40296 }
40297 return NULL;
d55e5bfc
RD
40298}
40299
40300
b850e7f3
RD
40301SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40302 PyObject *resultobj = 0;
40303 wxWindow *arg1 = (wxWindow *) 0 ;
40304 wxPoint *arg2 = 0 ;
40305 wxHelpEvent::Origin arg3 ;
40306 wxString result;
40307 void *argp1 = 0 ;
40308 int res1 = 0 ;
40309 wxPoint temp2 ;
40310 void *argp3 ;
40311 int res3 = 0 ;
40312 PyObject * obj0 = 0 ;
40313 PyObject * obj1 = 0 ;
40314 PyObject * obj2 = 0 ;
40315 char * kwnames[] = {
40316 (char *) "self",(char *) "pt",(char *) "origin", NULL
40317 };
40318
40319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40321 if (!SWIG_IsOK(res1)) {
40322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40323 }
40324 arg1 = reinterpret_cast< wxWindow * >(argp1);
40325 {
40326 arg2 = &temp2;
40327 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40328 }
40329 {
40330 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40331 if (!SWIG_IsOK(res3)) {
40332 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40333 }
40334 if (!argp3) {
40335 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40336 } else {
40337 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40338 arg3 = *temp;
40339 if (SWIG_IsNewObj(res3)) delete temp;
40340 }
40341 }
40342 {
40343 PyThreadState* __tstate = wxPyBeginAllowThreads();
40344 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40345 wxPyEndAllowThreads(__tstate);
40346 if (PyErr_Occurred()) SWIG_fail;
40347 }
40348 {
40349#if wxUSE_UNICODE
40350 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40351#else
40352 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40353#endif
40354 }
40355 return resultobj;
40356fail:
40357 return NULL;
40358}
40359
40360
1bd55598
RD
40361SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40362 PyObject *resultobj = 0;
40363 wxWindow *arg1 = (wxWindow *) 0 ;
40364 wxString result;
40365 void *argp1 = 0 ;
40366 int res1 = 0 ;
40367 PyObject *swig_obj[1] ;
40368
40369 if (!args) SWIG_fail;
40370 swig_obj[0] = args;
40371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40372 if (!SWIG_IsOK(res1)) {
40373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40374 }
40375 arg1 = reinterpret_cast< wxWindow * >(argp1);
40376 {
40377 PyThreadState* __tstate = wxPyBeginAllowThreads();
40378 result = ((wxWindow const *)arg1)->GetHelpText();
40379 wxPyEndAllowThreads(__tstate);
40380 if (PyErr_Occurred()) SWIG_fail;
40381 }
40382 {
40383#if wxUSE_UNICODE
40384 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40385#else
40386 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40387#endif
40388 }
40389 return resultobj;
40390fail:
40391 return NULL;
40392}
40393
40394
40395SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40396 PyObject *resultobj = 0;
40397 wxWindow *arg1 = (wxWindow *) 0 ;
40398 wxString *arg2 = 0 ;
40399 void *argp1 = 0 ;
40400 int res1 = 0 ;
40401 bool temp2 = false ;
40402 PyObject * obj0 = 0 ;
40403 PyObject * obj1 = 0 ;
40404 char * kwnames[] = {
40405 (char *) "self",(char *) "tip", NULL
40406 };
40407
40408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40410 if (!SWIG_IsOK(res1)) {
40411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40412 }
40413 arg1 = reinterpret_cast< wxWindow * >(argp1);
40414 {
40415 arg2 = wxString_in_helper(obj1);
40416 if (arg2 == NULL) SWIG_fail;
40417 temp2 = true;
40418 }
40419 {
40420 PyThreadState* __tstate = wxPyBeginAllowThreads();
40421 (arg1)->SetToolTip((wxString const &)*arg2);
40422 wxPyEndAllowThreads(__tstate);
40423 if (PyErr_Occurred()) SWIG_fail;
40424 }
40425 resultobj = SWIG_Py_Void();
40426 {
40427 if (temp2)
40428 delete arg2;
40429 }
40430 return resultobj;
40431fail:
40432 {
40433 if (temp2)
40434 delete arg2;
40435 }
40436 return NULL;
d55e5bfc
RD
40437}
40438
40439
1bd55598
RD
40440SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40441 PyObject *resultobj = 0;
40442 wxWindow *arg1 = (wxWindow *) 0 ;
40443 wxToolTip *arg2 = (wxToolTip *) 0 ;
40444 void *argp1 = 0 ;
40445 int res1 = 0 ;
40446 int res2 = 0 ;
40447 PyObject * obj0 = 0 ;
40448 PyObject * obj1 = 0 ;
40449 char * kwnames[] = {
40450 (char *) "self",(char *) "tip", NULL
40451 };
40452
40453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40455 if (!SWIG_IsOK(res1)) {
40456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40457 }
40458 arg1 = reinterpret_cast< wxWindow * >(argp1);
40459 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40460 if (!SWIG_IsOK(res2)) {
40461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40462 }
40463 {
40464 PyThreadState* __tstate = wxPyBeginAllowThreads();
40465 (arg1)->SetToolTip(arg2);
40466 wxPyEndAllowThreads(__tstate);
40467 if (PyErr_Occurred()) SWIG_fail;
40468 }
40469 resultobj = SWIG_Py_Void();
40470 return resultobj;
40471fail:
40472 return NULL;
d55e5bfc
RD
40473}
40474
40475
1bd55598
RD
40476SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40477 PyObject *resultobj = 0;
40478 wxWindow *arg1 = (wxWindow *) 0 ;
40479 wxToolTip *result = 0 ;
40480 void *argp1 = 0 ;
40481 int res1 = 0 ;
40482 PyObject *swig_obj[1] ;
40483
40484 if (!args) SWIG_fail;
40485 swig_obj[0] = args;
40486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40487 if (!SWIG_IsOK(res1)) {
40488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40489 }
40490 arg1 = reinterpret_cast< wxWindow * >(argp1);
40491 {
40492 PyThreadState* __tstate = wxPyBeginAllowThreads();
40493 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40494 wxPyEndAllowThreads(__tstate);
40495 if (PyErr_Occurred()) SWIG_fail;
40496 }
40497 {
40498 resultobj = wxPyMake_wxObject(result, (bool)0);
40499 }
40500 return resultobj;
40501fail:
40502 return NULL;
40503}
40504
40505
40506SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40507 PyObject *resultobj = 0;
40508 wxWindow *arg1 = (wxWindow *) 0 ;
40509 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40510 void *argp1 = 0 ;
40511 int res1 = 0 ;
40512 int res2 = 0 ;
40513 PyObject * obj0 = 0 ;
40514 PyObject * obj1 = 0 ;
40515 char * kwnames[] = {
40516 (char *) "self",(char *) "dropTarget", NULL
40517 };
40518
40519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40521 if (!SWIG_IsOK(res1)) {
40522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40523 }
40524 arg1 = reinterpret_cast< wxWindow * >(argp1);
40525 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40526 if (!SWIG_IsOK(res2)) {
40527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40528 }
40529 {
40530 PyThreadState* __tstate = wxPyBeginAllowThreads();
40531 (arg1)->SetDropTarget(arg2);
40532 wxPyEndAllowThreads(__tstate);
40533 if (PyErr_Occurred()) SWIG_fail;
40534 }
40535 resultobj = SWIG_Py_Void();
40536 return resultobj;
40537fail:
40538 return NULL;
d55e5bfc
RD
40539}
40540
40541
1bd55598
RD
40542SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40543 PyObject *resultobj = 0;
40544 wxWindow *arg1 = (wxWindow *) 0 ;
40545 wxPyDropTarget *result = 0 ;
40546 void *argp1 = 0 ;
40547 int res1 = 0 ;
40548 PyObject *swig_obj[1] ;
40549
40550 if (!args) SWIG_fail;
40551 swig_obj[0] = args;
40552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40553 if (!SWIG_IsOK(res1)) {
40554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40555 }
40556 arg1 = reinterpret_cast< wxWindow * >(argp1);
40557 {
40558 PyThreadState* __tstate = wxPyBeginAllowThreads();
40559 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40560 wxPyEndAllowThreads(__tstate);
40561 if (PyErr_Occurred()) SWIG_fail;
40562 }
40563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40564 return resultobj;
40565fail:
40566 return NULL;
40567}
40568
40569
40570SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40571 PyObject *resultobj = 0;
40572 wxWindow *arg1 = (wxWindow *) 0 ;
40573 bool arg2 ;
40574 void *argp1 = 0 ;
40575 int res1 = 0 ;
40576 bool val2 ;
40577 int ecode2 = 0 ;
40578 PyObject * obj0 = 0 ;
40579 PyObject * obj1 = 0 ;
40580 char * kwnames[] = {
40581 (char *) "self",(char *) "accept", NULL
40582 };
40583
40584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40586 if (!SWIG_IsOK(res1)) {
40587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40588 }
40589 arg1 = reinterpret_cast< wxWindow * >(argp1);
40590 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40591 if (!SWIG_IsOK(ecode2)) {
40592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40593 }
40594 arg2 = static_cast< bool >(val2);
40595 {
40596 PyThreadState* __tstate = wxPyBeginAllowThreads();
40597 wxWindow_DragAcceptFiles(arg1,arg2);
40598 wxPyEndAllowThreads(__tstate);
40599 if (PyErr_Occurred()) SWIG_fail;
40600 }
40601 resultobj = SWIG_Py_Void();
40602 return resultobj;
40603fail:
40604 return NULL;
40605}
40606
40607
40608SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40609 PyObject *resultobj = 0;
40610 wxWindow *arg1 = (wxWindow *) 0 ;
40611 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40612 void *argp1 = 0 ;
40613 int res1 = 0 ;
40614 int res2 = 0 ;
40615 PyObject * obj0 = 0 ;
40616 PyObject * obj1 = 0 ;
40617 char * kwnames[] = {
40618 (char *) "self",(char *) "constraints", NULL
40619 };
40620
40621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40623 if (!SWIG_IsOK(res1)) {
40624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40625 }
40626 arg1 = reinterpret_cast< wxWindow * >(argp1);
40627 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40628 if (!SWIG_IsOK(res2)) {
40629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40630 }
40631 {
40632 PyThreadState* __tstate = wxPyBeginAllowThreads();
40633 (arg1)->SetConstraints(arg2);
40634 wxPyEndAllowThreads(__tstate);
40635 if (PyErr_Occurred()) SWIG_fail;
40636 }
40637 resultobj = SWIG_Py_Void();
40638 return resultobj;
40639fail:
40640 return NULL;
53aa7709
RD
40641}
40642
40643
1bd55598
RD
40644SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40645 PyObject *resultobj = 0;
40646 wxWindow *arg1 = (wxWindow *) 0 ;
40647 wxLayoutConstraints *result = 0 ;
40648 void *argp1 = 0 ;
40649 int res1 = 0 ;
40650 PyObject *swig_obj[1] ;
40651
40652 if (!args) SWIG_fail;
40653 swig_obj[0] = args;
40654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40655 if (!SWIG_IsOK(res1)) {
40656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40657 }
40658 arg1 = reinterpret_cast< wxWindow * >(argp1);
40659 {
40660 PyThreadState* __tstate = wxPyBeginAllowThreads();
40661 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40662 wxPyEndAllowThreads(__tstate);
40663 if (PyErr_Occurred()) SWIG_fail;
40664 }
40665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40666 return resultobj;
40667fail:
40668 return NULL;
40669}
40670
40671
40672SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40673 PyObject *resultobj = 0;
40674 wxWindow *arg1 = (wxWindow *) 0 ;
40675 bool arg2 ;
40676 void *argp1 = 0 ;
40677 int res1 = 0 ;
40678 bool val2 ;
40679 int ecode2 = 0 ;
40680 PyObject * obj0 = 0 ;
40681 PyObject * obj1 = 0 ;
40682 char * kwnames[] = {
40683 (char *) "self",(char *) "autoLayout", NULL
40684 };
40685
40686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40688 if (!SWIG_IsOK(res1)) {
40689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40690 }
40691 arg1 = reinterpret_cast< wxWindow * >(argp1);
40692 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40693 if (!SWIG_IsOK(ecode2)) {
40694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40695 }
40696 arg2 = static_cast< bool >(val2);
40697 {
40698 PyThreadState* __tstate = wxPyBeginAllowThreads();
40699 (arg1)->SetAutoLayout(arg2);
40700 wxPyEndAllowThreads(__tstate);
40701 if (PyErr_Occurred()) SWIG_fail;
40702 }
40703 resultobj = SWIG_Py_Void();
40704 return resultobj;
40705fail:
40706 return NULL;
53aa7709
RD
40707}
40708
40709
1bd55598
RD
40710SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40711 PyObject *resultobj = 0;
40712 wxWindow *arg1 = (wxWindow *) 0 ;
40713 bool result;
40714 void *argp1 = 0 ;
40715 int res1 = 0 ;
40716 PyObject *swig_obj[1] ;
40717
40718 if (!args) SWIG_fail;
40719 swig_obj[0] = args;
40720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40721 if (!SWIG_IsOK(res1)) {
40722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40723 }
40724 arg1 = reinterpret_cast< wxWindow * >(argp1);
40725 {
40726 PyThreadState* __tstate = wxPyBeginAllowThreads();
40727 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40728 wxPyEndAllowThreads(__tstate);
40729 if (PyErr_Occurred()) SWIG_fail;
40730 }
40731 {
40732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40733 }
40734 return resultobj;
40735fail:
40736 return NULL;
53aa7709
RD
40737}
40738
40739
1bd55598
RD
40740SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40741 PyObject *resultobj = 0;
40742 wxWindow *arg1 = (wxWindow *) 0 ;
40743 bool result;
40744 void *argp1 = 0 ;
40745 int res1 = 0 ;
40746 PyObject *swig_obj[1] ;
40747
40748 if (!args) SWIG_fail;
40749 swig_obj[0] = args;
40750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40751 if (!SWIG_IsOK(res1)) {
40752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40753 }
40754 arg1 = reinterpret_cast< wxWindow * >(argp1);
40755 {
40756 PyThreadState* __tstate = wxPyBeginAllowThreads();
40757 result = (bool)(arg1)->Layout();
40758 wxPyEndAllowThreads(__tstate);
40759 if (PyErr_Occurred()) SWIG_fail;
40760 }
40761 {
40762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40763 }
40764 return resultobj;
40765fail:
40766 return NULL;
40767}
40768
40769
40770SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40771 PyObject *resultobj = 0;
40772 wxWindow *arg1 = (wxWindow *) 0 ;
40773 wxSizer *arg2 = (wxSizer *) 0 ;
40774 bool arg3 = (bool) true ;
40775 void *argp1 = 0 ;
40776 int res1 = 0 ;
40777 int res2 = 0 ;
40778 bool val3 ;
40779 int ecode3 = 0 ;
40780 PyObject * obj0 = 0 ;
40781 PyObject * obj1 = 0 ;
40782 PyObject * obj2 = 0 ;
40783 char * kwnames[] = {
40784 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40785 };
40786
40787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40789 if (!SWIG_IsOK(res1)) {
40790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40791 }
40792 arg1 = reinterpret_cast< wxWindow * >(argp1);
40793 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40794 if (!SWIG_IsOK(res2)) {
40795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40796 }
40797 if (obj2) {
40798 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40799 if (!SWIG_IsOK(ecode3)) {
40800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40801 }
40802 arg3 = static_cast< bool >(val3);
40803 }
40804 {
40805 PyThreadState* __tstate = wxPyBeginAllowThreads();
40806 (arg1)->SetSizer(arg2,arg3);
40807 wxPyEndAllowThreads(__tstate);
40808 if (PyErr_Occurred()) SWIG_fail;
40809 }
40810 resultobj = SWIG_Py_Void();
40811 return resultobj;
40812fail:
40813 return NULL;
40814}
40815
40816
40817SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40818 PyObject *resultobj = 0;
40819 wxWindow *arg1 = (wxWindow *) 0 ;
40820 wxSizer *arg2 = (wxSizer *) 0 ;
40821 bool arg3 = (bool) true ;
40822 void *argp1 = 0 ;
40823 int res1 = 0 ;
40824 int res2 = 0 ;
40825 bool val3 ;
40826 int ecode3 = 0 ;
40827 PyObject * obj0 = 0 ;
40828 PyObject * obj1 = 0 ;
40829 PyObject * obj2 = 0 ;
40830 char * kwnames[] = {
40831 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40832 };
40833
40834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40836 if (!SWIG_IsOK(res1)) {
40837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40838 }
40839 arg1 = reinterpret_cast< wxWindow * >(argp1);
40840 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40841 if (!SWIG_IsOK(res2)) {
40842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40843 }
40844 if (obj2) {
40845 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40846 if (!SWIG_IsOK(ecode3)) {
40847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40848 }
40849 arg3 = static_cast< bool >(val3);
40850 }
40851 {
40852 PyThreadState* __tstate = wxPyBeginAllowThreads();
40853 (arg1)->SetSizerAndFit(arg2,arg3);
40854 wxPyEndAllowThreads(__tstate);
40855 if (PyErr_Occurred()) SWIG_fail;
40856 }
40857 resultobj = SWIG_Py_Void();
40858 return resultobj;
40859fail:
40860 return NULL;
d55e5bfc
RD
40861}
40862
40863
1bd55598
RD
40864SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40865 PyObject *resultobj = 0;
40866 wxWindow *arg1 = (wxWindow *) 0 ;
40867 wxSizer *result = 0 ;
40868 void *argp1 = 0 ;
40869 int res1 = 0 ;
40870 PyObject *swig_obj[1] ;
40871
40872 if (!args) SWIG_fail;
40873 swig_obj[0] = args;
40874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40875 if (!SWIG_IsOK(res1)) {
40876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40877 }
40878 arg1 = reinterpret_cast< wxWindow * >(argp1);
40879 {
40880 PyThreadState* __tstate = wxPyBeginAllowThreads();
40881 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40882 wxPyEndAllowThreads(__tstate);
40883 if (PyErr_Occurred()) SWIG_fail;
40884 }
40885 {
40886 resultobj = wxPyMake_wxObject(result, (bool)0);
40887 }
40888 return resultobj;
40889fail:
40890 return NULL;
40891}
40892
40893
40894SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40895 PyObject *resultobj = 0;
40896 wxWindow *arg1 = (wxWindow *) 0 ;
40897 wxSizer *arg2 = (wxSizer *) 0 ;
40898 void *argp1 = 0 ;
40899 int res1 = 0 ;
40900 void *argp2 = 0 ;
40901 int res2 = 0 ;
40902 PyObject * obj0 = 0 ;
40903 PyObject * obj1 = 0 ;
40904 char * kwnames[] = {
40905 (char *) "self",(char *) "sizer", NULL
40906 };
40907
40908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
40909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40910 if (!SWIG_IsOK(res1)) {
40911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40912 }
40913 arg1 = reinterpret_cast< wxWindow * >(argp1);
40914 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40915 if (!SWIG_IsOK(res2)) {
40916 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40917 }
40918 arg2 = reinterpret_cast< wxSizer * >(argp2);
40919 {
40920 PyThreadState* __tstate = wxPyBeginAllowThreads();
40921 (arg1)->SetContainingSizer(arg2);
40922 wxPyEndAllowThreads(__tstate);
40923 if (PyErr_Occurred()) SWIG_fail;
40924 }
40925 resultobj = SWIG_Py_Void();
40926 return resultobj;
40927fail:
40928 return NULL;
d55e5bfc
RD
40929}
40930
40931
1bd55598
RD
40932SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40933 PyObject *resultobj = 0;
40934 wxWindow *arg1 = (wxWindow *) 0 ;
40935 wxSizer *result = 0 ;
40936 void *argp1 = 0 ;
40937 int res1 = 0 ;
40938 PyObject *swig_obj[1] ;
40939
40940 if (!args) SWIG_fail;
40941 swig_obj[0] = args;
40942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40943 if (!SWIG_IsOK(res1)) {
40944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40945 }
40946 arg1 = reinterpret_cast< wxWindow * >(argp1);
40947 {
40948 PyThreadState* __tstate = wxPyBeginAllowThreads();
40949 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40950 wxPyEndAllowThreads(__tstate);
40951 if (PyErr_Occurred()) SWIG_fail;
40952 }
40953 {
40954 resultobj = wxPyMake_wxObject(result, (bool)0);
40955 }
40956 return resultobj;
40957fail:
40958 return NULL;
d55e5bfc
RD
40959}
40960
40961
1bd55598
RD
40962SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40963 PyObject *resultobj = 0;
40964 wxWindow *arg1 = (wxWindow *) 0 ;
40965 void *argp1 = 0 ;
40966 int res1 = 0 ;
40967 PyObject *swig_obj[1] ;
40968
40969 if (!args) SWIG_fail;
40970 swig_obj[0] = args;
40971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40972 if (!SWIG_IsOK(res1)) {
40973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
40974 }
40975 arg1 = reinterpret_cast< wxWindow * >(argp1);
40976 {
40977 PyThreadState* __tstate = wxPyBeginAllowThreads();
40978 (arg1)->InheritAttributes();
40979 wxPyEndAllowThreads(__tstate);
40980 if (PyErr_Occurred()) SWIG_fail;
40981 }
40982 resultobj = SWIG_Py_Void();
40983 return resultobj;
40984fail:
40985 return NULL;
d55e5bfc
RD
40986}
40987
40988
1bd55598
RD
40989SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40990 PyObject *resultobj = 0;
40991 wxWindow *arg1 = (wxWindow *) 0 ;
40992 bool result;
40993 void *argp1 = 0 ;
40994 int res1 = 0 ;
40995 PyObject *swig_obj[1] ;
40996
40997 if (!args) SWIG_fail;
40998 swig_obj[0] = args;
40999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41000 if (!SWIG_IsOK(res1)) {
41001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41002 }
41003 arg1 = reinterpret_cast< wxWindow * >(argp1);
41004 {
41005 PyThreadState* __tstate = wxPyBeginAllowThreads();
41006 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41007 wxPyEndAllowThreads(__tstate);
41008 if (PyErr_Occurred()) SWIG_fail;
41009 }
41010 {
41011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41012 }
41013 return resultobj;
41014fail:
41015 return NULL;
d55e5bfc
RD
41016}
41017
41018
fc46b7f3
RD
41019SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41020 PyObject *resultobj = 0;
41021 wxWindow *arg1 = (wxWindow *) 0 ;
41022 bool result;
41023 void *argp1 = 0 ;
41024 int res1 = 0 ;
41025 PyObject *swig_obj[1] ;
41026
41027 if (!args) SWIG_fail;
41028 swig_obj[0] = args;
41029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41030 if (!SWIG_IsOK(res1)) {
41031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41032 }
41033 arg1 = reinterpret_cast< wxWindow * >(argp1);
41034 {
41035 PyThreadState* __tstate = wxPyBeginAllowThreads();
41036 result = (bool)(arg1)->CanSetTransparent();
41037 wxPyEndAllowThreads(__tstate);
41038 if (PyErr_Occurred()) SWIG_fail;
41039 }
41040 {
41041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41042 }
41043 return resultobj;
41044fail:
41045 return NULL;
41046}
41047
41048
41049SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41050 PyObject *resultobj = 0;
41051 wxWindow *arg1 = (wxWindow *) 0 ;
41052 byte arg2 ;
41053 bool result;
41054 void *argp1 = 0 ;
41055 int res1 = 0 ;
41056 unsigned char val2 ;
41057 int ecode2 = 0 ;
41058 PyObject * obj0 = 0 ;
41059 PyObject * obj1 = 0 ;
41060 char * kwnames[] = {
41061 (char *) "self",(char *) "alpha", NULL
41062 };
41063
41064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41066 if (!SWIG_IsOK(res1)) {
41067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41068 }
41069 arg1 = reinterpret_cast< wxWindow * >(argp1);
41070 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41071 if (!SWIG_IsOK(ecode2)) {
41072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41073 }
41074 arg2 = static_cast< byte >(val2);
41075 {
41076 PyThreadState* __tstate = wxPyBeginAllowThreads();
41077 result = (bool)(arg1)->SetTransparent(arg2);
41078 wxPyEndAllowThreads(__tstate);
41079 if (PyErr_Occurred()) SWIG_fail;
41080 }
41081 {
41082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41083 }
41084 return resultobj;
41085fail:
41086 return NULL;
41087}
41088
41089
1bd55598
RD
41090SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41091 PyObject *obj;
41092 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41093 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41094 return SWIG_Py_Void();
d55e5bfc
RD
41095}
41096
1bd55598
RD
41097SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41098 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
41099}
41100
1bd55598
RD
41101SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41102 PyObject *resultobj = 0;
41103 long arg1 ;
41104 wxWindow *arg2 = (wxWindow *) NULL ;
41105 wxWindow *result = 0 ;
41106 long val1 ;
41107 int ecode1 = 0 ;
41108 void *argp2 = 0 ;
41109 int res2 = 0 ;
41110 PyObject * obj0 = 0 ;
41111 PyObject * obj1 = 0 ;
41112 char * kwnames[] = {
41113 (char *) "id",(char *) "parent", NULL
41114 };
41115
41116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41117 ecode1 = SWIG_AsVal_long(obj0, &val1);
41118 if (!SWIG_IsOK(ecode1)) {
41119 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41120 }
41121 arg1 = static_cast< long >(val1);
41122 if (obj1) {
41123 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41124 if (!SWIG_IsOK(res2)) {
41125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
d55e5bfc 41126 }
1bd55598
RD
41127 arg2 = reinterpret_cast< wxWindow * >(argp2);
41128 }
41129 {
41130 if (!wxPyCheckForApp()) SWIG_fail;
41131 PyThreadState* __tstate = wxPyBeginAllowThreads();
41132 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41133 wxPyEndAllowThreads(__tstate);
41134 if (PyErr_Occurred()) SWIG_fail;
41135 }
41136 {
41137 resultobj = wxPyMake_wxObject(result, 0);
41138 }
41139 return resultobj;
41140fail:
41141 return NULL;
41142}
41143
41144
41145SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41146 PyObject *resultobj = 0;
41147 wxString *arg1 = 0 ;
41148 wxWindow *arg2 = (wxWindow *) NULL ;
41149 wxWindow *result = 0 ;
41150 bool temp1 = false ;
41151 void *argp2 = 0 ;
41152 int res2 = 0 ;
41153 PyObject * obj0 = 0 ;
41154 PyObject * obj1 = 0 ;
41155 char * kwnames[] = {
41156 (char *) "name",(char *) "parent", NULL
41157 };
41158
41159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41160 {
41161 arg1 = wxString_in_helper(obj0);
41162 if (arg1 == NULL) SWIG_fail;
41163 temp1 = true;
41164 }
41165 if (obj1) {
41166 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41167 if (!SWIG_IsOK(res2)) {
41168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
d55e5bfc 41169 }
1bd55598
RD
41170 arg2 = reinterpret_cast< wxWindow * >(argp2);
41171 }
41172 {
41173 if (!wxPyCheckForApp()) SWIG_fail;
41174 PyThreadState* __tstate = wxPyBeginAllowThreads();
41175 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41176 wxPyEndAllowThreads(__tstate);
41177 if (PyErr_Occurred()) SWIG_fail;
41178 }
41179 {
41180 resultobj = wxPyMake_wxObject(result, 0);
41181 }
41182 {
41183 if (temp1)
41184 delete arg1;
41185 }
41186 return resultobj;
41187fail:
41188 {
41189 if (temp1)
41190 delete arg1;
41191 }
41192 return NULL;
41193}
41194
41195
41196SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41197 PyObject *resultobj = 0;
41198 wxString *arg1 = 0 ;
41199 wxWindow *arg2 = (wxWindow *) NULL ;
41200 wxWindow *result = 0 ;
41201 bool temp1 = false ;
41202 void *argp2 = 0 ;
41203 int res2 = 0 ;
41204 PyObject * obj0 = 0 ;
41205 PyObject * obj1 = 0 ;
41206 char * kwnames[] = {
41207 (char *) "label",(char *) "parent", NULL
41208 };
41209
41210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41211 {
41212 arg1 = wxString_in_helper(obj0);
41213 if (arg1 == NULL) SWIG_fail;
41214 temp1 = true;
41215 }
41216 if (obj1) {
41217 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41218 if (!SWIG_IsOK(res2)) {
41219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41220 }
41221 arg2 = reinterpret_cast< wxWindow * >(argp2);
41222 }
41223 {
41224 if (!wxPyCheckForApp()) SWIG_fail;
41225 PyThreadState* __tstate = wxPyBeginAllowThreads();
41226 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41227 wxPyEndAllowThreads(__tstate);
41228 if (PyErr_Occurred()) SWIG_fail;
41229 }
41230 {
41231 resultobj = wxPyMake_wxObject(result, 0);
41232 }
41233 {
41234 if (temp1)
41235 delete arg1;
41236 }
41237 return resultobj;
41238fail:
41239 {
41240 if (temp1)
41241 delete arg1;
41242 }
41243 return NULL;
41244}
41245
41246
41247SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41248 PyObject *resultobj = 0;
41249 wxWindow *arg1 = (wxWindow *) 0 ;
41250 unsigned long arg2 ;
41251 wxWindow *result = 0 ;
41252 void *argp1 = 0 ;
41253 int res1 = 0 ;
41254 unsigned long val2 ;
41255 int ecode2 = 0 ;
41256 PyObject * obj0 = 0 ;
41257 PyObject * obj1 = 0 ;
41258 char * kwnames[] = {
41259 (char *) "parent",(char *) "_hWnd", NULL
41260 };
41261
41262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41264 if (!SWIG_IsOK(res1)) {
41265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41266 }
41267 arg1 = reinterpret_cast< wxWindow * >(argp1);
41268 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41269 if (!SWIG_IsOK(ecode2)) {
41270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41271 }
41272 arg2 = static_cast< unsigned long >(val2);
41273 {
41274 PyThreadState* __tstate = wxPyBeginAllowThreads();
41275 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41276 wxPyEndAllowThreads(__tstate);
41277 if (PyErr_Occurred()) SWIG_fail;
41278 }
41279 {
41280 resultobj = wxPyMake_wxObject(result, 0);
41281 }
41282 return resultobj;
41283fail:
41284 return NULL;
d55e5bfc
RD
41285}
41286
41287
1bd55598
RD
41288SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41289 PyObject *resultobj = 0;
41290 PyObject *result = 0 ;
41291
41292 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41293 {
41294 PyThreadState* __tstate = wxPyBeginAllowThreads();
41295 result = (PyObject *)GetTopLevelWindows();
41296 wxPyEndAllowThreads(__tstate);
41297 if (PyErr_Occurred()) SWIG_fail;
41298 }
41299 resultobj = result;
41300 return resultobj;
41301fail:
41302 return NULL;
d55e5bfc
RD
41303}
41304
41305
1bd55598
RD
41306SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41307 PyObject *resultobj = 0;
41308 wxValidator *result = 0 ;
41309
41310 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41311 {
41312 PyThreadState* __tstate = wxPyBeginAllowThreads();
41313 result = (wxValidator *)new wxValidator();
41314 wxPyEndAllowThreads(__tstate);
41315 if (PyErr_Occurred()) SWIG_fail;
41316 }
41317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41318 return resultobj;
41319fail:
41320 return NULL;
d55e5bfc
RD
41321}
41322
41323
1bd55598
RD
41324SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41325 PyObject *resultobj = 0;
41326 wxValidator *arg1 = (wxValidator *) 0 ;
41327 wxValidator *result = 0 ;
41328 void *argp1 = 0 ;
41329 int res1 = 0 ;
41330 PyObject *swig_obj[1] ;
41331
41332 if (!args) SWIG_fail;
41333 swig_obj[0] = args;
41334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41335 if (!SWIG_IsOK(res1)) {
41336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41337 }
41338 arg1 = reinterpret_cast< wxValidator * >(argp1);
41339 {
41340 PyThreadState* __tstate = wxPyBeginAllowThreads();
41341 result = (wxValidator *)(arg1)->Clone();
41342 wxPyEndAllowThreads(__tstate);
41343 if (PyErr_Occurred()) SWIG_fail;
41344 }
41345 {
41346 resultobj = wxPyMake_wxObject(result, 0);
41347 }
41348 return resultobj;
41349fail:
41350 return NULL;
41351}
41352
41353
41354SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41355 PyObject *resultobj = 0;
41356 wxValidator *arg1 = (wxValidator *) 0 ;
41357 wxWindow *arg2 = (wxWindow *) 0 ;
41358 bool result;
41359 void *argp1 = 0 ;
41360 int res1 = 0 ;
41361 void *argp2 = 0 ;
41362 int res2 = 0 ;
41363 PyObject * obj0 = 0 ;
41364 PyObject * obj1 = 0 ;
41365 char * kwnames[] = {
41366 (char *) "self",(char *) "parent", NULL
41367 };
41368
41369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41371 if (!SWIG_IsOK(res1)) {
41372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41373 }
41374 arg1 = reinterpret_cast< wxValidator * >(argp1);
41375 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41376 if (!SWIG_IsOK(res2)) {
41377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41378 }
41379 arg2 = reinterpret_cast< wxWindow * >(argp2);
41380 {
41381 PyThreadState* __tstate = wxPyBeginAllowThreads();
41382 result = (bool)(arg1)->Validate(arg2);
41383 wxPyEndAllowThreads(__tstate);
41384 if (PyErr_Occurred()) SWIG_fail;
41385 }
41386 {
41387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41388 }
41389 return resultobj;
41390fail:
41391 return NULL;
d55e5bfc
RD
41392}
41393
41394
1bd55598
RD
41395SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41396 PyObject *resultobj = 0;
41397 wxValidator *arg1 = (wxValidator *) 0 ;
41398 bool result;
41399 void *argp1 = 0 ;
41400 int res1 = 0 ;
41401 PyObject *swig_obj[1] ;
41402
41403 if (!args) SWIG_fail;
41404 swig_obj[0] = args;
41405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41406 if (!SWIG_IsOK(res1)) {
41407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41408 }
41409 arg1 = reinterpret_cast< wxValidator * >(argp1);
41410 {
41411 PyThreadState* __tstate = wxPyBeginAllowThreads();
41412 result = (bool)(arg1)->TransferToWindow();
41413 wxPyEndAllowThreads(__tstate);
41414 if (PyErr_Occurred()) SWIG_fail;
41415 }
41416 {
41417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41418 }
41419 return resultobj;
41420fail:
41421 return NULL;
d55e5bfc
RD
41422}
41423
41424
1bd55598
RD
41425SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41426 PyObject *resultobj = 0;
41427 wxValidator *arg1 = (wxValidator *) 0 ;
41428 bool result;
41429 void *argp1 = 0 ;
41430 int res1 = 0 ;
41431 PyObject *swig_obj[1] ;
41432
41433 if (!args) SWIG_fail;
41434 swig_obj[0] = args;
41435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41436 if (!SWIG_IsOK(res1)) {
41437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41438 }
41439 arg1 = reinterpret_cast< wxValidator * >(argp1);
41440 {
41441 PyThreadState* __tstate = wxPyBeginAllowThreads();
41442 result = (bool)(arg1)->TransferFromWindow();
41443 wxPyEndAllowThreads(__tstate);
41444 if (PyErr_Occurred()) SWIG_fail;
41445 }
41446 {
41447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41448 }
41449 return resultobj;
41450fail:
41451 return NULL;
d55e5bfc
RD
41452}
41453
41454
1bd55598
RD
41455SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41456 PyObject *resultobj = 0;
41457 wxValidator *arg1 = (wxValidator *) 0 ;
41458 wxWindow *result = 0 ;
41459 void *argp1 = 0 ;
41460 int res1 = 0 ;
41461 PyObject *swig_obj[1] ;
41462
41463 if (!args) SWIG_fail;
41464 swig_obj[0] = args;
41465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41466 if (!SWIG_IsOK(res1)) {
41467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41468 }
41469 arg1 = reinterpret_cast< wxValidator * >(argp1);
41470 {
41471 PyThreadState* __tstate = wxPyBeginAllowThreads();
41472 result = (wxWindow *)(arg1)->GetWindow();
41473 wxPyEndAllowThreads(__tstate);
41474 if (PyErr_Occurred()) SWIG_fail;
41475 }
41476 {
41477 resultobj = wxPyMake_wxObject(result, 0);
41478 }
41479 return resultobj;
41480fail:
41481 return NULL;
41482}
41483
41484
41485SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41486 PyObject *resultobj = 0;
41487 wxValidator *arg1 = (wxValidator *) 0 ;
41488 wxWindow *arg2 = (wxWindow *) 0 ;
41489 void *argp1 = 0 ;
41490 int res1 = 0 ;
41491 void *argp2 = 0 ;
41492 int res2 = 0 ;
41493 PyObject * obj0 = 0 ;
41494 PyObject * obj1 = 0 ;
41495 char * kwnames[] = {
41496 (char *) "self",(char *) "window", NULL
41497 };
41498
41499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41501 if (!SWIG_IsOK(res1)) {
41502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41503 }
41504 arg1 = reinterpret_cast< wxValidator * >(argp1);
41505 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41506 if (!SWIG_IsOK(res2)) {
41507 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41508 }
41509 arg2 = reinterpret_cast< wxWindow * >(argp2);
41510 {
41511 PyThreadState* __tstate = wxPyBeginAllowThreads();
41512 (arg1)->SetWindow(arg2);
41513 wxPyEndAllowThreads(__tstate);
41514 if (PyErr_Occurred()) SWIG_fail;
41515 }
41516 resultobj = SWIG_Py_Void();
41517 return resultobj;
41518fail:
41519 return NULL;
84f85550
RD
41520}
41521
41522
1bd55598
RD
41523SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41524 PyObject *resultobj = 0;
41525 bool result;
41526
41527 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41528 {
41529 PyThreadState* __tstate = wxPyBeginAllowThreads();
41530 result = (bool)wxValidator::IsSilent();
41531 wxPyEndAllowThreads(__tstate);
41532 if (PyErr_Occurred()) SWIG_fail;
41533 }
41534 {
41535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41536 }
41537 return resultobj;
41538fail:
41539 return NULL;
d55e5bfc
RD
41540}
41541
41542
1bd55598
RD
41543SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41544 PyObject *resultobj = 0;
41545 int arg1 = (int) true ;
41546 int val1 ;
41547 int ecode1 = 0 ;
41548 PyObject * obj0 = 0 ;
41549 char * kwnames[] = {
41550 (char *) "doIt", NULL
41551 };
41552
41553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41554 if (obj0) {
41555 ecode1 = SWIG_AsVal_int(obj0, &val1);
41556 if (!SWIG_IsOK(ecode1)) {
41557 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41558 }
41559 arg1 = static_cast< int >(val1);
41560 }
41561 {
41562 PyThreadState* __tstate = wxPyBeginAllowThreads();
41563 wxValidator::SetBellOnError(arg1);
41564 wxPyEndAllowThreads(__tstate);
41565 if (PyErr_Occurred()) SWIG_fail;
41566 }
41567 resultobj = SWIG_Py_Void();
41568 return resultobj;
41569fail:
41570 return NULL;
d55e5bfc
RD
41571}
41572
41573
1bd55598
RD
41574SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41575 PyObject *obj;
41576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41577 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41578 return SWIG_Py_Void();
d55e5bfc
RD
41579}
41580
1bd55598
RD
41581SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41582 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
41583}
41584
1bd55598
RD
41585SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41586 PyObject *resultobj = 0;
41587 wxPyValidator *result = 0 ;
41588
41589 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41590 {
41591 PyThreadState* __tstate = wxPyBeginAllowThreads();
41592 result = (wxPyValidator *)new wxPyValidator();
41593 wxPyEndAllowThreads(__tstate);
41594 if (PyErr_Occurred()) SWIG_fail;
41595 }
41596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41597 return resultobj;
41598fail:
41599 return NULL;
41600}
41601
41602
41603SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41604 PyObject *resultobj = 0;
41605 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41606 PyObject *arg2 = (PyObject *) 0 ;
41607 PyObject *arg3 = (PyObject *) 0 ;
c25f90f6 41608 int arg4 = (int) 1 ;
1bd55598
RD
41609 void *argp1 = 0 ;
41610 int res1 = 0 ;
41611 int val4 ;
41612 int ecode4 = 0 ;
41613 PyObject * obj0 = 0 ;
41614 PyObject * obj1 = 0 ;
41615 PyObject * obj2 = 0 ;
41616 PyObject * obj3 = 0 ;
41617 char * kwnames[] = {
41618 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41619 };
41620
41621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41623 if (!SWIG_IsOK(res1)) {
41624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41625 }
41626 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41627 arg2 = obj1;
41628 arg3 = obj2;
41629 if (obj3) {
41630 ecode4 = SWIG_AsVal_int(obj3, &val4);
41631 if (!SWIG_IsOK(ecode4)) {
41632 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41633 }
41634 arg4 = static_cast< int >(val4);
41635 }
41636 {
41637 PyThreadState* __tstate = wxPyBeginAllowThreads();
41638 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41639 wxPyEndAllowThreads(__tstate);
41640 if (PyErr_Occurred()) SWIG_fail;
41641 }
41642 resultobj = SWIG_Py_Void();
41643 return resultobj;
41644fail:
41645 return NULL;
d55e5bfc
RD
41646}
41647
41648
1bd55598
RD
41649SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41650 PyObject *obj;
41651 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41652 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41653 return SWIG_Py_Void();
d55e5bfc
RD
41654}
41655
1bd55598
RD
41656SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41657 return SWIG_Python_InitShadowInstance(args);
41658}
d55e5bfc 41659
1bd55598
RD
41660SWIGINTERN int DefaultValidator_set(PyObject *) {
41661 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41662 return 1;
d55e5bfc
RD
41663}
41664
41665
1bd55598
RD
41666SWIGINTERN PyObject *DefaultValidator_get(void) {
41667 PyObject *pyobj = 0;
41668
41669 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41670 return pyobj;
41671}
41672
41673
41674SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41675 PyObject *resultobj = 0;
41676 wxString const &arg1_defvalue = wxPyEmptyString ;
41677 wxString *arg1 = (wxString *) &arg1_defvalue ;
41678 long arg2 = (long) 0 ;
41679 wxMenu *result = 0 ;
41680 bool temp1 = false ;
41681 long val2 ;
41682 int ecode2 = 0 ;
41683 PyObject * obj0 = 0 ;
41684 PyObject * obj1 = 0 ;
41685 char * kwnames[] = {
41686 (char *) "title",(char *) "style", NULL
41687 };
41688
41689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41690 if (obj0) {
d55e5bfc 41691 {
1bd55598
RD
41692 arg1 = wxString_in_helper(obj0);
41693 if (arg1 == NULL) SWIG_fail;
41694 temp1 = true;
d55e5bfc 41695 }
1bd55598
RD
41696 }
41697 if (obj1) {
41698 ecode2 = SWIG_AsVal_long(obj1, &val2);
41699 if (!SWIG_IsOK(ecode2)) {
41700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41701 }
41702 arg2 = static_cast< long >(val2);
41703 }
41704 {
41705 if (!wxPyCheckForApp()) SWIG_fail;
41706 PyThreadState* __tstate = wxPyBeginAllowThreads();
41707 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41708 wxPyEndAllowThreads(__tstate);
41709 if (PyErr_Occurred()) SWIG_fail;
41710 }
41711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41712 {
41713 if (temp1)
41714 delete arg1;
41715 }
41716 return resultobj;
41717fail:
41718 {
41719 if (temp1)
41720 delete arg1;
41721 }
41722 return NULL;
41723}
41724
41725
41726SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41727 PyObject *resultobj = 0;
41728 wxMenu *arg1 = (wxMenu *) 0 ;
41729 int arg2 ;
ac5d357a
RD
41730 wxString const &arg3_defvalue = wxPyEmptyString ;
41731 wxString *arg3 = (wxString *) &arg3_defvalue ;
1bd55598
RD
41732 wxString const &arg4_defvalue = wxPyEmptyString ;
41733 wxString *arg4 = (wxString *) &arg4_defvalue ;
41734 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41735 wxMenuItem *result = 0 ;
41736 void *argp1 = 0 ;
41737 int res1 = 0 ;
41738 int val2 ;
41739 int ecode2 = 0 ;
41740 bool temp3 = false ;
41741 bool temp4 = false ;
41742 int val5 ;
41743 int ecode5 = 0 ;
41744 PyObject * obj0 = 0 ;
41745 PyObject * obj1 = 0 ;
41746 PyObject * obj2 = 0 ;
41747 PyObject * obj3 = 0 ;
41748 PyObject * obj4 = 0 ;
41749 char * kwnames[] = {
41750 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41751 };
41752
ac5d357a 41753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
1bd55598
RD
41754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41755 if (!SWIG_IsOK(res1)) {
41756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41757 }
41758 arg1 = reinterpret_cast< wxMenu * >(argp1);
41759 ecode2 = SWIG_AsVal_int(obj1, &val2);
41760 if (!SWIG_IsOK(ecode2)) {
41761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41762 }
41763 arg2 = static_cast< int >(val2);
ac5d357a
RD
41764 if (obj2) {
41765 {
41766 arg3 = wxString_in_helper(obj2);
41767 if (arg3 == NULL) SWIG_fail;
41768 temp3 = true;
41769 }
1bd55598
RD
41770 }
41771 if (obj3) {
d55e5bfc 41772 {
1bd55598
RD
41773 arg4 = wxString_in_helper(obj3);
41774 if (arg4 == NULL) SWIG_fail;
41775 temp4 = true;
d55e5bfc 41776 }
1bd55598
RD
41777 }
41778 if (obj4) {
41779 ecode5 = SWIG_AsVal_int(obj4, &val5);
41780 if (!SWIG_IsOK(ecode5)) {
41781 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41782 }
41783 arg5 = static_cast< wxItemKind >(val5);
41784 }
41785 {
41786 PyThreadState* __tstate = wxPyBeginAllowThreads();
41787 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41788 wxPyEndAllowThreads(__tstate);
41789 if (PyErr_Occurred()) SWIG_fail;
41790 }
41791 {
41792 resultobj = wxPyMake_wxObject(result, (bool)0);
41793 }
41794 {
41795 if (temp3)
41796 delete arg3;
41797 }
41798 {
41799 if (temp4)
41800 delete arg4;
41801 }
41802 return resultobj;
41803fail:
41804 {
41805 if (temp3)
41806 delete arg3;
41807 }
41808 {
41809 if (temp4)
41810 delete arg4;
41811 }
41812 return NULL;
d55e5bfc
RD
41813}
41814
41815
1bd55598
RD
41816SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41817 PyObject *resultobj = 0;
41818 wxMenu *arg1 = (wxMenu *) 0 ;
41819 wxMenuItem *result = 0 ;
41820 void *argp1 = 0 ;
41821 int res1 = 0 ;
41822 PyObject *swig_obj[1] ;
41823
41824 if (!args) SWIG_fail;
41825 swig_obj[0] = args;
41826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41827 if (!SWIG_IsOK(res1)) {
41828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41829 }
41830 arg1 = reinterpret_cast< wxMenu * >(argp1);
41831 {
41832 PyThreadState* __tstate = wxPyBeginAllowThreads();
41833 result = (wxMenuItem *)(arg1)->AppendSeparator();
41834 wxPyEndAllowThreads(__tstate);
41835 if (PyErr_Occurred()) SWIG_fail;
41836 }
41837 {
41838 resultobj = wxPyMake_wxObject(result, (bool)0);
41839 }
41840 return resultobj;
41841fail:
41842 return NULL;
41843}
41844
41845
41846SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41847 PyObject *resultobj = 0;
41848 wxMenu *arg1 = (wxMenu *) 0 ;
41849 int arg2 ;
41850 wxString *arg3 = 0 ;
41851 wxString const &arg4_defvalue = wxPyEmptyString ;
41852 wxString *arg4 = (wxString *) &arg4_defvalue ;
41853 wxMenuItem *result = 0 ;
41854 void *argp1 = 0 ;
41855 int res1 = 0 ;
41856 int val2 ;
41857 int ecode2 = 0 ;
41858 bool temp3 = false ;
41859 bool temp4 = false ;
41860 PyObject * obj0 = 0 ;
41861 PyObject * obj1 = 0 ;
41862 PyObject * obj2 = 0 ;
41863 PyObject * obj3 = 0 ;
41864 char * kwnames[] = {
41865 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41866 };
41867
41868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41870 if (!SWIG_IsOK(res1)) {
41871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41872 }
41873 arg1 = reinterpret_cast< wxMenu * >(argp1);
41874 ecode2 = SWIG_AsVal_int(obj1, &val2);
41875 if (!SWIG_IsOK(ecode2)) {
41876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41877 }
41878 arg2 = static_cast< int >(val2);
41879 {
41880 arg3 = wxString_in_helper(obj2);
41881 if (arg3 == NULL) SWIG_fail;
41882 temp3 = true;
41883 }
41884 if (obj3) {
d55e5bfc 41885 {
1bd55598
RD
41886 arg4 = wxString_in_helper(obj3);
41887 if (arg4 == NULL) SWIG_fail;
41888 temp4 = true;
d55e5bfc 41889 }
1bd55598
RD
41890 }
41891 {
41892 PyThreadState* __tstate = wxPyBeginAllowThreads();
41893 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41894 wxPyEndAllowThreads(__tstate);
41895 if (PyErr_Occurred()) SWIG_fail;
41896 }
41897 {
41898 resultobj = wxPyMake_wxObject(result, (bool)0);
41899 }
41900 {
41901 if (temp3)
41902 delete arg3;
41903 }
41904 {
41905 if (temp4)
41906 delete arg4;
41907 }
41908 return resultobj;
41909fail:
41910 {
41911 if (temp3)
41912 delete arg3;
41913 }
41914 {
41915 if (temp4)
41916 delete arg4;
41917 }
41918 return NULL;
41919}
41920
41921
41922SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41923 PyObject *resultobj = 0;
41924 wxMenu *arg1 = (wxMenu *) 0 ;
41925 int arg2 ;
41926 wxString *arg3 = 0 ;
41927 wxString const &arg4_defvalue = wxPyEmptyString ;
41928 wxString *arg4 = (wxString *) &arg4_defvalue ;
41929 wxMenuItem *result = 0 ;
41930 void *argp1 = 0 ;
41931 int res1 = 0 ;
41932 int val2 ;
41933 int ecode2 = 0 ;
41934 bool temp3 = false ;
41935 bool temp4 = false ;
41936 PyObject * obj0 = 0 ;
41937 PyObject * obj1 = 0 ;
41938 PyObject * obj2 = 0 ;
41939 PyObject * obj3 = 0 ;
41940 char * kwnames[] = {
41941 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41942 };
41943
41944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41946 if (!SWIG_IsOK(res1)) {
41947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41948 }
41949 arg1 = reinterpret_cast< wxMenu * >(argp1);
41950 ecode2 = SWIG_AsVal_int(obj1, &val2);
41951 if (!SWIG_IsOK(ecode2)) {
41952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41953 }
41954 arg2 = static_cast< int >(val2);
41955 {
41956 arg3 = wxString_in_helper(obj2);
41957 if (arg3 == NULL) SWIG_fail;
41958 temp3 = true;
41959 }
41960 if (obj3) {
36ed4f51 41961 {
1bd55598
RD
41962 arg4 = wxString_in_helper(obj3);
41963 if (arg4 == NULL) SWIG_fail;
41964 temp4 = true;
36ed4f51 41965 }
1bd55598
RD
41966 }
41967 {
41968 PyThreadState* __tstate = wxPyBeginAllowThreads();
41969 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41970 wxPyEndAllowThreads(__tstate);
41971 if (PyErr_Occurred()) SWIG_fail;
41972 }
41973 {
41974 resultobj = wxPyMake_wxObject(result, (bool)0);
41975 }
41976 {
41977 if (temp3)
41978 delete arg3;
41979 }
41980 {
41981 if (temp4)
41982 delete arg4;
41983 }
41984 return resultobj;
41985fail:
41986 {
41987 if (temp3)
41988 delete arg3;
41989 }
41990 {
41991 if (temp4)
41992 delete arg4;
41993 }
41994 return NULL;
41995}
41996
41997
41998SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41999 PyObject *resultobj = 0;
42000 wxMenu *arg1 = (wxMenu *) 0 ;
42001 int arg2 ;
42002 wxString *arg3 = 0 ;
42003 wxMenu *arg4 = (wxMenu *) 0 ;
42004 wxString const &arg5_defvalue = wxPyEmptyString ;
42005 wxString *arg5 = (wxString *) &arg5_defvalue ;
42006 wxMenuItem *result = 0 ;
42007 void *argp1 = 0 ;
42008 int res1 = 0 ;
42009 int val2 ;
42010 int ecode2 = 0 ;
42011 bool temp3 = false ;
42012 void *argp4 = 0 ;
42013 int res4 = 0 ;
42014 bool temp5 = false ;
42015 PyObject * obj0 = 0 ;
42016 PyObject * obj1 = 0 ;
42017 PyObject * obj2 = 0 ;
42018 PyObject * obj3 = 0 ;
42019 PyObject * obj4 = 0 ;
42020 char * kwnames[] = {
42021 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42022 };
42023
42024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42026 if (!SWIG_IsOK(res1)) {
42027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42028 }
42029 arg1 = reinterpret_cast< wxMenu * >(argp1);
42030 ecode2 = SWIG_AsVal_int(obj1, &val2);
42031 if (!SWIG_IsOK(ecode2)) {
42032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42033 }
42034 arg2 = static_cast< int >(val2);
42035 {
42036 arg3 = wxString_in_helper(obj2);
42037 if (arg3 == NULL) SWIG_fail;
42038 temp3 = true;
42039 }
42040 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42041 if (!SWIG_IsOK(res4)) {
42042 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42043 }
42044 arg4 = reinterpret_cast< wxMenu * >(argp4);
42045 if (obj4) {
d55e5bfc 42046 {
1bd55598
RD
42047 arg5 = wxString_in_helper(obj4);
42048 if (arg5 == NULL) SWIG_fail;
42049 temp5 = true;
d55e5bfc 42050 }
1bd55598
RD
42051 }
42052 {
42053 PyThreadState* __tstate = wxPyBeginAllowThreads();
42054 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42055 wxPyEndAllowThreads(__tstate);
42056 if (PyErr_Occurred()) SWIG_fail;
42057 }
42058 {
42059 resultobj = wxPyMake_wxObject(result, (bool)0);
42060 }
42061 {
42062 if (temp3)
42063 delete arg3;
42064 }
42065 {
42066 if (temp5)
42067 delete arg5;
42068 }
42069 return resultobj;
42070fail:
42071 {
42072 if (temp3)
42073 delete arg3;
42074 }
42075 {
42076 if (temp5)
42077 delete arg5;
42078 }
42079 return NULL;
42080}
42081
42082
da91cb0f
RD
42083SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42084 PyObject *resultobj = 0;
42085 wxMenu *arg1 = (wxMenu *) 0 ;
42086 wxMenu *arg2 = (wxMenu *) 0 ;
42087 wxString *arg3 = 0 ;
42088 wxString const &arg4_defvalue = wxPyEmptyString ;
42089 wxString *arg4 = (wxString *) &arg4_defvalue ;
42090 wxMenuItem *result = 0 ;
42091 void *argp1 = 0 ;
42092 int res1 = 0 ;
42093 void *argp2 = 0 ;
42094 int res2 = 0 ;
42095 bool temp3 = false ;
42096 bool temp4 = false ;
42097 PyObject * obj0 = 0 ;
42098 PyObject * obj1 = 0 ;
42099 PyObject * obj2 = 0 ;
42100 PyObject * obj3 = 0 ;
42101 char * kwnames[] = {
42102 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42103 };
42104
42105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42107 if (!SWIG_IsOK(res1)) {
42108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42109 }
42110 arg1 = reinterpret_cast< wxMenu * >(argp1);
42111 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42112 if (!SWIG_IsOK(res2)) {
42113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42114 }
42115 arg2 = reinterpret_cast< wxMenu * >(argp2);
42116 {
42117 arg3 = wxString_in_helper(obj2);
42118 if (arg3 == NULL) SWIG_fail;
42119 temp3 = true;
42120 }
42121 if (obj3) {
42122 {
42123 arg4 = wxString_in_helper(obj3);
42124 if (arg4 == NULL) SWIG_fail;
42125 temp4 = true;
42126 }
42127 }
42128 {
42129 PyThreadState* __tstate = wxPyBeginAllowThreads();
42130 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42131 wxPyEndAllowThreads(__tstate);
42132 if (PyErr_Occurred()) SWIG_fail;
42133 }
42134 {
42135 resultobj = wxPyMake_wxObject(result, (bool)0);
42136 }
42137 {
42138 if (temp3)
42139 delete arg3;
42140 }
42141 {
42142 if (temp4)
42143 delete arg4;
42144 }
42145 return resultobj;
42146fail:
42147 {
42148 if (temp3)
42149 delete arg3;
42150 }
42151 {
42152 if (temp4)
42153 delete arg4;
42154 }
42155 return NULL;
42156}
42157
42158
1bd55598
RD
42159SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42160 PyObject *resultobj = 0;
42161 wxMenu *arg1 = (wxMenu *) 0 ;
42162 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42163 wxMenuItem *result = 0 ;
42164 void *argp1 = 0 ;
42165 int res1 = 0 ;
42166 int res2 = 0 ;
42167 PyObject * obj0 = 0 ;
42168 PyObject * obj1 = 0 ;
42169 char * kwnames[] = {
42170 (char *) "self",(char *) "item", NULL
42171 };
42172
42173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42175 if (!SWIG_IsOK(res1)) {
42176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42177 }
42178 arg1 = reinterpret_cast< wxMenu * >(argp1);
42179 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42180 if (!SWIG_IsOK(res2)) {
42181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42182 }
42183 {
42184 PyThreadState* __tstate = wxPyBeginAllowThreads();
42185 result = (wxMenuItem *)(arg1)->Append(arg2);
42186 wxPyEndAllowThreads(__tstate);
42187 if (PyErr_Occurred()) SWIG_fail;
42188 }
42189 {
42190 resultobj = wxPyMake_wxObject(result, (bool)0);
42191 }
42192 return resultobj;
42193fail:
42194 return NULL;
42195}
42196
42197
42198SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42199 PyObject *resultobj = 0;
42200 wxMenu *arg1 = (wxMenu *) 0 ;
42201 size_t arg2 ;
42202 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42203 wxMenuItem *result = 0 ;
42204 void *argp1 = 0 ;
42205 int res1 = 0 ;
42206 size_t val2 ;
42207 int ecode2 = 0 ;
42208 int res3 = 0 ;
42209 PyObject * obj0 = 0 ;
42210 PyObject * obj1 = 0 ;
42211 PyObject * obj2 = 0 ;
42212 char * kwnames[] = {
42213 (char *) "self",(char *) "pos",(char *) "item", NULL
42214 };
42215
42216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42218 if (!SWIG_IsOK(res1)) {
42219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42220 }
42221 arg1 = reinterpret_cast< wxMenu * >(argp1);
42222 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42223 if (!SWIG_IsOK(ecode2)) {
42224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42225 }
42226 arg2 = static_cast< size_t >(val2);
42227 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42228 if (!SWIG_IsOK(res3)) {
42229 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42230 }
42231 {
42232 PyThreadState* __tstate = wxPyBeginAllowThreads();
42233 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42234 wxPyEndAllowThreads(__tstate);
42235 if (PyErr_Occurred()) SWIG_fail;
42236 }
42237 {
42238 resultobj = wxPyMake_wxObject(result, (bool)0);
42239 }
42240 return resultobj;
42241fail:
42242 return NULL;
42243}
42244
42245
42246SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42247 PyObject *resultobj = 0;
42248 wxMenu *arg1 = (wxMenu *) 0 ;
42249 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42250 wxMenuItem *result = 0 ;
42251 void *argp1 = 0 ;
42252 int res1 = 0 ;
42253 int res2 = 0 ;
42254 PyObject * obj0 = 0 ;
42255 PyObject * obj1 = 0 ;
42256 char * kwnames[] = {
42257 (char *) "self",(char *) "item", NULL
42258 };
42259
42260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42262 if (!SWIG_IsOK(res1)) {
42263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42264 }
42265 arg1 = reinterpret_cast< wxMenu * >(argp1);
42266 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42267 if (!SWIG_IsOK(res2)) {
42268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42269 }
42270 {
42271 PyThreadState* __tstate = wxPyBeginAllowThreads();
42272 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42273 wxPyEndAllowThreads(__tstate);
42274 if (PyErr_Occurred()) SWIG_fail;
42275 }
42276 {
42277 resultobj = wxPyMake_wxObject(result, (bool)0);
42278 }
42279 return resultobj;
42280fail:
42281 return NULL;
d55e5bfc
RD
42282}
42283
42284
1bd55598
RD
42285SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42286 PyObject *resultobj = 0;
42287 wxMenu *arg1 = (wxMenu *) 0 ;
42288 void *argp1 = 0 ;
42289 int res1 = 0 ;
42290 PyObject *swig_obj[1] ;
42291
42292 if (!args) SWIG_fail;
42293 swig_obj[0] = args;
42294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42295 if (!SWIG_IsOK(res1)) {
42296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42297 }
42298 arg1 = reinterpret_cast< wxMenu * >(argp1);
42299 {
42300 PyThreadState* __tstate = wxPyBeginAllowThreads();
42301 (arg1)->Break();
42302 wxPyEndAllowThreads(__tstate);
42303 if (PyErr_Occurred()) SWIG_fail;
42304 }
42305 resultobj = SWIG_Py_Void();
42306 return resultobj;
42307fail:
42308 return NULL;
42309}
42310
42311
42312SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42313 PyObject *resultobj = 0;
42314 wxMenu *arg1 = (wxMenu *) 0 ;
42315 size_t arg2 ;
42316 int arg3 ;
ac5d357a
RD
42317 wxString const &arg4_defvalue = wxPyEmptyString ;
42318 wxString *arg4 = (wxString *) &arg4_defvalue ;
1bd55598
RD
42319 wxString const &arg5_defvalue = wxPyEmptyString ;
42320 wxString *arg5 = (wxString *) &arg5_defvalue ;
42321 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42322 wxMenuItem *result = 0 ;
42323 void *argp1 = 0 ;
42324 int res1 = 0 ;
42325 size_t val2 ;
42326 int ecode2 = 0 ;
42327 int val3 ;
42328 int ecode3 = 0 ;
42329 bool temp4 = false ;
42330 bool temp5 = false ;
42331 int val6 ;
42332 int ecode6 = 0 ;
42333 PyObject * obj0 = 0 ;
42334 PyObject * obj1 = 0 ;
42335 PyObject * obj2 = 0 ;
42336 PyObject * obj3 = 0 ;
42337 PyObject * obj4 = 0 ;
42338 PyObject * obj5 = 0 ;
42339 char * kwnames[] = {
42340 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42341 };
42342
ac5d357a 42343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
1bd55598
RD
42344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42345 if (!SWIG_IsOK(res1)) {
42346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42347 }
42348 arg1 = reinterpret_cast< wxMenu * >(argp1);
42349 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42350 if (!SWIG_IsOK(ecode2)) {
42351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42352 }
42353 arg2 = static_cast< size_t >(val2);
42354 ecode3 = SWIG_AsVal_int(obj2, &val3);
42355 if (!SWIG_IsOK(ecode3)) {
42356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42357 }
42358 arg3 = static_cast< int >(val3);
ac5d357a
RD
42359 if (obj3) {
42360 {
42361 arg4 = wxString_in_helper(obj3);
42362 if (arg4 == NULL) SWIG_fail;
42363 temp4 = true;
42364 }
1bd55598
RD
42365 }
42366 if (obj4) {
d55e5bfc 42367 {
1bd55598
RD
42368 arg5 = wxString_in_helper(obj4);
42369 if (arg5 == NULL) SWIG_fail;
42370 temp5 = true;
d55e5bfc 42371 }
1bd55598
RD
42372 }
42373 if (obj5) {
42374 ecode6 = SWIG_AsVal_int(obj5, &val6);
42375 if (!SWIG_IsOK(ecode6)) {
42376 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42377 }
42378 arg6 = static_cast< wxItemKind >(val6);
42379 }
42380 {
42381 PyThreadState* __tstate = wxPyBeginAllowThreads();
42382 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42383 wxPyEndAllowThreads(__tstate);
42384 if (PyErr_Occurred()) SWIG_fail;
42385 }
42386 {
42387 resultobj = wxPyMake_wxObject(result, (bool)0);
42388 }
42389 {
42390 if (temp4)
42391 delete arg4;
42392 }
42393 {
42394 if (temp5)
42395 delete arg5;
42396 }
42397 return resultobj;
42398fail:
42399 {
42400 if (temp4)
42401 delete arg4;
42402 }
42403 {
42404 if (temp5)
42405 delete arg5;
42406 }
42407 return NULL;
42408}
42409
42410
42411SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42412 PyObject *resultobj = 0;
42413 wxMenu *arg1 = (wxMenu *) 0 ;
42414 size_t arg2 ;
42415 wxMenuItem *result = 0 ;
42416 void *argp1 = 0 ;
42417 int res1 = 0 ;
42418 size_t val2 ;
42419 int ecode2 = 0 ;
42420 PyObject * obj0 = 0 ;
42421 PyObject * obj1 = 0 ;
42422 char * kwnames[] = {
42423 (char *) "self",(char *) "pos", NULL
42424 };
42425
42426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42428 if (!SWIG_IsOK(res1)) {
42429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42430 }
42431 arg1 = reinterpret_cast< wxMenu * >(argp1);
42432 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42433 if (!SWIG_IsOK(ecode2)) {
42434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42435 }
42436 arg2 = static_cast< size_t >(val2);
42437 {
42438 PyThreadState* __tstate = wxPyBeginAllowThreads();
42439 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42440 wxPyEndAllowThreads(__tstate);
42441 if (PyErr_Occurred()) SWIG_fail;
42442 }
42443 {
42444 resultobj = wxPyMake_wxObject(result, (bool)0);
42445 }
42446 return resultobj;
42447fail:
42448 return NULL;
42449}
42450
42451
42452SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42453 PyObject *resultobj = 0;
42454 wxMenu *arg1 = (wxMenu *) 0 ;
42455 size_t arg2 ;
42456 int arg3 ;
42457 wxString *arg4 = 0 ;
42458 wxString const &arg5_defvalue = wxPyEmptyString ;
42459 wxString *arg5 = (wxString *) &arg5_defvalue ;
42460 wxMenuItem *result = 0 ;
42461 void *argp1 = 0 ;
42462 int res1 = 0 ;
42463 size_t val2 ;
42464 int ecode2 = 0 ;
42465 int val3 ;
42466 int ecode3 = 0 ;
42467 bool temp4 = false ;
42468 bool temp5 = false ;
42469 PyObject * obj0 = 0 ;
42470 PyObject * obj1 = 0 ;
42471 PyObject * obj2 = 0 ;
42472 PyObject * obj3 = 0 ;
42473 PyObject * obj4 = 0 ;
42474 char * kwnames[] = {
42475 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42476 };
42477
42478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42480 if (!SWIG_IsOK(res1)) {
42481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42482 }
42483 arg1 = reinterpret_cast< wxMenu * >(argp1);
42484 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42485 if (!SWIG_IsOK(ecode2)) {
42486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42487 }
42488 arg2 = static_cast< size_t >(val2);
42489 ecode3 = SWIG_AsVal_int(obj2, &val3);
42490 if (!SWIG_IsOK(ecode3)) {
42491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42492 }
42493 arg3 = static_cast< int >(val3);
42494 {
42495 arg4 = wxString_in_helper(obj3);
42496 if (arg4 == NULL) SWIG_fail;
42497 temp4 = true;
42498 }
42499 if (obj4) {
d55e5bfc 42500 {
1bd55598
RD
42501 arg5 = wxString_in_helper(obj4);
42502 if (arg5 == NULL) SWIG_fail;
42503 temp5 = true;
36ed4f51 42504 }
1bd55598
RD
42505 }
42506 {
42507 PyThreadState* __tstate = wxPyBeginAllowThreads();
42508 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42509 wxPyEndAllowThreads(__tstate);
42510 if (PyErr_Occurred()) SWIG_fail;
42511 }
42512 {
42513 resultobj = wxPyMake_wxObject(result, (bool)0);
42514 }
42515 {
42516 if (temp4)
42517 delete arg4;
42518 }
42519 {
42520 if (temp5)
42521 delete arg5;
42522 }
42523 return resultobj;
42524fail:
42525 {
42526 if (temp4)
42527 delete arg4;
42528 }
42529 {
42530 if (temp5)
42531 delete arg5;
42532 }
42533 return NULL;
42534}
42535
42536
42537SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42538 PyObject *resultobj = 0;
42539 wxMenu *arg1 = (wxMenu *) 0 ;
42540 size_t arg2 ;
42541 int arg3 ;
42542 wxString *arg4 = 0 ;
42543 wxString const &arg5_defvalue = wxPyEmptyString ;
42544 wxString *arg5 = (wxString *) &arg5_defvalue ;
42545 wxMenuItem *result = 0 ;
42546 void *argp1 = 0 ;
42547 int res1 = 0 ;
42548 size_t val2 ;
42549 int ecode2 = 0 ;
42550 int val3 ;
42551 int ecode3 = 0 ;
42552 bool temp4 = false ;
42553 bool temp5 = false ;
42554 PyObject * obj0 = 0 ;
42555 PyObject * obj1 = 0 ;
42556 PyObject * obj2 = 0 ;
42557 PyObject * obj3 = 0 ;
42558 PyObject * obj4 = 0 ;
42559 char * kwnames[] = {
42560 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42561 };
42562
42563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42565 if (!SWIG_IsOK(res1)) {
42566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42567 }
42568 arg1 = reinterpret_cast< wxMenu * >(argp1);
42569 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42570 if (!SWIG_IsOK(ecode2)) {
42571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42572 }
42573 arg2 = static_cast< size_t >(val2);
42574 ecode3 = SWIG_AsVal_int(obj2, &val3);
42575 if (!SWIG_IsOK(ecode3)) {
42576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42577 }
42578 arg3 = static_cast< int >(val3);
42579 {
42580 arg4 = wxString_in_helper(obj3);
42581 if (arg4 == NULL) SWIG_fail;
42582 temp4 = true;
42583 }
42584 if (obj4) {
d55e5bfc 42585 {
1bd55598
RD
42586 arg5 = wxString_in_helper(obj4);
42587 if (arg5 == NULL) SWIG_fail;
42588 temp5 = true;
d55e5bfc 42589 }
1bd55598
RD
42590 }
42591 {
42592 PyThreadState* __tstate = wxPyBeginAllowThreads();
42593 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42594 wxPyEndAllowThreads(__tstate);
42595 if (PyErr_Occurred()) SWIG_fail;
42596 }
42597 {
42598 resultobj = wxPyMake_wxObject(result, (bool)0);
42599 }
42600 {
42601 if (temp4)
42602 delete arg4;
42603 }
42604 {
42605 if (temp5)
42606 delete arg5;
42607 }
42608 return resultobj;
42609fail:
42610 {
42611 if (temp4)
42612 delete arg4;
42613 }
42614 {
42615 if (temp5)
42616 delete arg5;
42617 }
42618 return NULL;
42619}
42620
42621
42622SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42623 PyObject *resultobj = 0;
42624 wxMenu *arg1 = (wxMenu *) 0 ;
42625 size_t arg2 ;
42626 int arg3 ;
42627 wxString *arg4 = 0 ;
42628 wxMenu *arg5 = (wxMenu *) 0 ;
42629 wxString const &arg6_defvalue = wxPyEmptyString ;
42630 wxString *arg6 = (wxString *) &arg6_defvalue ;
42631 wxMenuItem *result = 0 ;
42632 void *argp1 = 0 ;
42633 int res1 = 0 ;
42634 size_t val2 ;
42635 int ecode2 = 0 ;
42636 int val3 ;
42637 int ecode3 = 0 ;
42638 bool temp4 = false ;
42639 void *argp5 = 0 ;
42640 int res5 = 0 ;
42641 bool temp6 = false ;
42642 PyObject * obj0 = 0 ;
42643 PyObject * obj1 = 0 ;
42644 PyObject * obj2 = 0 ;
42645 PyObject * obj3 = 0 ;
42646 PyObject * obj4 = 0 ;
42647 PyObject * obj5 = 0 ;
42648 char * kwnames[] = {
42649 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42650 };
42651
42652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42654 if (!SWIG_IsOK(res1)) {
42655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42656 }
42657 arg1 = reinterpret_cast< wxMenu * >(argp1);
42658 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42659 if (!SWIG_IsOK(ecode2)) {
42660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42661 }
42662 arg2 = static_cast< size_t >(val2);
42663 ecode3 = SWIG_AsVal_int(obj2, &val3);
42664 if (!SWIG_IsOK(ecode3)) {
42665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42666 }
42667 arg3 = static_cast< int >(val3);
42668 {
42669 arg4 = wxString_in_helper(obj3);
42670 if (arg4 == NULL) SWIG_fail;
42671 temp4 = true;
42672 }
42673 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42674 if (!SWIG_IsOK(res5)) {
42675 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42676 }
42677 arg5 = reinterpret_cast< wxMenu * >(argp5);
42678 if (obj5) {
d55e5bfc 42679 {
1bd55598
RD
42680 arg6 = wxString_in_helper(obj5);
42681 if (arg6 == NULL) SWIG_fail;
42682 temp6 = true;
d55e5bfc 42683 }
1bd55598
RD
42684 }
42685 {
42686 PyThreadState* __tstate = wxPyBeginAllowThreads();
42687 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42688 wxPyEndAllowThreads(__tstate);
42689 if (PyErr_Occurred()) SWIG_fail;
42690 }
42691 {
42692 resultobj = wxPyMake_wxObject(result, (bool)0);
42693 }
42694 {
42695 if (temp4)
42696 delete arg4;
42697 }
42698 {
42699 if (temp6)
42700 delete arg6;
42701 }
42702 return resultobj;
42703fail:
42704 {
42705 if (temp4)
42706 delete arg4;
42707 }
42708 {
42709 if (temp6)
42710 delete arg6;
42711 }
42712 return NULL;
42713}
42714
42715
42716SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42717 PyObject *resultobj = 0;
42718 wxMenu *arg1 = (wxMenu *) 0 ;
42719 int arg2 ;
ac5d357a
RD
42720 wxString const &arg3_defvalue = wxPyEmptyString ;
42721 wxString *arg3 = (wxString *) &arg3_defvalue ;
1bd55598
RD
42722 wxString const &arg4_defvalue = wxPyEmptyString ;
42723 wxString *arg4 = (wxString *) &arg4_defvalue ;
42724 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42725 wxMenuItem *result = 0 ;
42726 void *argp1 = 0 ;
42727 int res1 = 0 ;
42728 int val2 ;
42729 int ecode2 = 0 ;
42730 bool temp3 = false ;
42731 bool temp4 = false ;
42732 int val5 ;
42733 int ecode5 = 0 ;
42734 PyObject * obj0 = 0 ;
42735 PyObject * obj1 = 0 ;
42736 PyObject * obj2 = 0 ;
42737 PyObject * obj3 = 0 ;
42738 PyObject * obj4 = 0 ;
42739 char * kwnames[] = {
42740 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42741 };
42742
ac5d357a 42743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
1bd55598
RD
42744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42745 if (!SWIG_IsOK(res1)) {
42746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42747 }
42748 arg1 = reinterpret_cast< wxMenu * >(argp1);
42749 ecode2 = SWIG_AsVal_int(obj1, &val2);
42750 if (!SWIG_IsOK(ecode2)) {
42751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42752 }
42753 arg2 = static_cast< int >(val2);
ac5d357a
RD
42754 if (obj2) {
42755 {
42756 arg3 = wxString_in_helper(obj2);
42757 if (arg3 == NULL) SWIG_fail;
42758 temp3 = true;
42759 }
1bd55598
RD
42760 }
42761 if (obj3) {
36ed4f51 42762 {
1bd55598
RD
42763 arg4 = wxString_in_helper(obj3);
42764 if (arg4 == NULL) SWIG_fail;
42765 temp4 = true;
36ed4f51 42766 }
1bd55598
RD
42767 }
42768 if (obj4) {
42769 ecode5 = SWIG_AsVal_int(obj4, &val5);
42770 if (!SWIG_IsOK(ecode5)) {
42771 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42772 }
42773 arg5 = static_cast< wxItemKind >(val5);
42774 }
42775 {
42776 PyThreadState* __tstate = wxPyBeginAllowThreads();
42777 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42778 wxPyEndAllowThreads(__tstate);
42779 if (PyErr_Occurred()) SWIG_fail;
42780 }
42781 {
42782 resultobj = wxPyMake_wxObject(result, (bool)0);
42783 }
42784 {
42785 if (temp3)
42786 delete arg3;
42787 }
42788 {
42789 if (temp4)
42790 delete arg4;
42791 }
42792 return resultobj;
42793fail:
42794 {
42795 if (temp3)
42796 delete arg3;
42797 }
42798 {
42799 if (temp4)
42800 delete arg4;
42801 }
42802 return NULL;
d55e5bfc
RD
42803}
42804
42805
1bd55598
RD
42806SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42807 PyObject *resultobj = 0;
42808 wxMenu *arg1 = (wxMenu *) 0 ;
42809 wxMenuItem *result = 0 ;
42810 void *argp1 = 0 ;
42811 int res1 = 0 ;
42812 PyObject *swig_obj[1] ;
42813
42814 if (!args) SWIG_fail;
42815 swig_obj[0] = args;
42816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42817 if (!SWIG_IsOK(res1)) {
42818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42819 }
42820 arg1 = reinterpret_cast< wxMenu * >(argp1);
42821 {
42822 PyThreadState* __tstate = wxPyBeginAllowThreads();
42823 result = (wxMenuItem *)(arg1)->PrependSeparator();
42824 wxPyEndAllowThreads(__tstate);
42825 if (PyErr_Occurred()) SWIG_fail;
42826 }
42827 {
42828 resultobj = wxPyMake_wxObject(result, (bool)0);
42829 }
42830 return resultobj;
42831fail:
42832 return NULL;
42833}
42834
42835
42836SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42837 PyObject *resultobj = 0;
42838 wxMenu *arg1 = (wxMenu *) 0 ;
42839 int arg2 ;
42840 wxString *arg3 = 0 ;
42841 wxString const &arg4_defvalue = wxPyEmptyString ;
42842 wxString *arg4 = (wxString *) &arg4_defvalue ;
42843 wxMenuItem *result = 0 ;
42844 void *argp1 = 0 ;
42845 int res1 = 0 ;
42846 int val2 ;
42847 int ecode2 = 0 ;
42848 bool temp3 = false ;
42849 bool temp4 = false ;
42850 PyObject * obj0 = 0 ;
42851 PyObject * obj1 = 0 ;
42852 PyObject * obj2 = 0 ;
42853 PyObject * obj3 = 0 ;
42854 char * kwnames[] = {
42855 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42856 };
42857
42858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42860 if (!SWIG_IsOK(res1)) {
42861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42862 }
42863 arg1 = reinterpret_cast< wxMenu * >(argp1);
42864 ecode2 = SWIG_AsVal_int(obj1, &val2);
42865 if (!SWIG_IsOK(ecode2)) {
42866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42867 }
42868 arg2 = static_cast< int >(val2);
42869 {
42870 arg3 = wxString_in_helper(obj2);
42871 if (arg3 == NULL) SWIG_fail;
42872 temp3 = true;
42873 }
42874 if (obj3) {
d55e5bfc 42875 {
1bd55598
RD
42876 arg4 = wxString_in_helper(obj3);
42877 if (arg4 == NULL) SWIG_fail;
42878 temp4 = true;
d55e5bfc 42879 }
1bd55598
RD
42880 }
42881 {
42882 PyThreadState* __tstate = wxPyBeginAllowThreads();
42883 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42884 wxPyEndAllowThreads(__tstate);
42885 if (PyErr_Occurred()) SWIG_fail;
42886 }
42887 {
42888 resultobj = wxPyMake_wxObject(result, (bool)0);
42889 }
42890 {
42891 if (temp3)
42892 delete arg3;
42893 }
42894 {
42895 if (temp4)
42896 delete arg4;
42897 }
42898 return resultobj;
42899fail:
42900 {
42901 if (temp3)
42902 delete arg3;
42903 }
42904 {
42905 if (temp4)
42906 delete arg4;
42907 }
42908 return NULL;
42909}
42910
42911
42912SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42913 PyObject *resultobj = 0;
42914 wxMenu *arg1 = (wxMenu *) 0 ;
42915 int arg2 ;
42916 wxString *arg3 = 0 ;
42917 wxString const &arg4_defvalue = wxPyEmptyString ;
42918 wxString *arg4 = (wxString *) &arg4_defvalue ;
42919 wxMenuItem *result = 0 ;
42920 void *argp1 = 0 ;
42921 int res1 = 0 ;
42922 int val2 ;
42923 int ecode2 = 0 ;
42924 bool temp3 = false ;
42925 bool temp4 = false ;
42926 PyObject * obj0 = 0 ;
42927 PyObject * obj1 = 0 ;
42928 PyObject * obj2 = 0 ;
42929 PyObject * obj3 = 0 ;
42930 char * kwnames[] = {
42931 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42932 };
42933
42934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42936 if (!SWIG_IsOK(res1)) {
42937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42938 }
42939 arg1 = reinterpret_cast< wxMenu * >(argp1);
42940 ecode2 = SWIG_AsVal_int(obj1, &val2);
42941 if (!SWIG_IsOK(ecode2)) {
42942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42943 }
42944 arg2 = static_cast< int >(val2);
42945 {
42946 arg3 = wxString_in_helper(obj2);
42947 if (arg3 == NULL) SWIG_fail;
42948 temp3 = true;
42949 }
42950 if (obj3) {
d55e5bfc 42951 {
1bd55598
RD
42952 arg4 = wxString_in_helper(obj3);
42953 if (arg4 == NULL) SWIG_fail;
42954 temp4 = true;
d55e5bfc 42955 }
1bd55598
RD
42956 }
42957 {
42958 PyThreadState* __tstate = wxPyBeginAllowThreads();
42959 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42960 wxPyEndAllowThreads(__tstate);
42961 if (PyErr_Occurred()) SWIG_fail;
42962 }
42963 {
42964 resultobj = wxPyMake_wxObject(result, (bool)0);
42965 }
42966 {
42967 if (temp3)
42968 delete arg3;
42969 }
42970 {
42971 if (temp4)
42972 delete arg4;
42973 }
42974 return resultobj;
42975fail:
42976 {
42977 if (temp3)
42978 delete arg3;
42979 }
42980 {
42981 if (temp4)
42982 delete arg4;
42983 }
42984 return NULL;
42985}
42986
42987
42988SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42989 PyObject *resultobj = 0;
42990 wxMenu *arg1 = (wxMenu *) 0 ;
42991 int arg2 ;
42992 wxString *arg3 = 0 ;
42993 wxMenu *arg4 = (wxMenu *) 0 ;
42994 wxString const &arg5_defvalue = wxPyEmptyString ;
42995 wxString *arg5 = (wxString *) &arg5_defvalue ;
42996 wxMenuItem *result = 0 ;
42997 void *argp1 = 0 ;
42998 int res1 = 0 ;
42999 int val2 ;
43000 int ecode2 = 0 ;
43001 bool temp3 = false ;
43002 void *argp4 = 0 ;
43003 int res4 = 0 ;
43004 bool temp5 = false ;
43005 PyObject * obj0 = 0 ;
43006 PyObject * obj1 = 0 ;
43007 PyObject * obj2 = 0 ;
43008 PyObject * obj3 = 0 ;
43009 PyObject * obj4 = 0 ;
43010 char * kwnames[] = {
43011 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43012 };
43013
43014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43016 if (!SWIG_IsOK(res1)) {
43017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43018 }
43019 arg1 = reinterpret_cast< wxMenu * >(argp1);
43020 ecode2 = SWIG_AsVal_int(obj1, &val2);
43021 if (!SWIG_IsOK(ecode2)) {
43022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43023 }
43024 arg2 = static_cast< int >(val2);
43025 {
43026 arg3 = wxString_in_helper(obj2);
43027 if (arg3 == NULL) SWIG_fail;
43028 temp3 = true;
43029 }
43030 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43031 if (!SWIG_IsOK(res4)) {
43032 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43033 }
43034 arg4 = reinterpret_cast< wxMenu * >(argp4);
43035 if (obj4) {
36ed4f51 43036 {
1bd55598
RD
43037 arg5 = wxString_in_helper(obj4);
43038 if (arg5 == NULL) SWIG_fail;
43039 temp5 = true;
36ed4f51 43040 }
1bd55598
RD
43041 }
43042 {
43043 PyThreadState* __tstate = wxPyBeginAllowThreads();
43044 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43045 wxPyEndAllowThreads(__tstate);
43046 if (PyErr_Occurred()) SWIG_fail;
43047 }
43048 {
43049 resultobj = wxPyMake_wxObject(result, (bool)0);
43050 }
43051 {
43052 if (temp3)
43053 delete arg3;
43054 }
43055 {
43056 if (temp5)
43057 delete arg5;
43058 }
43059 return resultobj;
43060fail:
43061 {
43062 if (temp3)
43063 delete arg3;
43064 }
43065 {
43066 if (temp5)
43067 delete arg5;
43068 }
43069 return NULL;
43070}
43071
43072
43073SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43074 PyObject *resultobj = 0;
43075 wxMenu *arg1 = (wxMenu *) 0 ;
43076 int arg2 ;
43077 wxMenuItem *result = 0 ;
43078 void *argp1 = 0 ;
43079 int res1 = 0 ;
43080 int val2 ;
43081 int ecode2 = 0 ;
43082 PyObject * obj0 = 0 ;
43083 PyObject * obj1 = 0 ;
43084 char * kwnames[] = {
43085 (char *) "self",(char *) "id", NULL
43086 };
43087
43088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43090 if (!SWIG_IsOK(res1)) {
43091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43092 }
43093 arg1 = reinterpret_cast< wxMenu * >(argp1);
43094 ecode2 = SWIG_AsVal_int(obj1, &val2);
43095 if (!SWIG_IsOK(ecode2)) {
43096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43097 }
43098 arg2 = static_cast< int >(val2);
43099 {
43100 PyThreadState* __tstate = wxPyBeginAllowThreads();
43101 result = (wxMenuItem *)(arg1)->Remove(arg2);
43102 wxPyEndAllowThreads(__tstate);
43103 if (PyErr_Occurred()) SWIG_fail;
43104 }
43105 {
43106 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43107 }
43108 return resultobj;
43109fail:
43110 return NULL;
43111}
43112
43113
43114SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43115 PyObject *resultobj = 0;
43116 wxMenu *arg1 = (wxMenu *) 0 ;
43117 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43118 wxMenuItem *result = 0 ;
43119 void *argp1 = 0 ;
43120 int res1 = 0 ;
43121 void *argp2 = 0 ;
43122 int res2 = 0 ;
43123 PyObject * obj0 = 0 ;
43124 PyObject * obj1 = 0 ;
43125 char * kwnames[] = {
43126 (char *) "self",(char *) "item", NULL
43127 };
43128
43129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43131 if (!SWIG_IsOK(res1)) {
43132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43133 }
43134 arg1 = reinterpret_cast< wxMenu * >(argp1);
43135 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43136 if (!SWIG_IsOK(res2)) {
43137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43138 }
43139 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43140 {
43141 PyThreadState* __tstate = wxPyBeginAllowThreads();
43142 result = (wxMenuItem *)(arg1)->Remove(arg2);
43143 wxPyEndAllowThreads(__tstate);
43144 if (PyErr_Occurred()) SWIG_fail;
43145 }
43146 {
43147 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43148 }
43149 return resultobj;
43150fail:
43151 return NULL;
43152}
43153
43154
43155SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43156 PyObject *resultobj = 0;
43157 wxMenu *arg1 = (wxMenu *) 0 ;
43158 int arg2 ;
43159 bool result;
43160 void *argp1 = 0 ;
43161 int res1 = 0 ;
43162 int val2 ;
43163 int ecode2 = 0 ;
43164 PyObject * obj0 = 0 ;
43165 PyObject * obj1 = 0 ;
43166 char * kwnames[] = {
43167 (char *) "self",(char *) "id", NULL
43168 };
43169
43170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43172 if (!SWIG_IsOK(res1)) {
43173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43174 }
43175 arg1 = reinterpret_cast< wxMenu * >(argp1);
43176 ecode2 = SWIG_AsVal_int(obj1, &val2);
43177 if (!SWIG_IsOK(ecode2)) {
43178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43179 }
43180 arg2 = static_cast< int >(val2);
43181 {
43182 PyThreadState* __tstate = wxPyBeginAllowThreads();
43183 result = (bool)(arg1)->Delete(arg2);
43184 wxPyEndAllowThreads(__tstate);
43185 if (PyErr_Occurred()) SWIG_fail;
43186 }
43187 {
43188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43189 }
43190 return resultobj;
43191fail:
43192 return NULL;
43193}
43194
43195
43196SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43197 PyObject *resultobj = 0;
43198 wxMenu *arg1 = (wxMenu *) 0 ;
43199 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43200 bool result;
43201 void *argp1 = 0 ;
43202 int res1 = 0 ;
43203 void *argp2 = 0 ;
43204 int res2 = 0 ;
43205 PyObject * obj0 = 0 ;
43206 PyObject * obj1 = 0 ;
43207 char * kwnames[] = {
43208 (char *) "self",(char *) "item", NULL
43209 };
43210
43211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43213 if (!SWIG_IsOK(res1)) {
43214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43215 }
43216 arg1 = reinterpret_cast< wxMenu * >(argp1);
43217 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43218 if (!SWIG_IsOK(res2)) {
43219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43220 }
43221 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43222 {
43223 PyThreadState* __tstate = wxPyBeginAllowThreads();
43224 result = (bool)(arg1)->Delete(arg2);
43225 wxPyEndAllowThreads(__tstate);
43226 if (PyErr_Occurred()) SWIG_fail;
43227 }
43228 {
43229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43230 }
43231 return resultobj;
43232fail:
43233 return NULL;
d55e5bfc
RD
43234}
43235
43236
1bd55598
RD
43237SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43238 PyObject *resultobj = 0;
43239 wxMenu *arg1 = (wxMenu *) 0 ;
43240 void *argp1 = 0 ;
43241 int res1 = 0 ;
43242 PyObject *swig_obj[1] ;
43243
43244 if (!args) SWIG_fail;
43245 swig_obj[0] = args;
43246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43247 if (!SWIG_IsOK(res1)) {
43248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43249 }
43250 arg1 = reinterpret_cast< wxMenu * >(argp1);
43251 {
43252 PyThreadState* __tstate = wxPyBeginAllowThreads();
43253 wxMenu_Destroy(arg1);
43254 wxPyEndAllowThreads(__tstate);
43255 if (PyErr_Occurred()) SWIG_fail;
43256 }
43257 resultobj = SWIG_Py_Void();
43258 return resultobj;
43259fail:
43260 return NULL;
43261}
43262
43263
43264SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43265 PyObject *resultobj = 0;
43266 wxMenu *arg1 = (wxMenu *) 0 ;
43267 int arg2 ;
43268 bool result;
43269 void *argp1 = 0 ;
43270 int res1 = 0 ;
43271 int val2 ;
43272 int ecode2 = 0 ;
43273 PyObject * obj0 = 0 ;
43274 PyObject * obj1 = 0 ;
43275 char * kwnames[] = {
43276 (char *) "self",(char *) "id", NULL
43277 };
43278
43279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43281 if (!SWIG_IsOK(res1)) {
43282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43283 }
43284 arg1 = reinterpret_cast< wxMenu * >(argp1);
43285 ecode2 = SWIG_AsVal_int(obj1, &val2);
43286 if (!SWIG_IsOK(ecode2)) {
43287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43288 }
43289 arg2 = static_cast< int >(val2);
43290 {
43291 PyThreadState* __tstate = wxPyBeginAllowThreads();
43292 result = (bool)(arg1)->Destroy(arg2);
43293 wxPyEndAllowThreads(__tstate);
43294 if (PyErr_Occurred()) SWIG_fail;
43295 }
43296 {
43297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43298 }
43299 return resultobj;
43300fail:
43301 return NULL;
43302}
43303
43304
43305SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43306 PyObject *resultobj = 0;
43307 wxMenu *arg1 = (wxMenu *) 0 ;
43308 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43309 bool result;
43310 void *argp1 = 0 ;
43311 int res1 = 0 ;
43312 void *argp2 = 0 ;
43313 int res2 = 0 ;
43314 PyObject * obj0 = 0 ;
43315 PyObject * obj1 = 0 ;
43316 char * kwnames[] = {
43317 (char *) "self",(char *) "item", NULL
43318 };
43319
43320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43322 if (!SWIG_IsOK(res1)) {
43323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43324 }
43325 arg1 = reinterpret_cast< wxMenu * >(argp1);
43326 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43327 if (!SWIG_IsOK(res2)) {
43328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43329 }
43330 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43331 {
43332 PyThreadState* __tstate = wxPyBeginAllowThreads();
43333 result = (bool)(arg1)->Destroy(arg2);
43334 wxPyEndAllowThreads(__tstate);
43335 if (PyErr_Occurred()) SWIG_fail;
43336 }
43337 {
43338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43339 }
43340 return resultobj;
43341fail:
43342 return NULL;
d55e5bfc
RD
43343}
43344
43345
1bd55598
RD
43346SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43347 PyObject *resultobj = 0;
43348 wxMenu *arg1 = (wxMenu *) 0 ;
43349 size_t result;
43350 void *argp1 = 0 ;
43351 int res1 = 0 ;
43352 PyObject *swig_obj[1] ;
43353
43354 if (!args) SWIG_fail;
43355 swig_obj[0] = args;
43356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43357 if (!SWIG_IsOK(res1)) {
43358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43359 }
43360 arg1 = reinterpret_cast< wxMenu * >(argp1);
43361 {
43362 PyThreadState* __tstate = wxPyBeginAllowThreads();
43363 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43364 wxPyEndAllowThreads(__tstate);
43365 if (PyErr_Occurred()) SWIG_fail;
43366 }
43367 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43368 return resultobj;
43369fail:
43370 return NULL;
d55e5bfc
RD
43371}
43372
43373
1bd55598
RD
43374SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43375 PyObject *resultobj = 0;
43376 wxMenu *arg1 = (wxMenu *) 0 ;
43377 PyObject *result = 0 ;
43378 void *argp1 = 0 ;
43379 int res1 = 0 ;
43380 PyObject *swig_obj[1] ;
43381
43382 if (!args) SWIG_fail;
43383 swig_obj[0] = args;
43384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43385 if (!SWIG_IsOK(res1)) {
43386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43387 }
43388 arg1 = reinterpret_cast< wxMenu * >(argp1);
43389 {
43390 PyThreadState* __tstate = wxPyBeginAllowThreads();
43391 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43392 wxPyEndAllowThreads(__tstate);
43393 if (PyErr_Occurred()) SWIG_fail;
43394 }
43395 resultobj = result;
43396 return resultobj;
43397fail:
43398 return NULL;
43399}
43400
43401
43402SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43403 PyObject *resultobj = 0;
43404 wxMenu *arg1 = (wxMenu *) 0 ;
43405 wxString *arg2 = 0 ;
43406 int result;
43407 void *argp1 = 0 ;
43408 int res1 = 0 ;
43409 bool temp2 = false ;
43410 PyObject * obj0 = 0 ;
43411 PyObject * obj1 = 0 ;
43412 char * kwnames[] = {
43413 (char *) "self",(char *) "item", NULL
43414 };
43415
43416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43418 if (!SWIG_IsOK(res1)) {
43419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43420 }
43421 arg1 = reinterpret_cast< wxMenu * >(argp1);
43422 {
43423 arg2 = wxString_in_helper(obj1);
43424 if (arg2 == NULL) SWIG_fail;
43425 temp2 = true;
43426 }
43427 {
43428 PyThreadState* __tstate = wxPyBeginAllowThreads();
43429 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43430 wxPyEndAllowThreads(__tstate);
43431 if (PyErr_Occurred()) SWIG_fail;
43432 }
43433 resultobj = SWIG_From_int(static_cast< int >(result));
43434 {
43435 if (temp2)
43436 delete arg2;
43437 }
43438 return resultobj;
43439fail:
43440 {
43441 if (temp2)
43442 delete arg2;
43443 }
43444 return NULL;
43445}
43446
43447
43448SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43449 PyObject *resultobj = 0;
43450 wxMenu *arg1 = (wxMenu *) 0 ;
43451 int arg2 ;
43452 wxMenuItem *result = 0 ;
43453 void *argp1 = 0 ;
43454 int res1 = 0 ;
43455 int val2 ;
43456 int ecode2 = 0 ;
43457 PyObject * obj0 = 0 ;
43458 PyObject * obj1 = 0 ;
43459 char * kwnames[] = {
43460 (char *) "self",(char *) "id", NULL
43461 };
43462
43463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43465 if (!SWIG_IsOK(res1)) {
43466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43467 }
43468 arg1 = reinterpret_cast< wxMenu * >(argp1);
43469 ecode2 = SWIG_AsVal_int(obj1, &val2);
43470 if (!SWIG_IsOK(ecode2)) {
43471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43472 }
43473 arg2 = static_cast< int >(val2);
43474 {
43475 PyThreadState* __tstate = wxPyBeginAllowThreads();
43476 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43477 wxPyEndAllowThreads(__tstate);
43478 if (PyErr_Occurred()) SWIG_fail;
43479 }
43480 {
43481 resultobj = wxPyMake_wxObject(result, (bool)0);
43482 }
43483 return resultobj;
43484fail:
43485 return NULL;
43486}
43487
43488
43489SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43490 PyObject *resultobj = 0;
43491 wxMenu *arg1 = (wxMenu *) 0 ;
43492 size_t arg2 ;
43493 wxMenuItem *result = 0 ;
43494 void *argp1 = 0 ;
43495 int res1 = 0 ;
43496 size_t val2 ;
43497 int ecode2 = 0 ;
43498 PyObject * obj0 = 0 ;
43499 PyObject * obj1 = 0 ;
43500 char * kwnames[] = {
43501 (char *) "self",(char *) "position", NULL
43502 };
43503
43504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43506 if (!SWIG_IsOK(res1)) {
43507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43508 }
43509 arg1 = reinterpret_cast< wxMenu * >(argp1);
43510 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43511 if (!SWIG_IsOK(ecode2)) {
43512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43513 }
43514 arg2 = static_cast< size_t >(val2);
43515 {
43516 PyThreadState* __tstate = wxPyBeginAllowThreads();
43517 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43518 wxPyEndAllowThreads(__tstate);
43519 if (PyErr_Occurred()) SWIG_fail;
43520 }
43521 {
43522 resultobj = wxPyMake_wxObject(result, (bool)0);
43523 }
43524 return resultobj;
43525fail:
43526 return NULL;
43527}
43528
43529
43530SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43531 PyObject *resultobj = 0;
43532 wxMenu *arg1 = (wxMenu *) 0 ;
43533 int arg2 ;
43534 bool arg3 ;
43535 void *argp1 = 0 ;
43536 int res1 = 0 ;
43537 int val2 ;
43538 int ecode2 = 0 ;
43539 bool val3 ;
43540 int ecode3 = 0 ;
43541 PyObject * obj0 = 0 ;
43542 PyObject * obj1 = 0 ;
43543 PyObject * obj2 = 0 ;
43544 char * kwnames[] = {
43545 (char *) "self",(char *) "id",(char *) "enable", NULL
43546 };
43547
43548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43550 if (!SWIG_IsOK(res1)) {
43551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43552 }
43553 arg1 = reinterpret_cast< wxMenu * >(argp1);
43554 ecode2 = SWIG_AsVal_int(obj1, &val2);
43555 if (!SWIG_IsOK(ecode2)) {
43556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43557 }
43558 arg2 = static_cast< int >(val2);
43559 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43560 if (!SWIG_IsOK(ecode3)) {
43561 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43562 }
43563 arg3 = static_cast< bool >(val3);
43564 {
43565 PyThreadState* __tstate = wxPyBeginAllowThreads();
43566 (arg1)->Enable(arg2,arg3);
43567 wxPyEndAllowThreads(__tstate);
43568 if (PyErr_Occurred()) SWIG_fail;
43569 }
43570 resultobj = SWIG_Py_Void();
43571 return resultobj;
43572fail:
43573 return NULL;
43574}
43575
43576
43577SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43578 PyObject *resultobj = 0;
43579 wxMenu *arg1 = (wxMenu *) 0 ;
43580 int arg2 ;
43581 bool result;
43582 void *argp1 = 0 ;
43583 int res1 = 0 ;
43584 int val2 ;
43585 int ecode2 = 0 ;
43586 PyObject * obj0 = 0 ;
43587 PyObject * obj1 = 0 ;
43588 char * kwnames[] = {
43589 (char *) "self",(char *) "id", NULL
43590 };
43591
43592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43594 if (!SWIG_IsOK(res1)) {
43595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43596 }
43597 arg1 = reinterpret_cast< wxMenu * >(argp1);
43598 ecode2 = SWIG_AsVal_int(obj1, &val2);
43599 if (!SWIG_IsOK(ecode2)) {
43600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43601 }
43602 arg2 = static_cast< int >(val2);
43603 {
43604 PyThreadState* __tstate = wxPyBeginAllowThreads();
43605 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43606 wxPyEndAllowThreads(__tstate);
43607 if (PyErr_Occurred()) SWIG_fail;
43608 }
43609 {
43610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43611 }
43612 return resultobj;
43613fail:
43614 return NULL;
43615}
43616
43617
43618SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43619 PyObject *resultobj = 0;
43620 wxMenu *arg1 = (wxMenu *) 0 ;
43621 int arg2 ;
43622 bool arg3 ;
43623 void *argp1 = 0 ;
43624 int res1 = 0 ;
43625 int val2 ;
43626 int ecode2 = 0 ;
43627 bool val3 ;
43628 int ecode3 = 0 ;
43629 PyObject * obj0 = 0 ;
43630 PyObject * obj1 = 0 ;
43631 PyObject * obj2 = 0 ;
43632 char * kwnames[] = {
43633 (char *) "self",(char *) "id",(char *) "check", NULL
43634 };
43635
43636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43638 if (!SWIG_IsOK(res1)) {
43639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43640 }
43641 arg1 = reinterpret_cast< wxMenu * >(argp1);
43642 ecode2 = SWIG_AsVal_int(obj1, &val2);
43643 if (!SWIG_IsOK(ecode2)) {
43644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43645 }
43646 arg2 = static_cast< int >(val2);
43647 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43648 if (!SWIG_IsOK(ecode3)) {
43649 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43650 }
43651 arg3 = static_cast< bool >(val3);
43652 {
43653 PyThreadState* __tstate = wxPyBeginAllowThreads();
43654 (arg1)->Check(arg2,arg3);
43655 wxPyEndAllowThreads(__tstate);
43656 if (PyErr_Occurred()) SWIG_fail;
43657 }
43658 resultobj = SWIG_Py_Void();
43659 return resultobj;
43660fail:
43661 return NULL;
43662}
43663
43664
43665SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43666 PyObject *resultobj = 0;
43667 wxMenu *arg1 = (wxMenu *) 0 ;
43668 int arg2 ;
43669 bool result;
43670 void *argp1 = 0 ;
43671 int res1 = 0 ;
43672 int val2 ;
43673 int ecode2 = 0 ;
43674 PyObject * obj0 = 0 ;
43675 PyObject * obj1 = 0 ;
43676 char * kwnames[] = {
43677 (char *) "self",(char *) "id", NULL
43678 };
43679
43680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43682 if (!SWIG_IsOK(res1)) {
43683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43684 }
43685 arg1 = reinterpret_cast< wxMenu * >(argp1);
43686 ecode2 = SWIG_AsVal_int(obj1, &val2);
43687 if (!SWIG_IsOK(ecode2)) {
43688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43689 }
43690 arg2 = static_cast< int >(val2);
43691 {
43692 PyThreadState* __tstate = wxPyBeginAllowThreads();
43693 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43694 wxPyEndAllowThreads(__tstate);
43695 if (PyErr_Occurred()) SWIG_fail;
43696 }
43697 {
43698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43699 }
43700 return resultobj;
43701fail:
43702 return NULL;
43703}
43704
43705
43706SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43707 PyObject *resultobj = 0;
43708 wxMenu *arg1 = (wxMenu *) 0 ;
43709 int arg2 ;
43710 wxString *arg3 = 0 ;
43711 void *argp1 = 0 ;
43712 int res1 = 0 ;
43713 int val2 ;
43714 int ecode2 = 0 ;
43715 bool temp3 = false ;
43716 PyObject * obj0 = 0 ;
43717 PyObject * obj1 = 0 ;
43718 PyObject * obj2 = 0 ;
43719 char * kwnames[] = {
43720 (char *) "self",(char *) "id",(char *) "label", NULL
43721 };
43722
43723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43725 if (!SWIG_IsOK(res1)) {
43726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43727 }
43728 arg1 = reinterpret_cast< wxMenu * >(argp1);
43729 ecode2 = SWIG_AsVal_int(obj1, &val2);
43730 if (!SWIG_IsOK(ecode2)) {
43731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43732 }
43733 arg2 = static_cast< int >(val2);
43734 {
43735 arg3 = wxString_in_helper(obj2);
43736 if (arg3 == NULL) SWIG_fail;
43737 temp3 = true;
43738 }
43739 {
43740 PyThreadState* __tstate = wxPyBeginAllowThreads();
43741 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43742 wxPyEndAllowThreads(__tstate);
43743 if (PyErr_Occurred()) SWIG_fail;
43744 }
43745 resultobj = SWIG_Py_Void();
43746 {
43747 if (temp3)
43748 delete arg3;
43749 }
43750 return resultobj;
43751fail:
43752 {
43753 if (temp3)
43754 delete arg3;
43755 }
43756 return NULL;
43757}
43758
43759
43760SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43761 PyObject *resultobj = 0;
43762 wxMenu *arg1 = (wxMenu *) 0 ;
43763 int arg2 ;
43764 wxString result;
43765 void *argp1 = 0 ;
43766 int res1 = 0 ;
43767 int val2 ;
43768 int ecode2 = 0 ;
43769 PyObject * obj0 = 0 ;
43770 PyObject * obj1 = 0 ;
43771 char * kwnames[] = {
43772 (char *) "self",(char *) "id", NULL
43773 };
43774
43775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43777 if (!SWIG_IsOK(res1)) {
43778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43779 }
43780 arg1 = reinterpret_cast< wxMenu * >(argp1);
43781 ecode2 = SWIG_AsVal_int(obj1, &val2);
43782 if (!SWIG_IsOK(ecode2)) {
43783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43784 }
43785 arg2 = static_cast< int >(val2);
43786 {
43787 PyThreadState* __tstate = wxPyBeginAllowThreads();
43788 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43789 wxPyEndAllowThreads(__tstate);
43790 if (PyErr_Occurred()) SWIG_fail;
43791 }
43792 {
43793#if wxUSE_UNICODE
43794 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43795#else
43796 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43797#endif
43798 }
43799 return resultobj;
43800fail:
43801 return NULL;
43802}
43803
43804
43805SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43806 PyObject *resultobj = 0;
43807 wxMenu *arg1 = (wxMenu *) 0 ;
43808 int arg2 ;
43809 wxString *arg3 = 0 ;
43810 void *argp1 = 0 ;
43811 int res1 = 0 ;
43812 int val2 ;
43813 int ecode2 = 0 ;
43814 bool temp3 = false ;
43815 PyObject * obj0 = 0 ;
43816 PyObject * obj1 = 0 ;
43817 PyObject * obj2 = 0 ;
43818 char * kwnames[] = {
43819 (char *) "self",(char *) "id",(char *) "helpString", NULL
43820 };
43821
43822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43824 if (!SWIG_IsOK(res1)) {
43825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43826 }
43827 arg1 = reinterpret_cast< wxMenu * >(argp1);
43828 ecode2 = SWIG_AsVal_int(obj1, &val2);
43829 if (!SWIG_IsOK(ecode2)) {
43830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43831 }
43832 arg2 = static_cast< int >(val2);
43833 {
43834 arg3 = wxString_in_helper(obj2);
43835 if (arg3 == NULL) SWIG_fail;
43836 temp3 = true;
43837 }
43838 {
43839 PyThreadState* __tstate = wxPyBeginAllowThreads();
43840 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43841 wxPyEndAllowThreads(__tstate);
43842 if (PyErr_Occurred()) SWIG_fail;
43843 }
43844 resultobj = SWIG_Py_Void();
43845 {
43846 if (temp3)
43847 delete arg3;
43848 }
43849 return resultobj;
43850fail:
43851 {
43852 if (temp3)
43853 delete arg3;
43854 }
43855 return NULL;
43856}
43857
43858
43859SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43860 PyObject *resultobj = 0;
43861 wxMenu *arg1 = (wxMenu *) 0 ;
43862 int arg2 ;
43863 wxString result;
43864 void *argp1 = 0 ;
43865 int res1 = 0 ;
43866 int val2 ;
43867 int ecode2 = 0 ;
43868 PyObject * obj0 = 0 ;
43869 PyObject * obj1 = 0 ;
43870 char * kwnames[] = {
43871 (char *) "self",(char *) "id", NULL
43872 };
43873
43874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43876 if (!SWIG_IsOK(res1)) {
43877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43878 }
43879 arg1 = reinterpret_cast< wxMenu * >(argp1);
43880 ecode2 = SWIG_AsVal_int(obj1, &val2);
43881 if (!SWIG_IsOK(ecode2)) {
43882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43883 }
43884 arg2 = static_cast< int >(val2);
43885 {
43886 PyThreadState* __tstate = wxPyBeginAllowThreads();
43887 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43888 wxPyEndAllowThreads(__tstate);
43889 if (PyErr_Occurred()) SWIG_fail;
43890 }
43891 {
43892#if wxUSE_UNICODE
43893 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43894#else
43895 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43896#endif
43897 }
43898 return resultobj;
43899fail:
43900 return NULL;
43901}
43902
43903
43904SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43905 PyObject *resultobj = 0;
43906 wxMenu *arg1 = (wxMenu *) 0 ;
43907 wxString *arg2 = 0 ;
43908 void *argp1 = 0 ;
43909 int res1 = 0 ;
43910 bool temp2 = false ;
43911 PyObject * obj0 = 0 ;
43912 PyObject * obj1 = 0 ;
43913 char * kwnames[] = {
43914 (char *) "self",(char *) "title", NULL
43915 };
43916
43917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43919 if (!SWIG_IsOK(res1)) {
43920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43921 }
43922 arg1 = reinterpret_cast< wxMenu * >(argp1);
43923 {
43924 arg2 = wxString_in_helper(obj1);
43925 if (arg2 == NULL) SWIG_fail;
43926 temp2 = true;
43927 }
43928 {
43929 PyThreadState* __tstate = wxPyBeginAllowThreads();
43930 (arg1)->SetTitle((wxString const &)*arg2);
43931 wxPyEndAllowThreads(__tstate);
43932 if (PyErr_Occurred()) SWIG_fail;
43933 }
43934 resultobj = SWIG_Py_Void();
43935 {
43936 if (temp2)
43937 delete arg2;
43938 }
43939 return resultobj;
43940fail:
43941 {
43942 if (temp2)
43943 delete arg2;
43944 }
43945 return NULL;
d55e5bfc
RD
43946}
43947
43948
1bd55598
RD
43949SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43950 PyObject *resultobj = 0;
43951 wxMenu *arg1 = (wxMenu *) 0 ;
43952 wxString result;
43953 void *argp1 = 0 ;
43954 int res1 = 0 ;
43955 PyObject *swig_obj[1] ;
43956
43957 if (!args) SWIG_fail;
43958 swig_obj[0] = args;
43959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43960 if (!SWIG_IsOK(res1)) {
43961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
43962 }
43963 arg1 = reinterpret_cast< wxMenu * >(argp1);
43964 {
43965 PyThreadState* __tstate = wxPyBeginAllowThreads();
43966 result = ((wxMenu const *)arg1)->GetTitle();
43967 wxPyEndAllowThreads(__tstate);
43968 if (PyErr_Occurred()) SWIG_fail;
43969 }
43970 {
d55e5bfc 43971#if wxUSE_UNICODE
1bd55598 43972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
d55e5bfc 43973#else
1bd55598 43974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
d55e5bfc 43975#endif
1bd55598
RD
43976 }
43977 return resultobj;
43978fail:
43979 return NULL;
43980}
43981
43982
43983SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43984 PyObject *resultobj = 0;
43985 wxMenu *arg1 = (wxMenu *) 0 ;
43986 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
43987 void *argp1 = 0 ;
43988 int res1 = 0 ;
43989 void *argp2 = 0 ;
43990 int res2 = 0 ;
43991 PyObject * obj0 = 0 ;
43992 PyObject * obj1 = 0 ;
43993 char * kwnames[] = {
43994 (char *) "self",(char *) "handler", NULL
43995 };
43996
43997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
43998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43999 if (!SWIG_IsOK(res1)) {
44000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44001 }
44002 arg1 = reinterpret_cast< wxMenu * >(argp1);
44003 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44004 if (!SWIG_IsOK(res2)) {
44005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44006 }
44007 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44008 {
44009 PyThreadState* __tstate = wxPyBeginAllowThreads();
44010 (arg1)->SetEventHandler(arg2);
44011 wxPyEndAllowThreads(__tstate);
44012 if (PyErr_Occurred()) SWIG_fail;
44013 }
44014 resultobj = SWIG_Py_Void();
44015 return resultobj;
44016fail:
44017 return NULL;
d55e5bfc
RD
44018}
44019
44020
1bd55598
RD
44021SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44022 PyObject *resultobj = 0;
44023 wxMenu *arg1 = (wxMenu *) 0 ;
44024 wxEvtHandler *result = 0 ;
44025 void *argp1 = 0 ;
44026 int res1 = 0 ;
44027 PyObject *swig_obj[1] ;
44028
44029 if (!args) SWIG_fail;
44030 swig_obj[0] = args;
44031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44032 if (!SWIG_IsOK(res1)) {
44033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44034 }
44035 arg1 = reinterpret_cast< wxMenu * >(argp1);
44036 {
44037 PyThreadState* __tstate = wxPyBeginAllowThreads();
44038 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44039 wxPyEndAllowThreads(__tstate);
44040 if (PyErr_Occurred()) SWIG_fail;
44041 }
44042 {
44043 resultobj = wxPyMake_wxObject(result, 0);
44044 }
44045 return resultobj;
44046fail:
44047 return NULL;
44048}
44049
44050
44051SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44052 PyObject *resultobj = 0;
44053 wxMenu *arg1 = (wxMenu *) 0 ;
44054 wxWindow *arg2 = (wxWindow *) 0 ;
44055 void *argp1 = 0 ;
44056 int res1 = 0 ;
44057 void *argp2 = 0 ;
44058 int res2 = 0 ;
44059 PyObject * obj0 = 0 ;
44060 PyObject * obj1 = 0 ;
44061 char * kwnames[] = {
44062 (char *) "self",(char *) "win", NULL
44063 };
44064
44065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44067 if (!SWIG_IsOK(res1)) {
44068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44069 }
44070 arg1 = reinterpret_cast< wxMenu * >(argp1);
44071 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44072 if (!SWIG_IsOK(res2)) {
44073 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44074 }
44075 arg2 = reinterpret_cast< wxWindow * >(argp2);
44076 {
44077 PyThreadState* __tstate = wxPyBeginAllowThreads();
44078 (arg1)->SetInvokingWindow(arg2);
44079 wxPyEndAllowThreads(__tstate);
44080 if (PyErr_Occurred()) SWIG_fail;
44081 }
44082 resultobj = SWIG_Py_Void();
44083 return resultobj;
44084fail:
44085 return NULL;
d55e5bfc
RD
44086}
44087
44088
1bd55598
RD
44089SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44090 PyObject *resultobj = 0;
44091 wxMenu *arg1 = (wxMenu *) 0 ;
44092 wxWindow *result = 0 ;
44093 void *argp1 = 0 ;
44094 int res1 = 0 ;
44095 PyObject *swig_obj[1] ;
44096
44097 if (!args) SWIG_fail;
44098 swig_obj[0] = args;
44099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44100 if (!SWIG_IsOK(res1)) {
44101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44102 }
44103 arg1 = reinterpret_cast< wxMenu * >(argp1);
44104 {
44105 PyThreadState* __tstate = wxPyBeginAllowThreads();
44106 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44107 wxPyEndAllowThreads(__tstate);
44108 if (PyErr_Occurred()) SWIG_fail;
44109 }
44110 {
44111 resultobj = wxPyMake_wxObject(result, 0);
44112 }
44113 return resultobj;
44114fail:
44115 return NULL;
d55e5bfc
RD
44116}
44117
44118
1bd55598
RD
44119SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44120 PyObject *resultobj = 0;
44121 wxMenu *arg1 = (wxMenu *) 0 ;
44122 long result;
44123 void *argp1 = 0 ;
44124 int res1 = 0 ;
44125 PyObject *swig_obj[1] ;
44126
44127 if (!args) SWIG_fail;
44128 swig_obj[0] = args;
44129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44130 if (!SWIG_IsOK(res1)) {
44131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44132 }
44133 arg1 = reinterpret_cast< wxMenu * >(argp1);
44134 {
44135 PyThreadState* __tstate = wxPyBeginAllowThreads();
44136 result = (long)((wxMenu const *)arg1)->GetStyle();
44137 wxPyEndAllowThreads(__tstate);
44138 if (PyErr_Occurred()) SWIG_fail;
44139 }
44140 resultobj = SWIG_From_long(static_cast< long >(result));
44141 return resultobj;
44142fail:
44143 return NULL;
44144}
44145
44146
44147SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44148 PyObject *resultobj = 0;
44149 wxMenu *arg1 = (wxMenu *) 0 ;
44150 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44151 void *argp1 = 0 ;
44152 int res1 = 0 ;
44153 void *argp2 = 0 ;
44154 int res2 = 0 ;
44155 PyObject * obj0 = 0 ;
44156 PyObject * obj1 = 0 ;
44157 char * kwnames[] = {
44158 (char *) "self",(char *) "source", NULL
44159 };
44160
44161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44163 if (!SWIG_IsOK(res1)) {
44164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44165 }
44166 arg1 = reinterpret_cast< wxMenu * >(argp1);
44167 if (obj1) {
44168 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44169 if (!SWIG_IsOK(res2)) {
44170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
d55e5bfc 44171 }
1bd55598
RD
44172 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44173 }
44174 {
44175 PyThreadState* __tstate = wxPyBeginAllowThreads();
44176 (arg1)->UpdateUI(arg2);
44177 wxPyEndAllowThreads(__tstate);
44178 if (PyErr_Occurred()) SWIG_fail;
44179 }
44180 resultobj = SWIG_Py_Void();
44181 return resultobj;
44182fail:
44183 return NULL;
d55e5bfc
RD
44184}
44185
44186
1bd55598
RD
44187SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44188 PyObject *resultobj = 0;
44189 wxMenu *arg1 = (wxMenu *) 0 ;
44190 wxMenuBar *result = 0 ;
44191 void *argp1 = 0 ;
44192 int res1 = 0 ;
44193 PyObject *swig_obj[1] ;
44194
44195 if (!args) SWIG_fail;
44196 swig_obj[0] = args;
44197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44198 if (!SWIG_IsOK(res1)) {
44199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44200 }
44201 arg1 = reinterpret_cast< wxMenu * >(argp1);
44202 {
44203 PyThreadState* __tstate = wxPyBeginAllowThreads();
44204 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44205 wxPyEndAllowThreads(__tstate);
44206 if (PyErr_Occurred()) SWIG_fail;
44207 }
44208 {
44209 resultobj = wxPyMake_wxObject(result, (bool)0);
44210 }
44211 return resultobj;
44212fail:
44213 return NULL;
44214}
44215
44216
44217SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44218 PyObject *resultobj = 0;
44219 wxMenu *arg1 = (wxMenu *) 0 ;
44220 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44221 void *argp1 = 0 ;
44222 int res1 = 0 ;
44223 void *argp2 = 0 ;
44224 int res2 = 0 ;
44225 PyObject * obj0 = 0 ;
44226 PyObject * obj1 = 0 ;
44227 char * kwnames[] = {
44228 (char *) "self",(char *) "menubar", NULL
44229 };
44230
44231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44233 if (!SWIG_IsOK(res1)) {
44234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44235 }
44236 arg1 = reinterpret_cast< wxMenu * >(argp1);
44237 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44238 if (!SWIG_IsOK(res2)) {
44239 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44240 }
44241 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44242 {
44243 PyThreadState* __tstate = wxPyBeginAllowThreads();
44244 (arg1)->Attach(arg2);
44245 wxPyEndAllowThreads(__tstate);
44246 if (PyErr_Occurred()) SWIG_fail;
44247 }
44248 resultobj = SWIG_Py_Void();
44249 return resultobj;
44250fail:
44251 return NULL;
d55e5bfc
RD
44252}
44253
44254
1bd55598
RD
44255SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44256 PyObject *resultobj = 0;
44257 wxMenu *arg1 = (wxMenu *) 0 ;
44258 void *argp1 = 0 ;
44259 int res1 = 0 ;
44260 PyObject *swig_obj[1] ;
44261
44262 if (!args) SWIG_fail;
44263 swig_obj[0] = args;
44264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44265 if (!SWIG_IsOK(res1)) {
44266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44267 }
44268 arg1 = reinterpret_cast< wxMenu * >(argp1);
44269 {
44270 PyThreadState* __tstate = wxPyBeginAllowThreads();
44271 (arg1)->Detach();
44272 wxPyEndAllowThreads(__tstate);
44273 if (PyErr_Occurred()) SWIG_fail;
44274 }
44275 resultobj = SWIG_Py_Void();
44276 return resultobj;
44277fail:
44278 return NULL;
d55e5bfc
RD
44279}
44280
44281
1bd55598
RD
44282SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44283 PyObject *resultobj = 0;
44284 wxMenu *arg1 = (wxMenu *) 0 ;
44285 bool result;
44286 void *argp1 = 0 ;
44287 int res1 = 0 ;
44288 PyObject *swig_obj[1] ;
44289
44290 if (!args) SWIG_fail;
44291 swig_obj[0] = args;
44292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44293 if (!SWIG_IsOK(res1)) {
44294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44295 }
44296 arg1 = reinterpret_cast< wxMenu * >(argp1);
44297 {
44298 PyThreadState* __tstate = wxPyBeginAllowThreads();
44299 result = (bool)((wxMenu const *)arg1)->IsAttached();
44300 wxPyEndAllowThreads(__tstate);
44301 if (PyErr_Occurred()) SWIG_fail;
44302 }
44303 {
44304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44305 }
44306 return resultobj;
44307fail:
44308 return NULL;
44309}
44310
44311
44312SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44313 PyObject *resultobj = 0;
44314 wxMenu *arg1 = (wxMenu *) 0 ;
44315 wxMenu *arg2 = (wxMenu *) 0 ;
44316 void *argp1 = 0 ;
44317 int res1 = 0 ;
44318 void *argp2 = 0 ;
44319 int res2 = 0 ;
44320 PyObject * obj0 = 0 ;
44321 PyObject * obj1 = 0 ;
44322 char * kwnames[] = {
44323 (char *) "self",(char *) "parent", NULL
44324 };
44325
44326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44328 if (!SWIG_IsOK(res1)) {
44329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44330 }
44331 arg1 = reinterpret_cast< wxMenu * >(argp1);
44332 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44333 if (!SWIG_IsOK(res2)) {
44334 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44335 }
44336 arg2 = reinterpret_cast< wxMenu * >(argp2);
44337 {
44338 PyThreadState* __tstate = wxPyBeginAllowThreads();
44339 (arg1)->SetParent(arg2);
44340 wxPyEndAllowThreads(__tstate);
44341 if (PyErr_Occurred()) SWIG_fail;
44342 }
44343 resultobj = SWIG_Py_Void();
44344 return resultobj;
44345fail:
44346 return NULL;
d55e5bfc
RD
44347}
44348
44349
1bd55598
RD
44350SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44351 PyObject *resultobj = 0;
44352 wxMenu *arg1 = (wxMenu *) 0 ;
44353 wxMenu *result = 0 ;
44354 void *argp1 = 0 ;
44355 int res1 = 0 ;
44356 PyObject *swig_obj[1] ;
44357
44358 if (!args) SWIG_fail;
44359 swig_obj[0] = args;
44360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44361 if (!SWIG_IsOK(res1)) {
44362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44363 }
44364 arg1 = reinterpret_cast< wxMenu * >(argp1);
44365 {
44366 PyThreadState* __tstate = wxPyBeginAllowThreads();
44367 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44368 wxPyEndAllowThreads(__tstate);
44369 if (PyErr_Occurred()) SWIG_fail;
44370 }
44371 {
44372 resultobj = wxPyMake_wxObject(result, 0);
44373 }
44374 return resultobj;
44375fail:
44376 return NULL;
d55e5bfc
RD
44377}
44378
44379
1bd55598
RD
44380SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44381 PyObject *obj;
44382 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44383 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44384 return SWIG_Py_Void();
d55e5bfc 44385}
1bd55598
RD
44386
44387SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44388 return SWIG_Python_InitShadowInstance(args);
44389}
44390
44391SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44392 PyObject *resultobj = 0;
44393 long arg1 = (long) 0 ;
44394 wxMenuBar *result = 0 ;
44395 long val1 ;
44396 int ecode1 = 0 ;
44397 PyObject * obj0 = 0 ;
44398 char * kwnames[] = {
44399 (char *) "style", NULL
44400 };
44401
44402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44403 if (obj0) {
44404 ecode1 = SWIG_AsVal_long(obj0, &val1);
44405 if (!SWIG_IsOK(ecode1)) {
44406 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44407 }
44408 arg1 = static_cast< long >(val1);
44409 }
44410 {
44411 if (!wxPyCheckForApp()) SWIG_fail;
44412 PyThreadState* __tstate = wxPyBeginAllowThreads();
44413 result = (wxMenuBar *)new wxMenuBar(arg1);
44414 wxPyEndAllowThreads(__tstate);
44415 if (PyErr_Occurred()) SWIG_fail;
44416 }
44417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44418 return resultobj;
44419fail:
44420 return NULL;
44421}
44422
44423
44424SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44425 PyObject *resultobj = 0;
44426 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44427 wxMenu *arg2 = (wxMenu *) 0 ;
44428 wxString *arg3 = 0 ;
44429 bool result;
44430 void *argp1 = 0 ;
44431 int res1 = 0 ;
44432 void *argp2 = 0 ;
44433 int res2 = 0 ;
44434 bool temp3 = false ;
44435 PyObject * obj0 = 0 ;
44436 PyObject * obj1 = 0 ;
44437 PyObject * obj2 = 0 ;
44438 char * kwnames[] = {
44439 (char *) "self",(char *) "menu",(char *) "title", NULL
44440 };
44441
44442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44444 if (!SWIG_IsOK(res1)) {
44445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44446 }
44447 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44448 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44449 if (!SWIG_IsOK(res2)) {
44450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44451 }
44452 arg2 = reinterpret_cast< wxMenu * >(argp2);
44453 {
44454 arg3 = wxString_in_helper(obj2);
44455 if (arg3 == NULL) SWIG_fail;
44456 temp3 = true;
44457 }
44458 {
44459 PyThreadState* __tstate = wxPyBeginAllowThreads();
44460 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44461 wxPyEndAllowThreads(__tstate);
44462 if (PyErr_Occurred()) SWIG_fail;
44463 }
44464 {
44465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44466 }
44467 {
44468 if (temp3)
44469 delete arg3;
44470 }
44471 return resultobj;
44472fail:
44473 {
44474 if (temp3)
44475 delete arg3;
44476 }
44477 return NULL;
44478}
44479
44480
44481SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44482 PyObject *resultobj = 0;
44483 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44484 size_t arg2 ;
44485 wxMenu *arg3 = (wxMenu *) 0 ;
44486 wxString *arg4 = 0 ;
44487 bool result;
44488 void *argp1 = 0 ;
44489 int res1 = 0 ;
44490 size_t val2 ;
44491 int ecode2 = 0 ;
44492 void *argp3 = 0 ;
44493 int res3 = 0 ;
44494 bool temp4 = false ;
44495 PyObject * obj0 = 0 ;
44496 PyObject * obj1 = 0 ;
44497 PyObject * obj2 = 0 ;
44498 PyObject * obj3 = 0 ;
44499 char * kwnames[] = {
44500 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44501 };
44502
44503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44505 if (!SWIG_IsOK(res1)) {
44506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44507 }
44508 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44509 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44510 if (!SWIG_IsOK(ecode2)) {
44511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44512 }
44513 arg2 = static_cast< size_t >(val2);
44514 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44515 if (!SWIG_IsOK(res3)) {
44516 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44517 }
44518 arg3 = reinterpret_cast< wxMenu * >(argp3);
44519 {
44520 arg4 = wxString_in_helper(obj3);
44521 if (arg4 == NULL) SWIG_fail;
44522 temp4 = true;
44523 }
44524 {
44525 PyThreadState* __tstate = wxPyBeginAllowThreads();
44526 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44527 wxPyEndAllowThreads(__tstate);
44528 if (PyErr_Occurred()) SWIG_fail;
44529 }
44530 {
44531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44532 }
44533 {
44534 if (temp4)
44535 delete arg4;
44536 }
44537 return resultobj;
44538fail:
44539 {
44540 if (temp4)
44541 delete arg4;
44542 }
44543 return NULL;
d55e5bfc
RD
44544}
44545
44546
1bd55598
RD
44547SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44548 PyObject *resultobj = 0;
44549 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44550 size_t result;
44551 void *argp1 = 0 ;
44552 int res1 = 0 ;
44553 PyObject *swig_obj[1] ;
44554
44555 if (!args) SWIG_fail;
44556 swig_obj[0] = args;
44557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44558 if (!SWIG_IsOK(res1)) {
44559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44560 }
44561 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44562 {
44563 PyThreadState* __tstate = wxPyBeginAllowThreads();
44564 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44565 wxPyEndAllowThreads(__tstate);
44566 if (PyErr_Occurred()) SWIG_fail;
44567 }
44568 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44569 return resultobj;
44570fail:
44571 return NULL;
44572}
44573
44574
44575SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44576 PyObject *resultobj = 0;
44577 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44578 size_t arg2 ;
44579 wxMenu *result = 0 ;
44580 void *argp1 = 0 ;
44581 int res1 = 0 ;
44582 size_t val2 ;
44583 int ecode2 = 0 ;
44584 PyObject * obj0 = 0 ;
44585 PyObject * obj1 = 0 ;
44586 char * kwnames[] = {
44587 (char *) "self",(char *) "pos", NULL
44588 };
44589
44590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44592 if (!SWIG_IsOK(res1)) {
44593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44594 }
44595 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44596 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44597 if (!SWIG_IsOK(ecode2)) {
44598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44599 }
44600 arg2 = static_cast< size_t >(val2);
44601 {
44602 PyThreadState* __tstate = wxPyBeginAllowThreads();
44603 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44604 wxPyEndAllowThreads(__tstate);
44605 if (PyErr_Occurred()) SWIG_fail;
44606 }
44607 {
44608 resultobj = wxPyMake_wxObject(result, 0);
44609 }
44610 return resultobj;
44611fail:
44612 return NULL;
44613}
44614
44615
44616SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44617 PyObject *resultobj = 0;
44618 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44619 size_t arg2 ;
44620 wxMenu *arg3 = (wxMenu *) 0 ;
44621 wxString *arg4 = 0 ;
44622 wxMenu *result = 0 ;
44623 void *argp1 = 0 ;
44624 int res1 = 0 ;
44625 size_t val2 ;
44626 int ecode2 = 0 ;
44627 void *argp3 = 0 ;
44628 int res3 = 0 ;
44629 bool temp4 = false ;
44630 PyObject * obj0 = 0 ;
44631 PyObject * obj1 = 0 ;
44632 PyObject * obj2 = 0 ;
44633 PyObject * obj3 = 0 ;
44634 char * kwnames[] = {
44635 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44636 };
44637
44638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44640 if (!SWIG_IsOK(res1)) {
44641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44642 }
44643 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44644 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44645 if (!SWIG_IsOK(ecode2)) {
44646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44647 }
44648 arg2 = static_cast< size_t >(val2);
44649 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44650 if (!SWIG_IsOK(res3)) {
44651 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44652 }
44653 arg3 = reinterpret_cast< wxMenu * >(argp3);
44654 {
44655 arg4 = wxString_in_helper(obj3);
44656 if (arg4 == NULL) SWIG_fail;
44657 temp4 = true;
44658 }
44659 {
44660 PyThreadState* __tstate = wxPyBeginAllowThreads();
44661 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44662 wxPyEndAllowThreads(__tstate);
44663 if (PyErr_Occurred()) SWIG_fail;
44664 }
44665 {
44666 resultobj = wxPyMake_wxObject(result, 0);
44667 }
44668 {
44669 if (temp4)
44670 delete arg4;
44671 }
44672 return resultobj;
44673fail:
44674 {
44675 if (temp4)
44676 delete arg4;
44677 }
44678 return NULL;
44679}
44680
44681
44682SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44683 PyObject *resultobj = 0;
44684 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44685 size_t arg2 ;
44686 wxMenu *result = 0 ;
44687 void *argp1 = 0 ;
44688 int res1 = 0 ;
44689 size_t val2 ;
44690 int ecode2 = 0 ;
44691 PyObject * obj0 = 0 ;
44692 PyObject * obj1 = 0 ;
44693 char * kwnames[] = {
44694 (char *) "self",(char *) "pos", NULL
44695 };
44696
44697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44699 if (!SWIG_IsOK(res1)) {
44700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44701 }
44702 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44703 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44704 if (!SWIG_IsOK(ecode2)) {
44705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44706 }
44707 arg2 = static_cast< size_t >(val2);
44708 {
44709 PyThreadState* __tstate = wxPyBeginAllowThreads();
44710 result = (wxMenu *)(arg1)->Remove(arg2);
44711 wxPyEndAllowThreads(__tstate);
44712 if (PyErr_Occurred()) SWIG_fail;
44713 }
44714 {
44715 resultobj = wxPyMake_wxObject(result, 0);
44716 }
44717 return resultobj;
44718fail:
44719 return NULL;
44720}
44721
44722
44723SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44724 PyObject *resultobj = 0;
44725 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44726 size_t arg2 ;
44727 bool arg3 ;
44728 void *argp1 = 0 ;
44729 int res1 = 0 ;
44730 size_t val2 ;
44731 int ecode2 = 0 ;
44732 bool val3 ;
44733 int ecode3 = 0 ;
44734 PyObject * obj0 = 0 ;
44735 PyObject * obj1 = 0 ;
44736 PyObject * obj2 = 0 ;
44737 char * kwnames[] = {
44738 (char *) "self",(char *) "pos",(char *) "enable", NULL
44739 };
44740
44741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44743 if (!SWIG_IsOK(res1)) {
44744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44745 }
44746 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44747 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44748 if (!SWIG_IsOK(ecode2)) {
44749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44750 }
44751 arg2 = static_cast< size_t >(val2);
44752 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44753 if (!SWIG_IsOK(ecode3)) {
44754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44755 }
44756 arg3 = static_cast< bool >(val3);
44757 {
44758 PyThreadState* __tstate = wxPyBeginAllowThreads();
44759 (arg1)->EnableTop(arg2,arg3);
44760 wxPyEndAllowThreads(__tstate);
44761 if (PyErr_Occurred()) SWIG_fail;
44762 }
44763 resultobj = SWIG_Py_Void();
44764 return resultobj;
44765fail:
44766 return NULL;
44767}
44768
44769
44770SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44771 PyObject *resultobj = 0;
44772 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44773 size_t arg2 ;
44774 bool result;
44775 void *argp1 = 0 ;
44776 int res1 = 0 ;
44777 size_t val2 ;
44778 int ecode2 = 0 ;
44779 PyObject * obj0 = 0 ;
44780 PyObject * obj1 = 0 ;
44781 char * kwnames[] = {
44782 (char *) "self",(char *) "pos", NULL
44783 };
44784
44785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44787 if (!SWIG_IsOK(res1)) {
44788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44789 }
44790 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44791 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44792 if (!SWIG_IsOK(ecode2)) {
44793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44794 }
44795 arg2 = static_cast< size_t >(val2);
44796 {
44797 PyThreadState* __tstate = wxPyBeginAllowThreads();
44798 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44799 wxPyEndAllowThreads(__tstate);
44800 if (PyErr_Occurred()) SWIG_fail;
44801 }
44802 {
44803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44804 }
44805 return resultobj;
44806fail:
44807 return NULL;
44808}
44809
44810
44811SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44812 PyObject *resultobj = 0;
44813 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44814 size_t arg2 ;
44815 wxString *arg3 = 0 ;
44816 void *argp1 = 0 ;
44817 int res1 = 0 ;
44818 size_t val2 ;
44819 int ecode2 = 0 ;
44820 bool temp3 = false ;
44821 PyObject * obj0 = 0 ;
44822 PyObject * obj1 = 0 ;
44823 PyObject * obj2 = 0 ;
44824 char * kwnames[] = {
44825 (char *) "self",(char *) "pos",(char *) "label", NULL
44826 };
44827
44828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44830 if (!SWIG_IsOK(res1)) {
44831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44832 }
44833 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44834 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44835 if (!SWIG_IsOK(ecode2)) {
44836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44837 }
44838 arg2 = static_cast< size_t >(val2);
44839 {
44840 arg3 = wxString_in_helper(obj2);
44841 if (arg3 == NULL) SWIG_fail;
44842 temp3 = true;
44843 }
44844 {
44845 PyThreadState* __tstate = wxPyBeginAllowThreads();
44846 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44847 wxPyEndAllowThreads(__tstate);
44848 if (PyErr_Occurred()) SWIG_fail;
44849 }
44850 resultobj = SWIG_Py_Void();
44851 {
44852 if (temp3)
44853 delete arg3;
44854 }
44855 return resultobj;
44856fail:
44857 {
44858 if (temp3)
44859 delete arg3;
44860 }
44861 return NULL;
44862}
44863
44864
44865SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44866 PyObject *resultobj = 0;
44867 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44868 size_t arg2 ;
44869 wxString result;
44870 void *argp1 = 0 ;
44871 int res1 = 0 ;
44872 size_t val2 ;
44873 int ecode2 = 0 ;
44874 PyObject * obj0 = 0 ;
44875 PyObject * obj1 = 0 ;
44876 char * kwnames[] = {
44877 (char *) "self",(char *) "pos", NULL
44878 };
44879
44880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44882 if (!SWIG_IsOK(res1)) {
44883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44884 }
44885 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44886 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44887 if (!SWIG_IsOK(ecode2)) {
44888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44889 }
44890 arg2 = static_cast< size_t >(val2);
44891 {
44892 PyThreadState* __tstate = wxPyBeginAllowThreads();
44893 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44894 wxPyEndAllowThreads(__tstate);
44895 if (PyErr_Occurred()) SWIG_fail;
44896 }
44897 {
44898#if wxUSE_UNICODE
44899 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44900#else
44901 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44902#endif
44903 }
44904 return resultobj;
44905fail:
44906 return NULL;
44907}
44908
44909
44910SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44911 PyObject *resultobj = 0;
44912 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44913 wxString *arg2 = 0 ;
44914 wxString *arg3 = 0 ;
44915 int result;
44916 void *argp1 = 0 ;
44917 int res1 = 0 ;
44918 bool temp2 = false ;
44919 bool temp3 = false ;
44920 PyObject * obj0 = 0 ;
44921 PyObject * obj1 = 0 ;
44922 PyObject * obj2 = 0 ;
44923 char * kwnames[] = {
44924 (char *) "self",(char *) "menu",(char *) "item", NULL
44925 };
44926
44927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44929 if (!SWIG_IsOK(res1)) {
44930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44931 }
44932 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44933 {
44934 arg2 = wxString_in_helper(obj1);
44935 if (arg2 == NULL) SWIG_fail;
44936 temp2 = true;
44937 }
44938 {
44939 arg3 = wxString_in_helper(obj2);
44940 if (arg3 == NULL) SWIG_fail;
44941 temp3 = true;
44942 }
44943 {
44944 PyThreadState* __tstate = wxPyBeginAllowThreads();
44945 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44946 wxPyEndAllowThreads(__tstate);
44947 if (PyErr_Occurred()) SWIG_fail;
44948 }
44949 resultobj = SWIG_From_int(static_cast< int >(result));
44950 {
44951 if (temp2)
44952 delete arg2;
44953 }
44954 {
44955 if (temp3)
44956 delete arg3;
44957 }
44958 return resultobj;
44959fail:
44960 {
44961 if (temp2)
44962 delete arg2;
44963 }
44964 {
44965 if (temp3)
44966 delete arg3;
44967 }
44968 return NULL;
44969}
44970
44971
44972SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44973 PyObject *resultobj = 0;
44974 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44975 int arg2 ;
44976 wxMenuItem *result = 0 ;
44977 void *argp1 = 0 ;
44978 int res1 = 0 ;
44979 int val2 ;
44980 int ecode2 = 0 ;
44981 PyObject * obj0 = 0 ;
44982 PyObject * obj1 = 0 ;
44983 char * kwnames[] = {
44984 (char *) "self",(char *) "id", NULL
44985 };
44986
44987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44989 if (!SWIG_IsOK(res1)) {
44990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44991 }
44992 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44993 ecode2 = SWIG_AsVal_int(obj1, &val2);
44994 if (!SWIG_IsOK(ecode2)) {
44995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
44996 }
44997 arg2 = static_cast< int >(val2);
44998 {
44999 PyThreadState* __tstate = wxPyBeginAllowThreads();
45000 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45001 wxPyEndAllowThreads(__tstate);
45002 if (PyErr_Occurred()) SWIG_fail;
45003 }
45004 {
45005 resultobj = wxPyMake_wxObject(result, (bool)0);
45006 }
45007 return resultobj;
45008fail:
45009 return NULL;
45010}
45011
45012
45013SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45014 PyObject *resultobj = 0;
45015 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45016 wxString *arg2 = 0 ;
45017 int result;
45018 void *argp1 = 0 ;
45019 int res1 = 0 ;
45020 bool temp2 = false ;
45021 PyObject * obj0 = 0 ;
45022 PyObject * obj1 = 0 ;
45023 char * kwnames[] = {
45024 (char *) "self",(char *) "title", NULL
45025 };
45026
45027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45029 if (!SWIG_IsOK(res1)) {
45030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45031 }
45032 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45033 {
45034 arg2 = wxString_in_helper(obj1);
45035 if (arg2 == NULL) SWIG_fail;
45036 temp2 = true;
45037 }
45038 {
45039 PyThreadState* __tstate = wxPyBeginAllowThreads();
45040 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45041 wxPyEndAllowThreads(__tstate);
45042 if (PyErr_Occurred()) SWIG_fail;
45043 }
45044 resultobj = SWIG_From_int(static_cast< int >(result));
45045 {
45046 if (temp2)
45047 delete arg2;
45048 }
45049 return resultobj;
45050fail:
45051 {
45052 if (temp2)
45053 delete arg2;
45054 }
45055 return NULL;
45056}
45057
45058
45059SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45060 PyObject *resultobj = 0;
45061 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45062 int arg2 ;
45063 bool arg3 ;
45064 void *argp1 = 0 ;
45065 int res1 = 0 ;
45066 int val2 ;
45067 int ecode2 = 0 ;
45068 bool val3 ;
45069 int ecode3 = 0 ;
45070 PyObject * obj0 = 0 ;
45071 PyObject * obj1 = 0 ;
45072 PyObject * obj2 = 0 ;
45073 char * kwnames[] = {
45074 (char *) "self",(char *) "id",(char *) "enable", NULL
45075 };
45076
45077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45079 if (!SWIG_IsOK(res1)) {
45080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45081 }
45082 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45083 ecode2 = SWIG_AsVal_int(obj1, &val2);
45084 if (!SWIG_IsOK(ecode2)) {
45085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45086 }
45087 arg2 = static_cast< int >(val2);
45088 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45089 if (!SWIG_IsOK(ecode3)) {
45090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45091 }
45092 arg3 = static_cast< bool >(val3);
45093 {
45094 PyThreadState* __tstate = wxPyBeginAllowThreads();
45095 (arg1)->Enable(arg2,arg3);
45096 wxPyEndAllowThreads(__tstate);
45097 if (PyErr_Occurred()) SWIG_fail;
45098 }
45099 resultobj = SWIG_Py_Void();
45100 return resultobj;
45101fail:
45102 return NULL;
45103}
45104
45105
45106SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45107 PyObject *resultobj = 0;
45108 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45109 int arg2 ;
45110 bool arg3 ;
45111 void *argp1 = 0 ;
45112 int res1 = 0 ;
45113 int val2 ;
45114 int ecode2 = 0 ;
45115 bool val3 ;
45116 int ecode3 = 0 ;
45117 PyObject * obj0 = 0 ;
45118 PyObject * obj1 = 0 ;
45119 PyObject * obj2 = 0 ;
45120 char * kwnames[] = {
45121 (char *) "self",(char *) "id",(char *) "check", NULL
45122 };
45123
45124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45126 if (!SWIG_IsOK(res1)) {
45127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45128 }
45129 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45130 ecode2 = SWIG_AsVal_int(obj1, &val2);
45131 if (!SWIG_IsOK(ecode2)) {
45132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45133 }
45134 arg2 = static_cast< int >(val2);
45135 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45136 if (!SWIG_IsOK(ecode3)) {
45137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45138 }
45139 arg3 = static_cast< bool >(val3);
45140 {
45141 PyThreadState* __tstate = wxPyBeginAllowThreads();
45142 (arg1)->Check(arg2,arg3);
45143 wxPyEndAllowThreads(__tstate);
45144 if (PyErr_Occurred()) SWIG_fail;
45145 }
45146 resultobj = SWIG_Py_Void();
45147 return resultobj;
45148fail:
45149 return NULL;
45150}
45151
45152
45153SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45154 PyObject *resultobj = 0;
45155 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45156 int arg2 ;
45157 bool result;
45158 void *argp1 = 0 ;
45159 int res1 = 0 ;
45160 int val2 ;
45161 int ecode2 = 0 ;
45162 PyObject * obj0 = 0 ;
45163 PyObject * obj1 = 0 ;
45164 char * kwnames[] = {
45165 (char *) "self",(char *) "id", NULL
45166 };
45167
45168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45170 if (!SWIG_IsOK(res1)) {
45171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45172 }
45173 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45174 ecode2 = SWIG_AsVal_int(obj1, &val2);
45175 if (!SWIG_IsOK(ecode2)) {
45176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45177 }
45178 arg2 = static_cast< int >(val2);
45179 {
45180 PyThreadState* __tstate = wxPyBeginAllowThreads();
45181 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45182 wxPyEndAllowThreads(__tstate);
45183 if (PyErr_Occurred()) SWIG_fail;
45184 }
45185 {
45186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45187 }
45188 return resultobj;
45189fail:
45190 return NULL;
45191}
45192
45193
45194SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45195 PyObject *resultobj = 0;
45196 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45197 int arg2 ;
45198 bool result;
45199 void *argp1 = 0 ;
45200 int res1 = 0 ;
45201 int val2 ;
45202 int ecode2 = 0 ;
45203 PyObject * obj0 = 0 ;
45204 PyObject * obj1 = 0 ;
45205 char * kwnames[] = {
45206 (char *) "self",(char *) "id", NULL
45207 };
45208
45209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45211 if (!SWIG_IsOK(res1)) {
45212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45213 }
45214 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45215 ecode2 = SWIG_AsVal_int(obj1, &val2);
45216 if (!SWIG_IsOK(ecode2)) {
45217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45218 }
45219 arg2 = static_cast< int >(val2);
45220 {
45221 PyThreadState* __tstate = wxPyBeginAllowThreads();
45222 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45223 wxPyEndAllowThreads(__tstate);
45224 if (PyErr_Occurred()) SWIG_fail;
45225 }
45226 {
45227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45228 }
45229 return resultobj;
45230fail:
45231 return NULL;
45232}
45233
45234
45235SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45236 PyObject *resultobj = 0;
45237 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45238 int arg2 ;
45239 wxString *arg3 = 0 ;
45240 void *argp1 = 0 ;
45241 int res1 = 0 ;
45242 int val2 ;
45243 int ecode2 = 0 ;
45244 bool temp3 = false ;
45245 PyObject * obj0 = 0 ;
45246 PyObject * obj1 = 0 ;
45247 PyObject * obj2 = 0 ;
45248 char * kwnames[] = {
45249 (char *) "self",(char *) "id",(char *) "label", NULL
45250 };
45251
45252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45254 if (!SWIG_IsOK(res1)) {
45255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45256 }
45257 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45258 ecode2 = SWIG_AsVal_int(obj1, &val2);
45259 if (!SWIG_IsOK(ecode2)) {
45260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45261 }
45262 arg2 = static_cast< int >(val2);
45263 {
45264 arg3 = wxString_in_helper(obj2);
45265 if (arg3 == NULL) SWIG_fail;
45266 temp3 = true;
45267 }
45268 {
45269 PyThreadState* __tstate = wxPyBeginAllowThreads();
45270 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45271 wxPyEndAllowThreads(__tstate);
45272 if (PyErr_Occurred()) SWIG_fail;
45273 }
45274 resultobj = SWIG_Py_Void();
45275 {
45276 if (temp3)
45277 delete arg3;
45278 }
45279 return resultobj;
45280fail:
45281 {
45282 if (temp3)
45283 delete arg3;
45284 }
45285 return NULL;
45286}
45287
45288
45289SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45290 PyObject *resultobj = 0;
45291 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45292 int arg2 ;
45293 wxString result;
45294 void *argp1 = 0 ;
45295 int res1 = 0 ;
45296 int val2 ;
45297 int ecode2 = 0 ;
45298 PyObject * obj0 = 0 ;
45299 PyObject * obj1 = 0 ;
45300 char * kwnames[] = {
45301 (char *) "self",(char *) "id", NULL
45302 };
45303
45304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45306 if (!SWIG_IsOK(res1)) {
45307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45308 }
45309 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45310 ecode2 = SWIG_AsVal_int(obj1, &val2);
45311 if (!SWIG_IsOK(ecode2)) {
45312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45313 }
45314 arg2 = static_cast< int >(val2);
45315 {
45316 PyThreadState* __tstate = wxPyBeginAllowThreads();
45317 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45318 wxPyEndAllowThreads(__tstate);
45319 if (PyErr_Occurred()) SWIG_fail;
45320 }
45321 {
45322#if wxUSE_UNICODE
45323 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45324#else
45325 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45326#endif
45327 }
45328 return resultobj;
45329fail:
45330 return NULL;
45331}
45332
45333
45334SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45335 PyObject *resultobj = 0;
45336 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45337 int arg2 ;
45338 wxString *arg3 = 0 ;
45339 void *argp1 = 0 ;
45340 int res1 = 0 ;
45341 int val2 ;
45342 int ecode2 = 0 ;
45343 bool temp3 = false ;
45344 PyObject * obj0 = 0 ;
45345 PyObject * obj1 = 0 ;
45346 PyObject * obj2 = 0 ;
45347 char * kwnames[] = {
45348 (char *) "self",(char *) "id",(char *) "helpString", NULL
45349 };
45350
45351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45353 if (!SWIG_IsOK(res1)) {
45354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45355 }
45356 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45357 ecode2 = SWIG_AsVal_int(obj1, &val2);
45358 if (!SWIG_IsOK(ecode2)) {
45359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45360 }
45361 arg2 = static_cast< int >(val2);
45362 {
45363 arg3 = wxString_in_helper(obj2);
45364 if (arg3 == NULL) SWIG_fail;
45365 temp3 = true;
45366 }
45367 {
45368 PyThreadState* __tstate = wxPyBeginAllowThreads();
45369 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45370 wxPyEndAllowThreads(__tstate);
45371 if (PyErr_Occurred()) SWIG_fail;
45372 }
45373 resultobj = SWIG_Py_Void();
45374 {
45375 if (temp3)
45376 delete arg3;
45377 }
45378 return resultobj;
45379fail:
45380 {
45381 if (temp3)
45382 delete arg3;
45383 }
45384 return NULL;
45385}
45386
45387
45388SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45389 PyObject *resultobj = 0;
45390 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45391 int arg2 ;
45392 wxString result;
45393 void *argp1 = 0 ;
45394 int res1 = 0 ;
45395 int val2 ;
45396 int ecode2 = 0 ;
45397 PyObject * obj0 = 0 ;
45398 PyObject * obj1 = 0 ;
45399 char * kwnames[] = {
45400 (char *) "self",(char *) "id", NULL
45401 };
45402
45403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45405 if (!SWIG_IsOK(res1)) {
45406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45407 }
45408 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45409 ecode2 = SWIG_AsVal_int(obj1, &val2);
45410 if (!SWIG_IsOK(ecode2)) {
45411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45412 }
45413 arg2 = static_cast< int >(val2);
45414 {
45415 PyThreadState* __tstate = wxPyBeginAllowThreads();
45416 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45417 wxPyEndAllowThreads(__tstate);
45418 if (PyErr_Occurred()) SWIG_fail;
45419 }
45420 {
45421#if wxUSE_UNICODE
45422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45423#else
45424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45425#endif
45426 }
45427 return resultobj;
45428fail:
45429 return NULL;
d55e5bfc
RD
45430}
45431
45432
1bd55598
RD
45433SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45434 PyObject *resultobj = 0;
45435 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45436 wxFrame *result = 0 ;
45437 void *argp1 = 0 ;
45438 int res1 = 0 ;
45439 PyObject *swig_obj[1] ;
45440
45441 if (!args) SWIG_fail;
45442 swig_obj[0] = args;
45443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45444 if (!SWIG_IsOK(res1)) {
45445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45446 }
45447 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45448 {
45449 PyThreadState* __tstate = wxPyBeginAllowThreads();
45450 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45451 wxPyEndAllowThreads(__tstate);
45452 if (PyErr_Occurred()) SWIG_fail;
45453 }
45454 {
45455 resultobj = wxPyMake_wxObject(result, (bool)0);
45456 }
45457 return resultobj;
45458fail:
45459 return NULL;
d55e5bfc
RD
45460}
45461
45462
1bd55598
RD
45463SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45464 PyObject *resultobj = 0;
45465 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45466 bool result;
45467 void *argp1 = 0 ;
45468 int res1 = 0 ;
45469 PyObject *swig_obj[1] ;
45470
45471 if (!args) SWIG_fail;
45472 swig_obj[0] = args;
45473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45474 if (!SWIG_IsOK(res1)) {
45475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45476 }
45477 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45478 {
45479 PyThreadState* __tstate = wxPyBeginAllowThreads();
45480 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45481 wxPyEndAllowThreads(__tstate);
45482 if (PyErr_Occurred()) SWIG_fail;
45483 }
45484 {
45485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45486 }
45487 return resultobj;
45488fail:
45489 return NULL;
45490}
45491
45492
45493SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45494 PyObject *resultobj = 0;
45495 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45496 wxFrame *arg2 = (wxFrame *) 0 ;
45497 void *argp1 = 0 ;
45498 int res1 = 0 ;
45499 void *argp2 = 0 ;
45500 int res2 = 0 ;
45501 PyObject * obj0 = 0 ;
45502 PyObject * obj1 = 0 ;
45503 char * kwnames[] = {
45504 (char *) "self",(char *) "frame", NULL
45505 };
45506
45507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45509 if (!SWIG_IsOK(res1)) {
45510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45511 }
45512 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45513 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45514 if (!SWIG_IsOK(res2)) {
45515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45516 }
45517 arg2 = reinterpret_cast< wxFrame * >(argp2);
45518 {
45519 PyThreadState* __tstate = wxPyBeginAllowThreads();
45520 (arg1)->Attach(arg2);
45521 wxPyEndAllowThreads(__tstate);
45522 if (PyErr_Occurred()) SWIG_fail;
45523 }
45524 resultobj = SWIG_Py_Void();
45525 return resultobj;
45526fail:
45527 return NULL;
d55e5bfc
RD
45528}
45529
45530
1bd55598
RD
45531SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45532 PyObject *resultobj = 0;
45533 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45534 void *argp1 = 0 ;
45535 int res1 = 0 ;
45536 PyObject *swig_obj[1] ;
45537
45538 if (!args) SWIG_fail;
45539 swig_obj[0] = args;
45540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45541 if (!SWIG_IsOK(res1)) {
45542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45543 }
45544 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45545 {
45546 PyThreadState* __tstate = wxPyBeginAllowThreads();
45547 (arg1)->Detach();
45548 wxPyEndAllowThreads(__tstate);
45549 if (PyErr_Occurred()) SWIG_fail;
45550 }
45551 resultobj = SWIG_Py_Void();
45552 return resultobj;
45553fail:
45554 return NULL;
d55e5bfc
RD
45555}
45556
45557
587d0f36
RD
45558SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45559 PyObject *resultobj = 0;
45560 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45561 void *argp1 = 0 ;
45562 int res1 = 0 ;
45563 PyObject *swig_obj[1] ;
45564
45565 if (!args) SWIG_fail;
45566 swig_obj[0] = args;
45567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45568 if (!SWIG_IsOK(res1)) {
45569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45570 }
45571 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45572 {
45573 PyThreadState* __tstate = wxPyBeginAllowThreads();
45574 (arg1)->UpdateMenus();
45575 wxPyEndAllowThreads(__tstate);
45576 if (PyErr_Occurred()) SWIG_fail;
45577 }
45578 resultobj = SWIG_Py_Void();
45579 return resultobj;
45580fail:
45581 return NULL;
45582}
45583
45584
1bd55598
RD
45585SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45586 PyObject *resultobj = 0;
45587 bool arg1 ;
45588 bool val1 ;
45589 int ecode1 = 0 ;
45590 PyObject * obj0 = 0 ;
45591 char * kwnames[] = {
45592 (char *) "enable", NULL
45593 };
45594
45595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45596 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45597 if (!SWIG_IsOK(ecode1)) {
45598 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45599 }
45600 arg1 = static_cast< bool >(val1);
45601 {
45602 PyThreadState* __tstate = wxPyBeginAllowThreads();
45603 wxMenuBar::SetAutoWindowMenu(arg1);
45604 wxPyEndAllowThreads(__tstate);
45605 if (PyErr_Occurred()) SWIG_fail;
45606 }
45607 resultobj = SWIG_Py_Void();
45608 return resultobj;
45609fail:
45610 return NULL;
d55e5bfc
RD
45611}
45612
45613
1bd55598
RD
45614SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45615 PyObject *resultobj = 0;
45616 bool result;
45617
45618 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45619 {
45620 PyThreadState* __tstate = wxPyBeginAllowThreads();
45621 result = (bool)wxMenuBar::GetAutoWindowMenu();
45622 wxPyEndAllowThreads(__tstate);
45623 if (PyErr_Occurred()) SWIG_fail;
45624 }
45625 {
45626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45627 }
45628 return resultobj;
45629fail:
45630 return NULL;
45631}
45632
45633
45634SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45635 PyObject *obj;
45636 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45637 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45638 return SWIG_Py_Void();
45639}
45640
45641SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45642 return SWIG_Python_InitShadowInstance(args);
45643}
45644
45645SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45646 PyObject *resultobj = 0;
45647 wxMenu *arg1 = (wxMenu *) NULL ;
45648 int arg2 = (int) wxID_ANY ;
45649 wxString const &arg3_defvalue = wxPyEmptyString ;
45650 wxString *arg3 = (wxString *) &arg3_defvalue ;
45651 wxString const &arg4_defvalue = wxPyEmptyString ;
45652 wxString *arg4 = (wxString *) &arg4_defvalue ;
45653 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45654 wxMenu *arg6 = (wxMenu *) NULL ;
45655 wxMenuItem *result = 0 ;
45656 void *argp1 = 0 ;
45657 int res1 = 0 ;
45658 int val2 ;
45659 int ecode2 = 0 ;
45660 bool temp3 = false ;
45661 bool temp4 = false ;
45662 int val5 ;
45663 int ecode5 = 0 ;
45664 void *argp6 = 0 ;
45665 int res6 = 0 ;
45666 PyObject * obj0 = 0 ;
45667 PyObject * obj1 = 0 ;
45668 PyObject * obj2 = 0 ;
45669 PyObject * obj3 = 0 ;
45670 PyObject * obj4 = 0 ;
45671 PyObject * obj5 = 0 ;
45672 char * kwnames[] = {
45673 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45674 };
45675
45676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45677 if (obj0) {
45678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45679 if (!SWIG_IsOK(res1)) {
45680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
d55e5bfc 45681 }
1bd55598
RD
45682 arg1 = reinterpret_cast< wxMenu * >(argp1);
45683 }
45684 if (obj1) {
45685 ecode2 = SWIG_AsVal_int(obj1, &val2);
45686 if (!SWIG_IsOK(ecode2)) {
45687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45688 }
45689 arg2 = static_cast< int >(val2);
45690 }
45691 if (obj2) {
d55e5bfc 45692 {
1bd55598
RD
45693 arg3 = wxString_in_helper(obj2);
45694 if (arg3 == NULL) SWIG_fail;
45695 temp3 = true;
d55e5bfc 45696 }
1bd55598
RD
45697 }
45698 if (obj3) {
d55e5bfc 45699 {
1bd55598
RD
45700 arg4 = wxString_in_helper(obj3);
45701 if (arg4 == NULL) SWIG_fail;
45702 temp4 = true;
36ed4f51 45703 }
1bd55598
RD
45704 }
45705 if (obj4) {
45706 ecode5 = SWIG_AsVal_int(obj4, &val5);
45707 if (!SWIG_IsOK(ecode5)) {
45708 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45709 }
45710 arg5 = static_cast< wxItemKind >(val5);
45711 }
45712 if (obj5) {
45713 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45714 if (!SWIG_IsOK(res6)) {
45715 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
5cbf236d 45716 }
1bd55598
RD
45717 arg6 = reinterpret_cast< wxMenu * >(argp6);
45718 }
45719 {
45720 PyThreadState* __tstate = wxPyBeginAllowThreads();
45721 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45722 wxPyEndAllowThreads(__tstate);
45723 if (PyErr_Occurred()) SWIG_fail;
45724 }
3ecece7e 45725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
1bd55598
RD
45726 {
45727 if (temp3)
45728 delete arg3;
45729 }
45730 {
45731 if (temp4)
45732 delete arg4;
45733 }
45734 return resultobj;
45735fail:
45736 {
45737 if (temp3)
45738 delete arg3;
45739 }
45740 {
45741 if (temp4)
45742 delete arg4;
45743 }
45744 return NULL;
5cbf236d
RD
45745}
45746
45747
1bd55598
RD
45748SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45749 PyObject *resultobj = 0;
45750 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45751 void *argp1 = 0 ;
45752 int res1 = 0 ;
45753 PyObject *swig_obj[1] ;
45754
45755 if (!args) SWIG_fail;
45756 swig_obj[0] = args;
45757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45758 if (!SWIG_IsOK(res1)) {
45759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45760 }
45761 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45762 {
45763 PyThreadState* __tstate = wxPyBeginAllowThreads();
45764 delete arg1;
5cbf236d 45765
1bd55598
RD
45766 wxPyEndAllowThreads(__tstate);
45767 if (PyErr_Occurred()) SWIG_fail;
45768 }
45769 resultobj = SWIG_Py_Void();
45770 return resultobj;
45771fail:
45772 return NULL;
5cbf236d
RD
45773}
45774
45775
1bd55598
RD
45776SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45777 PyObject *resultobj = 0;
45778 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45779 wxMenu *result = 0 ;
45780 void *argp1 = 0 ;
45781 int res1 = 0 ;
45782 PyObject *swig_obj[1] ;
45783
45784 if (!args) SWIG_fail;
45785 swig_obj[0] = args;
45786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45787 if (!SWIG_IsOK(res1)) {
45788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45789 }
45790 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45791 {
45792 PyThreadState* __tstate = wxPyBeginAllowThreads();
45793 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45794 wxPyEndAllowThreads(__tstate);
45795 if (PyErr_Occurred()) SWIG_fail;
45796 }
45797 {
45798 resultobj = wxPyMake_wxObject(result, 0);
45799 }
45800 return resultobj;
45801fail:
45802 return NULL;
45803}
45804
45805
45806SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45807 PyObject *resultobj = 0;
45808 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45809 wxMenu *arg2 = (wxMenu *) 0 ;
45810 void *argp1 = 0 ;
45811 int res1 = 0 ;
45812 void *argp2 = 0 ;
45813 int res2 = 0 ;
45814 PyObject * obj0 = 0 ;
45815 PyObject * obj1 = 0 ;
45816 char * kwnames[] = {
45817 (char *) "self",(char *) "menu", NULL
45818 };
45819
45820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45822 if (!SWIG_IsOK(res1)) {
45823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45824 }
45825 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45826 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45827 if (!SWIG_IsOK(res2)) {
45828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45829 }
45830 arg2 = reinterpret_cast< wxMenu * >(argp2);
45831 {
45832 PyThreadState* __tstate = wxPyBeginAllowThreads();
45833 (arg1)->SetMenu(arg2);
45834 wxPyEndAllowThreads(__tstate);
45835 if (PyErr_Occurred()) SWIG_fail;
45836 }
45837 resultobj = SWIG_Py_Void();
45838 return resultobj;
45839fail:
45840 return NULL;
45841}
45842
45843
45844SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45845 PyObject *resultobj = 0;
45846 wxMenuItem *arg1 = (wxMenuItem *) 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 *) "id", NULL
45856 };
45857
45858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45860 if (!SWIG_IsOK(res1)) {
45861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45862 }
45863 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45864 ecode2 = SWIG_AsVal_int(obj1, &val2);
45865 if (!SWIG_IsOK(ecode2)) {
45866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45867 }
45868 arg2 = static_cast< int >(val2);
45869 {
45870 PyThreadState* __tstate = wxPyBeginAllowThreads();
45871 (arg1)->SetId(arg2);
45872 wxPyEndAllowThreads(__tstate);
45873 if (PyErr_Occurred()) SWIG_fail;
45874 }
45875 resultobj = SWIG_Py_Void();
45876 return resultobj;
45877fail:
45878 return NULL;
b411df4a
RD
45879}
45880
45881
1bd55598
RD
45882SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45883 PyObject *resultobj = 0;
45884 wxMenuItem *arg1 = (wxMenuItem *) 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_wxMenuItem, 0 | 0 );
45893 if (!SWIG_IsOK(res1)) {
45894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45895 }
45896 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45897 {
45898 PyThreadState* __tstate = wxPyBeginAllowThreads();
45899 result = (int)((wxMenuItem const *)arg1)->GetId();
45900 wxPyEndAllowThreads(__tstate);
45901 if (PyErr_Occurred()) SWIG_fail;
45902 }
45903 resultobj = SWIG_From_int(static_cast< int >(result));
45904 return resultobj;
45905fail:
45906 return NULL;
b411df4a
RD
45907}
45908
45909
1bd55598
RD
45910SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45911 PyObject *resultobj = 0;
45912 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45913 bool result;
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_wxMenuItem, 0 | 0 );
45921 if (!SWIG_IsOK(res1)) {
45922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45923 }
45924 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45925 {
45926 PyThreadState* __tstate = wxPyBeginAllowThreads();
45927 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45928 wxPyEndAllowThreads(__tstate);
45929 if (PyErr_Occurred()) SWIG_fail;
45930 }
45931 {
45932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45933 }
45934 return resultobj;
45935fail:
45936 return NULL;
45937}
45938
45939
45940SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45941 PyObject *resultobj = 0;
45942 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45943 wxString *arg2 = 0 ;
45944 void *argp1 = 0 ;
45945 int res1 = 0 ;
45946 bool temp2 = false ;
45947 PyObject * obj0 = 0 ;
45948 PyObject * obj1 = 0 ;
45949 char * kwnames[] = {
45950 (char *) "self",(char *) "str", NULL
45951 };
45952
45953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45955 if (!SWIG_IsOK(res1)) {
45956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45957 }
45958 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45959 {
45960 arg2 = wxString_in_helper(obj1);
45961 if (arg2 == NULL) SWIG_fail;
45962 temp2 = true;
45963 }
45964 {
45965 PyThreadState* __tstate = wxPyBeginAllowThreads();
45966 (arg1)->SetText((wxString const &)*arg2);
45967 wxPyEndAllowThreads(__tstate);
45968 if (PyErr_Occurred()) SWIG_fail;
45969 }
45970 resultobj = SWIG_Py_Void();
45971 {
45972 if (temp2)
45973 delete arg2;
45974 }
45975 return resultobj;
45976fail:
45977 {
45978 if (temp2)
45979 delete arg2;
45980 }
45981 return NULL;
b411df4a
RD
45982}
45983
45984
1bd55598
RD
45985SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45986 PyObject *resultobj = 0;
45987 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45988 wxString result;
45989 void *argp1 = 0 ;
45990 int res1 = 0 ;
45991 PyObject *swig_obj[1] ;
45992
45993 if (!args) SWIG_fail;
45994 swig_obj[0] = args;
45995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45996 if (!SWIG_IsOK(res1)) {
45997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45998 }
45999 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46000 {
46001 PyThreadState* __tstate = wxPyBeginAllowThreads();
46002 result = ((wxMenuItem const *)arg1)->GetLabel();
46003 wxPyEndAllowThreads(__tstate);
46004 if (PyErr_Occurred()) SWIG_fail;
46005 }
46006 {
46007#if wxUSE_UNICODE
46008 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46009#else
46010 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46011#endif
46012 }
46013 return resultobj;
46014fail:
46015 return NULL;
b411df4a
RD
46016}
46017
46018
1bd55598
RD
46019SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46020 PyObject *resultobj = 0;
46021 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46022 wxString *result = 0 ;
46023 void *argp1 = 0 ;
46024 int res1 = 0 ;
46025 PyObject *swig_obj[1] ;
46026
46027 if (!args) SWIG_fail;
46028 swig_obj[0] = args;
46029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46030 if (!SWIG_IsOK(res1)) {
46031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46032 }
46033 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46034 {
46035 PyThreadState* __tstate = wxPyBeginAllowThreads();
b411df4a 46036 {
1bd55598
RD
46037 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46038 result = (wxString *) &_result_ref;
b411df4a 46039 }
1bd55598
RD
46040 wxPyEndAllowThreads(__tstate);
46041 if (PyErr_Occurred()) SWIG_fail;
46042 }
46043 {
46044#if wxUSE_UNICODE
46045 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46046#else
46047 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46048#endif
46049 }
46050 return resultobj;
46051fail:
46052 return NULL;
b411df4a
RD
46053}
46054
46055
1bd55598
RD
46056SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46057 PyObject *resultobj = 0;
46058 wxString *arg1 = 0 ;
46059 wxString result;
46060 bool temp1 = false ;
46061 PyObject * obj0 = 0 ;
46062 char * kwnames[] = {
46063 (char *) "text", NULL
46064 };
46065
46066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46067 {
46068 arg1 = wxString_in_helper(obj0);
46069 if (arg1 == NULL) SWIG_fail;
46070 temp1 = true;
46071 }
46072 {
46073 PyThreadState* __tstate = wxPyBeginAllowThreads();
46074 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46075 wxPyEndAllowThreads(__tstate);
46076 if (PyErr_Occurred()) SWIG_fail;
46077 }
46078 {
46079#if wxUSE_UNICODE
46080 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46081#else
46082 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46083#endif
46084 }
46085 {
46086 if (temp1)
46087 delete arg1;
46088 }
46089 return resultobj;
46090fail:
46091 {
46092 if (temp1)
46093 delete arg1;
46094 }
46095 return NULL;
b411df4a
RD
46096}
46097
46098
1bd55598
RD
46099SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46100 PyObject *resultobj = 0;
46101 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46102 wxItemKind result;
46103 void *argp1 = 0 ;
46104 int res1 = 0 ;
46105 PyObject *swig_obj[1] ;
46106
46107 if (!args) SWIG_fail;
46108 swig_obj[0] = args;
46109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46110 if (!SWIG_IsOK(res1)) {
46111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46112 }
46113 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46114 {
46115 PyThreadState* __tstate = wxPyBeginAllowThreads();
46116 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46117 wxPyEndAllowThreads(__tstate);
46118 if (PyErr_Occurred()) SWIG_fail;
46119 }
46120 resultobj = SWIG_From_int(static_cast< int >(result));
46121 return resultobj;
46122fail:
46123 return NULL;
46124}
46125
46126
46127SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46128 PyObject *resultobj = 0;
46129 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46130 wxItemKind arg2 ;
46131 void *argp1 = 0 ;
46132 int res1 = 0 ;
46133 int val2 ;
46134 int ecode2 = 0 ;
46135 PyObject * obj0 = 0 ;
46136 PyObject * obj1 = 0 ;
46137 char * kwnames[] = {
46138 (char *) "self",(char *) "kind", NULL
46139 };
46140
46141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46143 if (!SWIG_IsOK(res1)) {
46144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46145 }
46146 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46147 ecode2 = SWIG_AsVal_int(obj1, &val2);
46148 if (!SWIG_IsOK(ecode2)) {
46149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46150 }
46151 arg2 = static_cast< wxItemKind >(val2);
46152 {
46153 PyThreadState* __tstate = wxPyBeginAllowThreads();
46154 (arg1)->SetKind(arg2);
46155 wxPyEndAllowThreads(__tstate);
46156 if (PyErr_Occurred()) SWIG_fail;
46157 }
46158 resultobj = SWIG_Py_Void();
46159 return resultobj;
46160fail:
46161 return NULL;
46162}
46163
46164
46165SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46166 PyObject *resultobj = 0;
46167 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46168 bool arg2 ;
46169 void *argp1 = 0 ;
46170 int res1 = 0 ;
46171 bool val2 ;
46172 int ecode2 = 0 ;
46173 PyObject * obj0 = 0 ;
46174 PyObject * obj1 = 0 ;
46175 char * kwnames[] = {
46176 (char *) "self",(char *) "checkable", NULL
46177 };
46178
46179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46181 if (!SWIG_IsOK(res1)) {
46182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46183 }
46184 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46185 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46186 if (!SWIG_IsOK(ecode2)) {
46187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46188 }
46189 arg2 = static_cast< bool >(val2);
46190 {
46191 PyThreadState* __tstate = wxPyBeginAllowThreads();
46192 (arg1)->SetCheckable(arg2);
46193 wxPyEndAllowThreads(__tstate);
46194 if (PyErr_Occurred()) SWIG_fail;
46195 }
46196 resultobj = SWIG_Py_Void();
46197 return resultobj;
46198fail:
46199 return NULL;
b411df4a
RD
46200}
46201
46202
1bd55598
RD
46203SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46204 PyObject *resultobj = 0;
46205 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46206 bool result;
46207 void *argp1 = 0 ;
46208 int res1 = 0 ;
46209 PyObject *swig_obj[1] ;
46210
46211 if (!args) SWIG_fail;
46212 swig_obj[0] = args;
46213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46214 if (!SWIG_IsOK(res1)) {
46215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46216 }
46217 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46218 {
46219 PyThreadState* __tstate = wxPyBeginAllowThreads();
46220 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46221 wxPyEndAllowThreads(__tstate);
46222 if (PyErr_Occurred()) SWIG_fail;
46223 }
46224 {
46225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46226 }
46227 return resultobj;
46228fail:
46229 return NULL;
b411df4a
RD
46230}
46231
46232
1bd55598
RD
46233SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46234 PyObject *resultobj = 0;
46235 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46236 bool result;
46237 void *argp1 = 0 ;
46238 int res1 = 0 ;
46239 PyObject *swig_obj[1] ;
46240
46241 if (!args) SWIG_fail;
46242 swig_obj[0] = args;
46243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46244 if (!SWIG_IsOK(res1)) {
46245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46246 }
46247 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46248 {
46249 PyThreadState* __tstate = wxPyBeginAllowThreads();
46250 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46251 wxPyEndAllowThreads(__tstate);
46252 if (PyErr_Occurred()) SWIG_fail;
46253 }
46254 {
46255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46256 }
46257 return resultobj;
46258fail:
46259 return NULL;
46260}
46261
46262
46263SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46264 PyObject *resultobj = 0;
46265 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46266 wxMenu *arg2 = (wxMenu *) 0 ;
46267 void *argp1 = 0 ;
46268 int res1 = 0 ;
46269 void *argp2 = 0 ;
46270 int res2 = 0 ;
46271 PyObject * obj0 = 0 ;
46272 PyObject * obj1 = 0 ;
46273 char * kwnames[] = {
46274 (char *) "self",(char *) "menu", NULL
46275 };
46276
46277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46279 if (!SWIG_IsOK(res1)) {
46280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46281 }
46282 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46283 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46284 if (!SWIG_IsOK(res2)) {
46285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46286 }
46287 arg2 = reinterpret_cast< wxMenu * >(argp2);
46288 {
46289 PyThreadState* __tstate = wxPyBeginAllowThreads();
46290 (arg1)->SetSubMenu(arg2);
46291 wxPyEndAllowThreads(__tstate);
46292 if (PyErr_Occurred()) SWIG_fail;
46293 }
46294 resultobj = SWIG_Py_Void();
46295 return resultobj;
46296fail:
46297 return NULL;
b411df4a
RD
46298}
46299
46300
1bd55598
RD
46301SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46302 PyObject *resultobj = 0;
46303 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46304 wxMenu *result = 0 ;
46305 void *argp1 = 0 ;
46306 int res1 = 0 ;
46307 PyObject *swig_obj[1] ;
46308
46309 if (!args) SWIG_fail;
46310 swig_obj[0] = args;
46311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46312 if (!SWIG_IsOK(res1)) {
46313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46314 }
46315 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46316 {
46317 PyThreadState* __tstate = wxPyBeginAllowThreads();
46318 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46319 wxPyEndAllowThreads(__tstate);
46320 if (PyErr_Occurred()) SWIG_fail;
46321 }
46322 {
46323 resultobj = wxPyMake_wxObject(result, 0);
46324 }
46325 return resultobj;
46326fail:
46327 return NULL;
46328}
46329
46330
46331SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46332 PyObject *resultobj = 0;
46333 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46334 bool arg2 = (bool) true ;
46335 void *argp1 = 0 ;
46336 int res1 = 0 ;
46337 bool val2 ;
46338 int ecode2 = 0 ;
46339 PyObject * obj0 = 0 ;
46340 PyObject * obj1 = 0 ;
46341 char * kwnames[] = {
46342 (char *) "self",(char *) "enable", NULL
46343 };
46344
46345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46347 if (!SWIG_IsOK(res1)) {
46348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46349 }
46350 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46351 if (obj1) {
46352 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46353 if (!SWIG_IsOK(ecode2)) {
46354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46355 }
46356 arg2 = static_cast< bool >(val2);
46357 }
46358 {
46359 PyThreadState* __tstate = wxPyBeginAllowThreads();
46360 (arg1)->Enable(arg2);
46361 wxPyEndAllowThreads(__tstate);
46362 if (PyErr_Occurred()) SWIG_fail;
46363 }
46364 resultobj = SWIG_Py_Void();
46365 return resultobj;
46366fail:
46367 return NULL;
32fe5131
RD
46368}
46369
46370
1bd55598
RD
46371SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46372 PyObject *resultobj = 0;
46373 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46374 bool result;
46375 void *argp1 = 0 ;
46376 int res1 = 0 ;
46377 PyObject *swig_obj[1] ;
46378
46379 if (!args) SWIG_fail;
46380 swig_obj[0] = args;
46381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46382 if (!SWIG_IsOK(res1)) {
46383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46384 }
46385 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46386 {
46387 PyThreadState* __tstate = wxPyBeginAllowThreads();
46388 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46389 wxPyEndAllowThreads(__tstate);
46390 if (PyErr_Occurred()) SWIG_fail;
46391 }
46392 {
46393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46394 }
46395 return resultobj;
46396fail:
46397 return NULL;
46398}
46399
46400
46401SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46402 PyObject *resultobj = 0;
46403 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46404 bool arg2 = (bool) true ;
46405 void *argp1 = 0 ;
46406 int res1 = 0 ;
46407 bool val2 ;
46408 int ecode2 = 0 ;
46409 PyObject * obj0 = 0 ;
46410 PyObject * obj1 = 0 ;
46411 char * kwnames[] = {
46412 (char *) "self",(char *) "check", NULL
46413 };
46414
46415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46417 if (!SWIG_IsOK(res1)) {
46418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46419 }
46420 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46421 if (obj1) {
46422 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46423 if (!SWIG_IsOK(ecode2)) {
46424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46425 }
46426 arg2 = static_cast< bool >(val2);
46427 }
46428 {
46429 PyThreadState* __tstate = wxPyBeginAllowThreads();
46430 (arg1)->Check(arg2);
46431 wxPyEndAllowThreads(__tstate);
46432 if (PyErr_Occurred()) SWIG_fail;
46433 }
46434 resultobj = SWIG_Py_Void();
46435 return resultobj;
46436fail:
46437 return NULL;
32fe5131
RD
46438}
46439
46440
1bd55598
RD
46441SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46442 PyObject *resultobj = 0;
46443 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46444 bool result;
46445 void *argp1 = 0 ;
46446 int res1 = 0 ;
46447 PyObject *swig_obj[1] ;
46448
46449 if (!args) SWIG_fail;
46450 swig_obj[0] = args;
46451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46452 if (!SWIG_IsOK(res1)) {
46453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46454 }
46455 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46456 {
46457 PyThreadState* __tstate = wxPyBeginAllowThreads();
46458 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46459 wxPyEndAllowThreads(__tstate);
46460 if (PyErr_Occurred()) SWIG_fail;
46461 }
46462 {
46463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46464 }
46465 return resultobj;
46466fail:
46467 return NULL;
d55e5bfc
RD
46468}
46469
46470
1bd55598
RD
46471SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46472 PyObject *resultobj = 0;
46473 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46474 void *argp1 = 0 ;
46475 int res1 = 0 ;
46476 PyObject *swig_obj[1] ;
46477
46478 if (!args) SWIG_fail;
46479 swig_obj[0] = args;
46480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46481 if (!SWIG_IsOK(res1)) {
46482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46483 }
46484 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46485 {
46486 PyThreadState* __tstate = wxPyBeginAllowThreads();
46487 (arg1)->Toggle();
46488 wxPyEndAllowThreads(__tstate);
46489 if (PyErr_Occurred()) SWIG_fail;
46490 }
46491 resultobj = SWIG_Py_Void();
46492 return resultobj;
46493fail:
46494 return NULL;
46495}
46496
46497
46498SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46499 PyObject *resultobj = 0;
46500 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46501 wxString *arg2 = 0 ;
46502 void *argp1 = 0 ;
46503 int res1 = 0 ;
46504 bool temp2 = false ;
46505 PyObject * obj0 = 0 ;
46506 PyObject * obj1 = 0 ;
46507 char * kwnames[] = {
46508 (char *) "self",(char *) "str", NULL
46509 };
46510
46511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46513 if (!SWIG_IsOK(res1)) {
46514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46515 }
46516 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46517 {
46518 arg2 = wxString_in_helper(obj1);
46519 if (arg2 == NULL) SWIG_fail;
46520 temp2 = true;
46521 }
46522 {
46523 PyThreadState* __tstate = wxPyBeginAllowThreads();
46524 (arg1)->SetHelp((wxString const &)*arg2);
46525 wxPyEndAllowThreads(__tstate);
46526 if (PyErr_Occurred()) SWIG_fail;
46527 }
46528 resultobj = SWIG_Py_Void();
46529 {
46530 if (temp2)
46531 delete arg2;
46532 }
46533 return resultobj;
46534fail:
46535 {
46536 if (temp2)
46537 delete arg2;
46538 }
46539 return NULL;
d55e5bfc
RD
46540}
46541
46542
1bd55598
RD
46543SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46544 PyObject *resultobj = 0;
46545 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46546 wxString *result = 0 ;
46547 void *argp1 = 0 ;
46548 int res1 = 0 ;
46549 PyObject *swig_obj[1] ;
46550
46551 if (!args) SWIG_fail;
46552 swig_obj[0] = args;
46553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46554 if (!SWIG_IsOK(res1)) {
46555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46556 }
46557 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46558 {
46559 PyThreadState* __tstate = wxPyBeginAllowThreads();
d55e5bfc 46560 {
1bd55598
RD
46561 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46562 result = (wxString *) &_result_ref;
d55e5bfc 46563 }
1bd55598
RD
46564 wxPyEndAllowThreads(__tstate);
46565 if (PyErr_Occurred()) SWIG_fail;
46566 }
46567 {
46568#if wxUSE_UNICODE
46569 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46570#else
46571 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46572#endif
46573 }
46574 return resultobj;
46575fail:
46576 return NULL;
d55e5bfc
RD
46577}
46578
46579
1bd55598
RD
46580SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46581 PyObject *resultobj = 0;
46582 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46583 wxAcceleratorEntry *result = 0 ;
46584 void *argp1 = 0 ;
46585 int res1 = 0 ;
46586 PyObject *swig_obj[1] ;
46587
46588 if (!args) SWIG_fail;
46589 swig_obj[0] = args;
46590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46591 if (!SWIG_IsOK(res1)) {
46592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46593 }
46594 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46595 {
46596 PyThreadState* __tstate = wxPyBeginAllowThreads();
46597 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46598 wxPyEndAllowThreads(__tstate);
46599 if (PyErr_Occurred()) SWIG_fail;
46600 }
46601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46602 return resultobj;
46603fail:
46604 return NULL;
46605}
46606
46607
46608SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46609 PyObject *resultobj = 0;
46610 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46611 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46612 void *argp1 = 0 ;
46613 int res1 = 0 ;
46614 void *argp2 = 0 ;
46615 int res2 = 0 ;
46616 PyObject * obj0 = 0 ;
46617 PyObject * obj1 = 0 ;
46618 char * kwnames[] = {
46619 (char *) "self",(char *) "accel", NULL
46620 };
46621
46622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46624 if (!SWIG_IsOK(res1)) {
46625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46626 }
46627 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46628 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46629 if (!SWIG_IsOK(res2)) {
46630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46631 }
46632 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46633 {
46634 PyThreadState* __tstate = wxPyBeginAllowThreads();
46635 (arg1)->SetAccel(arg2);
46636 wxPyEndAllowThreads(__tstate);
46637 if (PyErr_Occurred()) SWIG_fail;
46638 }
46639 resultobj = SWIG_Py_Void();
46640 return resultobj;
46641fail:
46642 return NULL;
46643}
46644
46645
46646SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46647 PyObject *resultobj = 0;
46648 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46649 wxBitmap *arg2 = 0 ;
46650 void *argp1 = 0 ;
46651 int res1 = 0 ;
46652 void *argp2 = 0 ;
46653 int res2 = 0 ;
46654 PyObject * obj0 = 0 ;
46655 PyObject * obj1 = 0 ;
46656 char * kwnames[] = {
46657 (char *) "self",(char *) "bitmap", NULL
46658 };
46659
46660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46662 if (!SWIG_IsOK(res1)) {
46663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46664 }
46665 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46666 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46667 if (!SWIG_IsOK(res2)) {
46668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46669 }
46670 if (!argp2) {
46671 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46672 }
46673 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46674 {
46675 PyThreadState* __tstate = wxPyBeginAllowThreads();
46676 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46677 wxPyEndAllowThreads(__tstate);
46678 if (PyErr_Occurred()) SWIG_fail;
46679 }
46680 resultobj = SWIG_Py_Void();
46681 return resultobj;
46682fail:
46683 return NULL;
d55e5bfc
RD
46684}
46685
46686
1bd55598
RD
46687SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46688 PyObject *resultobj = 0;
46689 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46690 wxBitmap *result = 0 ;
46691 void *argp1 = 0 ;
46692 int res1 = 0 ;
46693 PyObject *swig_obj[1] ;
46694
46695 if (!args) SWIG_fail;
46696 swig_obj[0] = args;
46697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46698 if (!SWIG_IsOK(res1)) {
46699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46700 }
46701 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46702 {
46703 PyThreadState* __tstate = wxPyBeginAllowThreads();
36ed4f51 46704 {
1bd55598
RD
46705 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46706 result = (wxBitmap *) &_result_ref;
36ed4f51 46707 }
1bd55598
RD
46708 wxPyEndAllowThreads(__tstate);
46709 if (PyErr_Occurred()) SWIG_fail;
46710 }
46711 {
46712 wxBitmap* resultptr = new wxBitmap(*result);
46713 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46714 }
46715 return resultobj;
46716fail:
46717 return NULL;
46718}
46719
46720
46721SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46722 PyObject *resultobj = 0;
46723 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46724 wxFont *arg2 = 0 ;
46725 void *argp1 = 0 ;
46726 int res1 = 0 ;
46727 void *argp2 = 0 ;
46728 int res2 = 0 ;
46729 PyObject * obj0 = 0 ;
46730 PyObject * obj1 = 0 ;
46731 char * kwnames[] = {
46732 (char *) "self",(char *) "font", NULL
46733 };
46734
46735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46737 if (!SWIG_IsOK(res1)) {
46738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46739 }
46740 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46741 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46742 if (!SWIG_IsOK(res2)) {
46743 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46744 }
46745 if (!argp2) {
46746 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46747 }
46748 arg2 = reinterpret_cast< wxFont * >(argp2);
46749 {
46750 PyThreadState* __tstate = wxPyBeginAllowThreads();
46751 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
46752 wxPyEndAllowThreads(__tstate);
46753 if (PyErr_Occurred()) SWIG_fail;
46754 }
46755 resultobj = SWIG_Py_Void();
46756 return resultobj;
46757fail:
46758 return NULL;
d55e5bfc
RD
46759}
46760
46761
1bd55598
RD
46762SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46763 PyObject *resultobj = 0;
46764 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46765 wxFont result;
46766 void *argp1 = 0 ;
46767 int res1 = 0 ;
46768 PyObject *swig_obj[1] ;
46769
46770 if (!args) SWIG_fail;
46771 swig_obj[0] = args;
46772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46773 if (!SWIG_IsOK(res1)) {
46774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46775 }
46776 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46777 {
46778 PyThreadState* __tstate = wxPyBeginAllowThreads();
46779 result = wxMenuItem_GetFont(arg1);
46780 wxPyEndAllowThreads(__tstate);
46781 if (PyErr_Occurred()) SWIG_fail;
46782 }
46783 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46784 return resultobj;
46785fail:
46786 return NULL;
46787}
46788
46789
46790SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46791 PyObject *resultobj = 0;
46792 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46793 wxColour *arg2 = 0 ;
46794 void *argp1 = 0 ;
46795 int res1 = 0 ;
46796 wxColour temp2 ;
46797 PyObject * obj0 = 0 ;
46798 PyObject * obj1 = 0 ;
46799 char * kwnames[] = {
46800 (char *) "self",(char *) "colText", NULL
46801 };
46802
46803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46805 if (!SWIG_IsOK(res1)) {
46806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46807 }
46808 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46809 {
46810 arg2 = &temp2;
46811 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46812 }
46813 {
46814 PyThreadState* __tstate = wxPyBeginAllowThreads();
46815 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
46816 wxPyEndAllowThreads(__tstate);
46817 if (PyErr_Occurred()) SWIG_fail;
46818 }
46819 resultobj = SWIG_Py_Void();
46820 return resultobj;
46821fail:
46822 return NULL;
d55e5bfc
RD
46823}
46824
46825
1bd55598
RD
46826SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46827 PyObject *resultobj = 0;
46828 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46829 wxColour result;
46830 void *argp1 = 0 ;
46831 int res1 = 0 ;
46832 PyObject *swig_obj[1] ;
46833
46834 if (!args) SWIG_fail;
46835 swig_obj[0] = args;
46836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46837 if (!SWIG_IsOK(res1)) {
46838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46839 }
46840 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46841 {
46842 PyThreadState* __tstate = wxPyBeginAllowThreads();
46843 result = wxMenuItem_GetTextColour(arg1);
46844 wxPyEndAllowThreads(__tstate);
46845 if (PyErr_Occurred()) SWIG_fail;
46846 }
46847 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46848 return resultobj;
46849fail:
46850 return NULL;
46851}
46852
46853
46854SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46855 PyObject *resultobj = 0;
46856 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46857 wxColour *arg2 = 0 ;
46858 void *argp1 = 0 ;
46859 int res1 = 0 ;
46860 wxColour temp2 ;
46861 PyObject * obj0 = 0 ;
46862 PyObject * obj1 = 0 ;
46863 char * kwnames[] = {
46864 (char *) "self",(char *) "colBack", NULL
46865 };
46866
46867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46869 if (!SWIG_IsOK(res1)) {
46870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46871 }
46872 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46873 {
46874 arg2 = &temp2;
46875 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46876 }
46877 {
46878 PyThreadState* __tstate = wxPyBeginAllowThreads();
46879 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
46880 wxPyEndAllowThreads(__tstate);
46881 if (PyErr_Occurred()) SWIG_fail;
46882 }
46883 resultobj = SWIG_Py_Void();
46884 return resultobj;
46885fail:
46886 return NULL;
d55e5bfc 46887}
1bd55598
RD
46888
46889
46890SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46891 PyObject *resultobj = 0;
46892 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46893 wxColour result;
46894 void *argp1 = 0 ;
46895 int res1 = 0 ;
46896 PyObject *swig_obj[1] ;
46897
46898 if (!args) SWIG_fail;
46899 swig_obj[0] = args;
46900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46901 if (!SWIG_IsOK(res1)) {
46902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46903 }
46904 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46905 {
46906 PyThreadState* __tstate = wxPyBeginAllowThreads();
46907 result = wxMenuItem_GetBackgroundColour(arg1);
46908 wxPyEndAllowThreads(__tstate);
46909 if (PyErr_Occurred()) SWIG_fail;
46910 }
46911 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46912 return resultobj;
46913fail:
46914 return NULL;
46915}
46916
46917
46918SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46919 PyObject *resultobj = 0;
46920 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46921 wxBitmap *arg2 = 0 ;
46922 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46923 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46924 void *argp1 = 0 ;
46925 int res1 = 0 ;
46926 void *argp2 = 0 ;
46927 int res2 = 0 ;
46928 void *argp3 = 0 ;
46929 int res3 = 0 ;
46930 PyObject * obj0 = 0 ;
46931 PyObject * obj1 = 0 ;
46932 PyObject * obj2 = 0 ;
46933 char * kwnames[] = {
46934 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46935 };
46936
46937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46939 if (!SWIG_IsOK(res1)) {
46940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46941 }
46942 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46943 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46944 if (!SWIG_IsOK(res2)) {
46945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46946 }
46947 if (!argp2) {
46948 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46949 }
46950 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46951 if (obj2) {
46952 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46953 if (!SWIG_IsOK(res3)) {
46954 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
d55e5bfc 46955 }
1bd55598
RD
46956 if (!argp3) {
46957 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
d55e5bfc 46958 }
1bd55598
RD
46959 arg3 = reinterpret_cast< wxBitmap * >(argp3);
46960 }
46961 {
46962 PyThreadState* __tstate = wxPyBeginAllowThreads();
46963 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
46964 wxPyEndAllowThreads(__tstate);
46965 if (PyErr_Occurred()) SWIG_fail;
46966 }
46967 resultobj = SWIG_Py_Void();
46968 return resultobj;
46969fail:
46970 return NULL;
46971}
46972
46973
46974SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46975 PyObject *resultobj = 0;
46976 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46977 wxBitmap *arg2 = 0 ;
46978 void *argp1 = 0 ;
46979 int res1 = 0 ;
46980 void *argp2 = 0 ;
46981 int res2 = 0 ;
46982 PyObject * obj0 = 0 ;
46983 PyObject * obj1 = 0 ;
46984 char * kwnames[] = {
46985 (char *) "self",(char *) "bmpDisabled", NULL
46986 };
46987
46988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46990 if (!SWIG_IsOK(res1)) {
46991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46992 }
46993 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46994 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46995 if (!SWIG_IsOK(res2)) {
46996 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46997 }
46998 if (!argp2) {
46999 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47000 }
47001 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47002 {
47003 PyThreadState* __tstate = wxPyBeginAllowThreads();
47004 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
47005 wxPyEndAllowThreads(__tstate);
47006 if (PyErr_Occurred()) SWIG_fail;
47007 }
47008 resultobj = SWIG_Py_Void();
47009 return resultobj;
47010fail:
47011 return NULL;
d55e5bfc
RD
47012}
47013
47014
1bd55598
RD
47015SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47016 PyObject *resultobj = 0;
47017 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47018 wxBitmap *result = 0 ;
47019 void *argp1 = 0 ;
47020 int res1 = 0 ;
47021 PyObject *swig_obj[1] ;
47022
47023 if (!args) SWIG_fail;
47024 swig_obj[0] = args;
47025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47026 if (!SWIG_IsOK(res1)) {
47027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47028 }
47029 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47030 {
47031 PyThreadState* __tstate = wxPyBeginAllowThreads();
d55e5bfc 47032 {
1bd55598
RD
47033 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
47034 result = (wxBitmap *) &_result_ref;
d55e5bfc 47035 }
1bd55598
RD
47036 wxPyEndAllowThreads(__tstate);
47037 if (PyErr_Occurred()) SWIG_fail;
47038 }
47039 {
47040 wxBitmap* resultptr = new wxBitmap(*result);
47041 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47042 }
47043 return resultobj;
47044fail:
47045 return NULL;
47046}
47047
47048
47049SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47050 PyObject *resultobj = 0;
47051 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47052 int arg2 ;
47053 void *argp1 = 0 ;
47054 int res1 = 0 ;
47055 int val2 ;
47056 int ecode2 = 0 ;
47057 PyObject * obj0 = 0 ;
47058 PyObject * obj1 = 0 ;
47059 char * kwnames[] = {
47060 (char *) "self",(char *) "nWidth", NULL
47061 };
47062
47063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47065 if (!SWIG_IsOK(res1)) {
47066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47067 }
47068 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47069 ecode2 = SWIG_AsVal_int(obj1, &val2);
47070 if (!SWIG_IsOK(ecode2)) {
47071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47072 }
47073 arg2 = static_cast< int >(val2);
47074 {
47075 PyThreadState* __tstate = wxPyBeginAllowThreads();
47076 wxMenuItem_SetMarginWidth(arg1,arg2);
47077 wxPyEndAllowThreads(__tstate);
47078 if (PyErr_Occurred()) SWIG_fail;
47079 }
47080 resultobj = SWIG_Py_Void();
47081 return resultobj;
47082fail:
47083 return NULL;
d55e5bfc
RD
47084}
47085
47086
1bd55598
RD
47087SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47088 PyObject *resultobj = 0;
47089 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47090 int result;
47091 void *argp1 = 0 ;
47092 int res1 = 0 ;
47093 PyObject *swig_obj[1] ;
47094
47095 if (!args) SWIG_fail;
47096 swig_obj[0] = args;
47097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47098 if (!SWIG_IsOK(res1)) {
47099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47100 }
47101 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47102 {
47103 PyThreadState* __tstate = wxPyBeginAllowThreads();
47104 result = (int)wxMenuItem_GetMarginWidth(arg1);
47105 wxPyEndAllowThreads(__tstate);
47106 if (PyErr_Occurred()) SWIG_fail;
47107 }
47108 resultobj = SWIG_From_int(static_cast< int >(result));
47109 return resultobj;
47110fail:
47111 return NULL;
d55e5bfc
RD
47112}
47113
47114
1bd55598
RD
47115SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47116 PyObject *resultobj = 0;
47117 int result;
47118
47119 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47120 {
47121 PyThreadState* __tstate = wxPyBeginAllowThreads();
47122 result = (int)wxMenuItem_GetDefaultMarginWidth();
47123 wxPyEndAllowThreads(__tstate);
47124 if (PyErr_Occurred()) SWIG_fail;
47125 }
47126 resultobj = SWIG_From_int(static_cast< int >(result));
47127 return resultobj;
47128fail:
47129 return NULL;
d55e5bfc 47130}
1bd55598
RD
47131
47132
47133SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47134 PyObject *resultobj = 0;
47135 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47136 bool result;
47137 void *argp1 = 0 ;
47138 int res1 = 0 ;
47139 PyObject *swig_obj[1] ;
47140
47141 if (!args) SWIG_fail;
47142 swig_obj[0] = args;
47143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47144 if (!SWIG_IsOK(res1)) {
47145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47146 }
47147 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47148 {
47149 PyThreadState* __tstate = wxPyBeginAllowThreads();
47150 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47151 wxPyEndAllowThreads(__tstate);
47152 if (PyErr_Occurred()) SWIG_fail;
47153 }
47154 {
47155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47156 }
47157 return resultobj;
47158fail:
47159 return NULL;
47160}
47161
47162
47163SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47164 PyObject *resultobj = 0;
47165 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47166 bool arg2 = (bool) true ;
47167 void *argp1 = 0 ;
47168 int res1 = 0 ;
47169 bool val2 ;
47170 int ecode2 = 0 ;
47171 PyObject * obj0 = 0 ;
47172 PyObject * obj1 = 0 ;
47173 char * kwnames[] = {
47174 (char *) "self",(char *) "ownerDrawn", NULL
47175 };
47176
47177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47179 if (!SWIG_IsOK(res1)) {
47180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47181 }
47182 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47183 if (obj1) {
47184 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47185 if (!SWIG_IsOK(ecode2)) {
47186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47187 }
47188 arg2 = static_cast< bool >(val2);
47189 }
47190 {
47191 PyThreadState* __tstate = wxPyBeginAllowThreads();
47192 wxMenuItem_SetOwnerDrawn(arg1,arg2);
47193 wxPyEndAllowThreads(__tstate);
47194 if (PyErr_Occurred()) SWIG_fail;
47195 }
47196 resultobj = SWIG_Py_Void();
47197 return resultobj;
47198fail:
47199 return NULL;
d55e5bfc
RD
47200}
47201
47202
1bd55598
RD
47203SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47204 PyObject *resultobj = 0;
47205 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47206 void *argp1 = 0 ;
47207 int res1 = 0 ;
47208 PyObject *swig_obj[1] ;
47209
47210 if (!args) SWIG_fail;
47211 swig_obj[0] = args;
47212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47213 if (!SWIG_IsOK(res1)) {
47214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47215 }
47216 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47217 {
47218 PyThreadState* __tstate = wxPyBeginAllowThreads();
47219 wxMenuItem_ResetOwnerDrawn(arg1);
47220 wxPyEndAllowThreads(__tstate);
47221 if (PyErr_Occurred()) SWIG_fail;
47222 }
47223 resultobj = SWIG_Py_Void();
47224 return resultobj;
47225fail:
47226 return NULL;
d55e5bfc
RD
47227}
47228
47229
1bd55598
RD
47230SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47231 PyObject *obj;
47232 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47233 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47234 return SWIG_Py_Void();
d55e5bfc
RD
47235}
47236
1bd55598
RD
47237SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47238 return SWIG_Python_InitShadowInstance(args);
47239}
d55e5bfc 47240
1bd55598
RD
47241SWIGINTERN int ControlNameStr_set(PyObject *) {
47242 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47243 return 1;
d55e5bfc
RD
47244}
47245
47246
1bd55598
RD
47247SWIGINTERN PyObject *ControlNameStr_get(void) {
47248 PyObject *pyobj = 0;
47249
47250 {
d55e5bfc 47251#if wxUSE_UNICODE
1bd55598 47252 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
d55e5bfc 47253#else
1bd55598 47254 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
d55e5bfc 47255#endif
1bd55598
RD
47256 }
47257 return pyobj;
47258}
47259
47260
47261SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47262 PyObject *resultobj = 0;
47263 wxWindow *arg1 = (wxWindow *) 0 ;
47264 int arg2 = (int) -1 ;
47265 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47266 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47267 wxSize const &arg4_defvalue = wxDefaultSize ;
47268 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47269 long arg5 = (long) 0 ;
47270 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47271 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47272 wxString const &arg7_defvalue = wxPyControlNameStr ;
47273 wxString *arg7 = (wxString *) &arg7_defvalue ;
47274 wxControl *result = 0 ;
47275 void *argp1 = 0 ;
47276 int res1 = 0 ;
47277 int val2 ;
47278 int ecode2 = 0 ;
47279 wxPoint temp3 ;
47280 wxSize temp4 ;
47281 long val5 ;
47282 int ecode5 = 0 ;
47283 void *argp6 = 0 ;
47284 int res6 = 0 ;
47285 bool temp7 = false ;
47286 PyObject * obj0 = 0 ;
47287 PyObject * obj1 = 0 ;
47288 PyObject * obj2 = 0 ;
47289 PyObject * obj3 = 0 ;
47290 PyObject * obj4 = 0 ;
47291 PyObject * obj5 = 0 ;
47292 PyObject * obj6 = 0 ;
47293 char * kwnames[] = {
47294 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47295 };
47296
47297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47299 if (!SWIG_IsOK(res1)) {
47300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47301 }
47302 arg1 = reinterpret_cast< wxWindow * >(argp1);
47303 if (obj1) {
47304 ecode2 = SWIG_AsVal_int(obj1, &val2);
47305 if (!SWIG_IsOK(ecode2)) {
47306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47307 }
47308 arg2 = static_cast< int >(val2);
47309 }
47310 if (obj2) {
d55e5bfc 47311 {
1bd55598
RD
47312 arg3 = &temp3;
47313 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
d55e5bfc 47314 }
1bd55598
RD
47315 }
47316 if (obj3) {
d55e5bfc 47317 {
1bd55598
RD
47318 arg4 = &temp4;
47319 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
d55e5bfc 47320 }
1bd55598
RD
47321 }
47322 if (obj4) {
47323 ecode5 = SWIG_AsVal_long(obj4, &val5);
47324 if (!SWIG_IsOK(ecode5)) {
47325 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47326 }
47327 arg5 = static_cast< long >(val5);
47328 }
47329 if (obj5) {
47330 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47331 if (!SWIG_IsOK(res6)) {
47332 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
d55e5bfc 47333 }
1bd55598
RD
47334 if (!argp6) {
47335 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
d55e5bfc 47336 }
1bd55598
RD
47337 arg6 = reinterpret_cast< wxValidator * >(argp6);
47338 }
47339 if (obj6) {
d55e5bfc 47340 {
1bd55598
RD
47341 arg7 = wxString_in_helper(obj6);
47342 if (arg7 == NULL) SWIG_fail;
47343 temp7 = true;
d55e5bfc 47344 }
1bd55598
RD
47345 }
47346 {
47347 if (!wxPyCheckForApp()) SWIG_fail;
47348 PyThreadState* __tstate = wxPyBeginAllowThreads();
47349 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47350 wxPyEndAllowThreads(__tstate);
47351 if (PyErr_Occurred()) SWIG_fail;
47352 }
47353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47354 {
47355 if (temp7)
47356 delete arg7;
47357 }
47358 return resultobj;
47359fail:
47360 {
47361 if (temp7)
47362 delete arg7;
47363 }
47364 return NULL;
d55e5bfc
RD
47365}
47366
47367
1bd55598
RD
47368SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47369 PyObject *resultobj = 0;
47370 wxControl *result = 0 ;
47371
47372 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47373 {
47374 if (!wxPyCheckForApp()) SWIG_fail;
47375 PyThreadState* __tstate = wxPyBeginAllowThreads();
47376 result = (wxControl *)new wxControl();
47377 wxPyEndAllowThreads(__tstate);
47378 if (PyErr_Occurred()) SWIG_fail;
47379 }
47380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47381 return resultobj;
47382fail:
47383 return NULL;
47384}
47385
47386
47387SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47388 PyObject *resultobj = 0;
47389 wxControl *arg1 = (wxControl *) 0 ;
47390 wxWindow *arg2 = (wxWindow *) 0 ;
47391 int arg3 = (int) -1 ;
47392 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47393 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47394 wxSize const &arg5_defvalue = wxDefaultSize ;
47395 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47396 long arg6 = (long) 0 ;
47397 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47398 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47399 wxString const &arg8_defvalue = wxPyControlNameStr ;
47400 wxString *arg8 = (wxString *) &arg8_defvalue ;
47401 bool result;
47402 void *argp1 = 0 ;
47403 int res1 = 0 ;
47404 void *argp2 = 0 ;
47405 int res2 = 0 ;
47406 int val3 ;
47407 int ecode3 = 0 ;
47408 wxPoint temp4 ;
47409 wxSize temp5 ;
47410 long val6 ;
47411 int ecode6 = 0 ;
47412 void *argp7 = 0 ;
47413 int res7 = 0 ;
47414 bool temp8 = false ;
47415 PyObject * obj0 = 0 ;
47416 PyObject * obj1 = 0 ;
47417 PyObject * obj2 = 0 ;
47418 PyObject * obj3 = 0 ;
47419 PyObject * obj4 = 0 ;
47420 PyObject * obj5 = 0 ;
47421 PyObject * obj6 = 0 ;
47422 PyObject * obj7 = 0 ;
47423 char * kwnames[] = {
47424 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47425 };
47426
47427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47429 if (!SWIG_IsOK(res1)) {
47430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47431 }
47432 arg1 = reinterpret_cast< wxControl * >(argp1);
47433 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47434 if (!SWIG_IsOK(res2)) {
47435 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47436 }
47437 arg2 = reinterpret_cast< wxWindow * >(argp2);
47438 if (obj2) {
47439 ecode3 = SWIG_AsVal_int(obj2, &val3);
47440 if (!SWIG_IsOK(ecode3)) {
47441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47442 }
47443 arg3 = static_cast< int >(val3);
47444 }
47445 if (obj3) {
d55e5bfc 47446 {
1bd55598
RD
47447 arg4 = &temp4;
47448 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
d55e5bfc 47449 }
1bd55598
RD
47450 }
47451 if (obj4) {
d55e5bfc 47452 {
1bd55598
RD
47453 arg5 = &temp5;
47454 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
d55e5bfc 47455 }
1bd55598
RD
47456 }
47457 if (obj5) {
47458 ecode6 = SWIG_AsVal_long(obj5, &val6);
47459 if (!SWIG_IsOK(ecode6)) {
47460 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47461 }
47462 arg6 = static_cast< long >(val6);
47463 }
47464 if (obj6) {
47465 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47466 if (!SWIG_IsOK(res7)) {
47467 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
d55e5bfc 47468 }
1bd55598
RD
47469 if (!argp7) {
47470 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
d55e5bfc 47471 }
1bd55598
RD
47472 arg7 = reinterpret_cast< wxValidator * >(argp7);
47473 }
47474 if (obj7) {
d55e5bfc 47475 {
1bd55598
RD
47476 arg8 = wxString_in_helper(obj7);
47477 if (arg8 == NULL) SWIG_fail;
47478 temp8 = true;
d55e5bfc 47479 }
1bd55598
RD
47480 }
47481 {
47482 PyThreadState* __tstate = wxPyBeginAllowThreads();
47483 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47484 wxPyEndAllowThreads(__tstate);
47485 if (PyErr_Occurred()) SWIG_fail;
47486 }
47487 {
47488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47489 }
47490 {
47491 if (temp8)
47492 delete arg8;
47493 }
47494 return resultobj;
47495fail:
47496 {
47497 if (temp8)
47498 delete arg8;
47499 }
47500 return NULL;
47501}
47502
47503
1eeb270e
RD
47504SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47505 PyObject *resultobj = 0;
47506 wxControl *arg1 = (wxControl *) 0 ;
47507 int result;
47508 void *argp1 = 0 ;
47509 int res1 = 0 ;
47510 PyObject *swig_obj[1] ;
47511
47512 if (!args) SWIG_fail;
47513 swig_obj[0] = args;
47514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47515 if (!SWIG_IsOK(res1)) {
47516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47517 }
47518 arg1 = reinterpret_cast< wxControl * >(argp1);
47519 {
47520 PyThreadState* __tstate = wxPyBeginAllowThreads();
47521 result = (int)((wxControl const *)arg1)->GetAlignment();
47522 wxPyEndAllowThreads(__tstate);
47523 if (PyErr_Occurred()) SWIG_fail;
47524 }
47525 resultobj = SWIG_From_int(static_cast< int >(result));
47526 return resultobj;
47527fail:
47528 return NULL;
47529}
47530
47531
34e0a3bb 47532SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1eeb270e
RD
47533 PyObject *resultobj = 0;
47534 wxControl *arg1 = (wxControl *) 0 ;
47535 wxString result;
47536 void *argp1 = 0 ;
47537 int res1 = 0 ;
34e0a3bb 47538 PyObject *swig_obj[1] ;
1eeb270e 47539
34e0a3bb
RD
47540 if (!args) SWIG_fail;
47541 swig_obj[0] = args;
1eeb270e
RD
47542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47543 if (!SWIG_IsOK(res1)) {
47544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47545 }
47546 arg1 = reinterpret_cast< wxControl * >(argp1);
47547 {
47548 PyThreadState* __tstate = wxPyBeginAllowThreads();
47549 result = ((wxControl const *)arg1)->GetLabelText();
47550 wxPyEndAllowThreads(__tstate);
47551 if (PyErr_Occurred()) SWIG_fail;
47552 }
47553 {
47554#if wxUSE_UNICODE
47555 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47556#else
47557 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47558#endif
47559 }
47560 return resultobj;
47561fail:
47562 return NULL;
47563}
47564
47565
1bd55598
RD
47566SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47567 PyObject *resultobj = 0;
47568 wxControl *arg1 = (wxControl *) 0 ;
47569 wxCommandEvent *arg2 = 0 ;
47570 void *argp1 = 0 ;
47571 int res1 = 0 ;
47572 void *argp2 = 0 ;
47573 int res2 = 0 ;
47574 PyObject * obj0 = 0 ;
47575 PyObject * obj1 = 0 ;
47576 char * kwnames[] = {
47577 (char *) "self",(char *) "event", NULL
47578 };
47579
47580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47582 if (!SWIG_IsOK(res1)) {
47583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47584 }
47585 arg1 = reinterpret_cast< wxControl * >(argp1);
47586 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47587 if (!SWIG_IsOK(res2)) {
47588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47589 }
47590 if (!argp2) {
47591 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47592 }
47593 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47594 {
47595 PyThreadState* __tstate = wxPyBeginAllowThreads();
47596 (arg1)->Command(*arg2);
47597 wxPyEndAllowThreads(__tstate);
47598 if (PyErr_Occurred()) SWIG_fail;
47599 }
47600 resultobj = SWIG_Py_Void();
47601 return resultobj;
47602fail:
47603 return NULL;
d55e5bfc
RD
47604}
47605
47606
1bd55598
RD
47607SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47608 PyObject *resultobj = 0;
47609 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47610 SwigValueWrapper<wxVisualAttributes > result;
47611 int val1 ;
47612 int ecode1 = 0 ;
47613 PyObject * obj0 = 0 ;
47614 char * kwnames[] = {
47615 (char *) "variant", NULL
47616 };
47617
47618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47619 if (obj0) {
47620 ecode1 = SWIG_AsVal_int(obj0, &val1);
47621 if (!SWIG_IsOK(ecode1)) {
47622 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47623 }
47624 arg1 = static_cast< wxWindowVariant >(val1);
47625 }
47626 {
47627 if (!wxPyCheckForApp()) SWIG_fail;
47628 PyThreadState* __tstate = wxPyBeginAllowThreads();
47629 result = wxControl::GetClassDefaultAttributes(arg1);
47630 wxPyEndAllowThreads(__tstate);
47631 if (PyErr_Occurred()) SWIG_fail;
47632 }
47633 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47634 return resultobj;
47635fail:
47636 return NULL;
47637}
47638
47639
47640SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47641 PyObject *obj;
47642 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47643 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47644 return SWIG_Py_Void();
47645}
47646
47647SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47648 return SWIG_Python_InitShadowInstance(args);
47649}
47650
47651SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47652 PyObject *resultobj = 0;
47653 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47654 wxString *arg2 = 0 ;
47655 PyObject *arg3 = (PyObject *) NULL ;
47656 int result;
47657 void *argp1 = 0 ;
47658 int res1 = 0 ;
47659 bool temp2 = false ;
47660 PyObject * obj0 = 0 ;
47661 PyObject * obj1 = 0 ;
47662 PyObject * obj2 = 0 ;
47663 char * kwnames[] = {
47664 (char *) "self",(char *) "item",(char *) "clientData", NULL
47665 };
47666
47667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47669 if (!SWIG_IsOK(res1)) {
47670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47671 }
47672 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47673 {
47674 arg2 = wxString_in_helper(obj1);
47675 if (arg2 == NULL) SWIG_fail;
47676 temp2 = true;
47677 }
47678 if (obj2) {
47679 arg3 = obj2;
47680 }
47681 {
47682 PyThreadState* __tstate = wxPyBeginAllowThreads();
47683 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47684 wxPyEndAllowThreads(__tstate);
47685 if (PyErr_Occurred()) SWIG_fail;
47686 }
47687 resultobj = SWIG_From_int(static_cast< int >(result));
47688 {
47689 if (temp2)
47690 delete arg2;
47691 }
47692 return resultobj;
47693fail:
47694 {
47695 if (temp2)
47696 delete arg2;
47697 }
47698 return NULL;
d55e5bfc
RD
47699}
47700
47701
1bd55598
RD
47702SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47703 PyObject *resultobj = 0;
47704 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47705 wxArrayString *arg2 = 0 ;
47706 void *argp1 = 0 ;
47707 int res1 = 0 ;
47708 bool temp2 = false ;
47709 PyObject * obj0 = 0 ;
47710 PyObject * obj1 = 0 ;
47711 char * kwnames[] = {
47712 (char *) "self",(char *) "strings", NULL
47713 };
47714
47715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47717 if (!SWIG_IsOK(res1)) {
47718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47719 }
47720 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47721 {
47722 if (! PySequence_Check(obj1)) {
47723 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47724 SWIG_fail;
47725 }
47726 arg2 = new wxArrayString;
47727 temp2 = true;
47728 int i, len=PySequence_Length(obj1);
47729 for (i=0; i<len; i++) {
47730 PyObject* item = PySequence_GetItem(obj1, i);
47731 wxString* s = wxString_in_helper(item);
47732 if (PyErr_Occurred()) SWIG_fail;
47733 arg2->Add(*s);
47734 delete s;
47735 Py_DECREF(item);
d55e5bfc 47736 }
1bd55598
RD
47737 }
47738 {
47739 PyThreadState* __tstate = wxPyBeginAllowThreads();
47740 (arg1)->Append((wxArrayString const &)*arg2);
47741 wxPyEndAllowThreads(__tstate);
47742 if (PyErr_Occurred()) SWIG_fail;
47743 }
47744 resultobj = SWIG_Py_Void();
47745 {
47746 if (temp2) delete arg2;
47747 }
47748 return resultobj;
47749fail:
47750 {
47751 if (temp2) delete arg2;
47752 }
47753 return NULL;
47754}
47755
47756
47757SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47758 PyObject *resultobj = 0;
47759 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47760 wxString *arg2 = 0 ;
d359a380 47761 int arg3 ;
1bd55598
RD
47762 PyObject *arg4 = (PyObject *) NULL ;
47763 int result;
47764 void *argp1 = 0 ;
47765 int res1 = 0 ;
47766 bool temp2 = false ;
d359a380 47767 int val3 ;
1bd55598
RD
47768 int ecode3 = 0 ;
47769 PyObject * obj0 = 0 ;
47770 PyObject * obj1 = 0 ;
47771 PyObject * obj2 = 0 ;
47772 PyObject * obj3 = 0 ;
47773 char * kwnames[] = {
47774 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47775 };
47776
47777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47779 if (!SWIG_IsOK(res1)) {
47780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47781 }
47782 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47783 {
47784 arg2 = wxString_in_helper(obj1);
47785 if (arg2 == NULL) SWIG_fail;
47786 temp2 = true;
47787 }
d359a380 47788 ecode3 = SWIG_AsVal_int(obj2, &val3);
1bd55598 47789 if (!SWIG_IsOK(ecode3)) {
d359a380 47790 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
1bd55598 47791 }
d359a380 47792 arg3 = static_cast< int >(val3);
1bd55598
RD
47793 if (obj3) {
47794 arg4 = obj3;
47795 }
47796 {
47797 PyThreadState* __tstate = wxPyBeginAllowThreads();
47798 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47799 wxPyEndAllowThreads(__tstate);
47800 if (PyErr_Occurred()) SWIG_fail;
47801 }
47802 resultobj = SWIG_From_int(static_cast< int >(result));
47803 {
47804 if (temp2)
47805 delete arg2;
47806 }
47807 return resultobj;
47808fail:
47809 {
47810 if (temp2)
47811 delete arg2;
47812 }
47813 return NULL;
d55e5bfc
RD
47814}
47815
47816
1bd55598
RD
47817SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47818 PyObject *resultobj = 0;
47819 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47820 void *argp1 = 0 ;
47821 int res1 = 0 ;
47822 PyObject *swig_obj[1] ;
47823
47824 if (!args) SWIG_fail;
47825 swig_obj[0] = args;
47826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47827 if (!SWIG_IsOK(res1)) {
47828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47829 }
47830 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47831 {
47832 PyThreadState* __tstate = wxPyBeginAllowThreads();
47833 (arg1)->Clear();
47834 wxPyEndAllowThreads(__tstate);
47835 if (PyErr_Occurred()) SWIG_fail;
47836 }
47837 resultobj = SWIG_Py_Void();
47838 return resultobj;
47839fail:
47840 return NULL;
47841}
47842
47843
47844SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47845 PyObject *resultobj = 0;
47846 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
d359a380 47847 int arg2 ;
1bd55598
RD
47848 void *argp1 = 0 ;
47849 int res1 = 0 ;
d359a380 47850 int val2 ;
1bd55598
RD
47851 int ecode2 = 0 ;
47852 PyObject * obj0 = 0 ;
47853 PyObject * obj1 = 0 ;
47854 char * kwnames[] = {
47855 (char *) "self",(char *) "n", NULL
47856 };
47857
47858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
47859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47860 if (!SWIG_IsOK(res1)) {
47861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47862 }
47863 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
d359a380 47864 ecode2 = SWIG_AsVal_int(obj1, &val2);
1bd55598 47865 if (!SWIG_IsOK(ecode2)) {
d359a380 47866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
1bd55598 47867 }
d359a380 47868 arg2 = static_cast< int >(val2);
1bd55598
RD
47869 {
47870 PyThreadState* __tstate = wxPyBeginAllowThreads();
47871 (arg1)->Delete(arg2);
47872 wxPyEndAllowThreads(__tstate);
47873 if (PyErr_Occurred()) SWIG_fail;
47874 }
47875 resultobj = SWIG_Py_Void();
47876 return resultobj;
47877fail:
47878 return NULL;
47879}
47880
47881
47882SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47883 PyObject *resultobj = 0;
47884 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
d359a380 47885 int arg2 ;
1bd55598
RD
47886 PyObject *result = 0 ;
47887 void *argp1 = 0 ;
47888 int res1 = 0 ;
d359a380 47889 int val2 ;
1bd55598
RD
47890 int ecode2 = 0 ;
47891 PyObject * obj0 = 0 ;
47892 PyObject * obj1 = 0 ;
47893 char * kwnames[] = {
47894 (char *) "self",(char *) "n", NULL
47895 };
47896
47897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47899 if (!SWIG_IsOK(res1)) {
47900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47901 }
47902 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
d359a380 47903 ecode2 = SWIG_AsVal_int(obj1, &val2);
1bd55598 47904 if (!SWIG_IsOK(ecode2)) {
d359a380 47905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
1bd55598 47906 }
d359a380 47907 arg2 = static_cast< int >(val2);
1bd55598
RD
47908 {
47909 PyThreadState* __tstate = wxPyBeginAllowThreads();
47910 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47911 wxPyEndAllowThreads(__tstate);
47912 if (PyErr_Occurred()) SWIG_fail;
47913 }
47914 resultobj = result;
47915 return resultobj;
47916fail:
47917 return NULL;
47918}
47919
47920
47921SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47922 PyObject *resultobj = 0;
47923 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
d359a380 47924 int arg2 ;
1bd55598
RD
47925 PyObject *arg3 = (PyObject *) 0 ;
47926 void *argp1 = 0 ;
47927 int res1 = 0 ;
d359a380 47928 int val2 ;
1bd55598
RD
47929 int ecode2 = 0 ;
47930 PyObject * obj0 = 0 ;
47931 PyObject * obj1 = 0 ;
47932 PyObject * obj2 = 0 ;
47933 char * kwnames[] = {
47934 (char *) "self",(char *) "n",(char *) "clientData", NULL
47935 };
47936
47937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47939 if (!SWIG_IsOK(res1)) {
47940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47941 }
47942 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
d359a380 47943 ecode2 = SWIG_AsVal_int(obj1, &val2);
1bd55598 47944 if (!SWIG_IsOK(ecode2)) {
d359a380 47945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
1bd55598 47946 }
d359a380 47947 arg2 = static_cast< int >(val2);
1bd55598
RD
47948 arg3 = obj2;
47949 {
47950 PyThreadState* __tstate = wxPyBeginAllowThreads();
47951 wxItemContainer_SetClientData(arg1,arg2,arg3);
47952 wxPyEndAllowThreads(__tstate);
47953 if (PyErr_Occurred()) SWIG_fail;
47954 }
47955 resultobj = SWIG_Py_Void();
47956 return resultobj;
47957fail:
47958 return NULL;
d55e5bfc
RD
47959}
47960
47961
1bd55598
RD
47962SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47963 PyObject *resultobj = 0;
47964 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
d359a380 47965 int result;
1bd55598
RD
47966 void *argp1 = 0 ;
47967 int res1 = 0 ;
47968 PyObject *swig_obj[1] ;
47969
47970 if (!args) SWIG_fail;
47971 swig_obj[0] = args;
47972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47973 if (!SWIG_IsOK(res1)) {
47974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47975 }
47976 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47977 {
47978 PyThreadState* __tstate = wxPyBeginAllowThreads();
d359a380 47979 result = (int)((wxItemContainer const *)arg1)->GetCount();
1bd55598
RD
47980 wxPyEndAllowThreads(__tstate);
47981 if (PyErr_Occurred()) SWIG_fail;
47982 }
d359a380 47983 resultobj = SWIG_From_int(static_cast< int >(result));
1bd55598
RD
47984 return resultobj;
47985fail:
47986 return NULL;
d55e5bfc
RD
47987}
47988
47989
1bd55598
RD
47990SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47991 PyObject *resultobj = 0;
47992 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47993 bool result;
47994 void *argp1 = 0 ;
47995 int res1 = 0 ;
47996 PyObject *swig_obj[1] ;
47997
47998 if (!args) SWIG_fail;
47999 swig_obj[0] = args;
48000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48001 if (!SWIG_IsOK(res1)) {
48002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48003 }
48004 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48005 {
48006 PyThreadState* __tstate = wxPyBeginAllowThreads();
48007 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48008 wxPyEndAllowThreads(__tstate);
48009 if (PyErr_Occurred()) SWIG_fail;
48010 }
48011 {
48012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48013 }
48014 return resultobj;
48015fail:
48016 return NULL;
48017}
48018
48019
48020SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48021 PyObject *resultobj = 0;
48022 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
d359a380 48023 int arg2 ;
1bd55598
RD
48024 wxString result;
48025 void *argp1 = 0 ;
48026 int res1 = 0 ;
d359a380 48027 int val2 ;
1bd55598
RD
48028 int ecode2 = 0 ;
48029 PyObject * obj0 = 0 ;
48030 PyObject * obj1 = 0 ;
48031 char * kwnames[] = {
48032 (char *) "self",(char *) "n", NULL
48033 };
48034
48035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48037 if (!SWIG_IsOK(res1)) {
48038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48039 }
48040 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
d359a380 48041 ecode2 = SWIG_AsVal_int(obj1, &val2);
1bd55598 48042 if (!SWIG_IsOK(ecode2)) {
d359a380 48043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
1bd55598 48044 }
d359a380 48045 arg2 = static_cast< int >(val2);
1bd55598
RD
48046 {
48047 PyThreadState* __tstate = wxPyBeginAllowThreads();
48048 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48049 wxPyEndAllowThreads(__tstate);
48050 if (PyErr_Occurred()) SWIG_fail;
48051 }
48052 {
48053#if wxUSE_UNICODE
48054 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48055#else
48056 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48057#endif
48058 }
48059 return resultobj;
48060fail:
48061 return NULL;
d55e5bfc
RD
48062}
48063
48064
1bd55598
RD
48065SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48066 PyObject *resultobj = 0;
48067 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48068 wxArrayString result;
48069 void *argp1 = 0 ;
48070 int res1 = 0 ;
48071 PyObject *swig_obj[1] ;
48072
48073 if (!args) SWIG_fail;
48074 swig_obj[0] = args;
48075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48076 if (!SWIG_IsOK(res1)) {
48077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48078 }
48079 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48080 {
48081 PyThreadState* __tstate = wxPyBeginAllowThreads();
48082 result = ((wxItemContainer const *)arg1)->GetStrings();
48083 wxPyEndAllowThreads(__tstate);
48084 if (PyErr_Occurred()) SWIG_fail;
48085 }
48086 {
48087 resultobj = wxArrayString2PyList_helper(result);
48088 }
48089 return resultobj;
48090fail:
48091 return NULL;
48092}
48093
48094
48095SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48096 PyObject *resultobj = 0;
48097 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
d359a380 48098 int arg2 ;
1bd55598
RD
48099 wxString *arg3 = 0 ;
48100 void *argp1 = 0 ;
48101 int res1 = 0 ;
d359a380 48102 int val2 ;
1bd55598
RD
48103 int ecode2 = 0 ;
48104 bool temp3 = false ;
48105 PyObject * obj0 = 0 ;
48106 PyObject * obj1 = 0 ;
48107 PyObject * obj2 = 0 ;
48108 char * kwnames[] = {
48109 (char *) "self",(char *) "n",(char *) "s", NULL
48110 };
48111
48112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48114 if (!SWIG_IsOK(res1)) {
48115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48116 }
48117 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
d359a380 48118 ecode2 = SWIG_AsVal_int(obj1, &val2);
1bd55598 48119 if (!SWIG_IsOK(ecode2)) {
d359a380 48120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
1bd55598 48121 }
d359a380 48122 arg2 = static_cast< int >(val2);
1bd55598
RD
48123 {
48124 arg3 = wxString_in_helper(obj2);
48125 if (arg3 == NULL) SWIG_fail;
48126 temp3 = true;
48127 }
48128 {
48129 PyThreadState* __tstate = wxPyBeginAllowThreads();
48130 (arg1)->SetString(arg2,(wxString const &)*arg3);
48131 wxPyEndAllowThreads(__tstate);
48132 if (PyErr_Occurred()) SWIG_fail;
48133 }
48134 resultobj = SWIG_Py_Void();
48135 {
48136 if (temp3)
48137 delete arg3;
48138 }
48139 return resultobj;
48140fail:
48141 {
48142 if (temp3)
48143 delete arg3;
48144 }
48145 return NULL;
48146}
48147
48148
48149SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48150 PyObject *resultobj = 0;
48151 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48152 wxString *arg2 = 0 ;
48153 int result;
48154 void *argp1 = 0 ;
48155 int res1 = 0 ;
48156 bool temp2 = false ;
48157 PyObject * obj0 = 0 ;
48158 PyObject * obj1 = 0 ;
48159 char * kwnames[] = {
48160 (char *) "self",(char *) "s", NULL
48161 };
48162
48163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48165 if (!SWIG_IsOK(res1)) {
48166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48167 }
48168 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48169 {
48170 arg2 = wxString_in_helper(obj1);
48171 if (arg2 == NULL) SWIG_fail;
48172 temp2 = true;
48173 }
48174 {
48175 PyThreadState* __tstate = wxPyBeginAllowThreads();
48176 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48177 wxPyEndAllowThreads(__tstate);
48178 if (PyErr_Occurred()) SWIG_fail;
48179 }
48180 resultobj = SWIG_From_int(static_cast< int >(result));
48181 {
48182 if (temp2)
48183 delete arg2;
48184 }
48185 return resultobj;
48186fail:
48187 {
48188 if (temp2)
48189 delete arg2;
48190 }
48191 return NULL;
48192}
48193
48194
48195SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48196 PyObject *resultobj = 0;
48197 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48198 int arg2 ;
48199 void *argp1 = 0 ;
48200 int res1 = 0 ;
48201 int val2 ;
48202 int ecode2 = 0 ;
48203 PyObject * obj0 = 0 ;
48204 PyObject * obj1 = 0 ;
48205 char * kwnames[] = {
48206 (char *) "self",(char *) "n", NULL
48207 };
48208
48209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48211 if (!SWIG_IsOK(res1)) {
48212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48213 }
48214 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48215 ecode2 = SWIG_AsVal_int(obj1, &val2);
48216 if (!SWIG_IsOK(ecode2)) {
48217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48218 }
48219 arg2 = static_cast< int >(val2);
48220 {
48221 PyThreadState* __tstate = wxPyBeginAllowThreads();
48222 (arg1)->SetSelection(arg2);
48223 wxPyEndAllowThreads(__tstate);
48224 if (PyErr_Occurred()) SWIG_fail;
48225 }
48226 resultobj = SWIG_Py_Void();
48227 return resultobj;
48228fail:
48229 return NULL;
d55e5bfc
RD
48230}
48231
48232
1bd55598
RD
48233SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48234 PyObject *resultobj = 0;
48235 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48236 int result;
48237 void *argp1 = 0 ;
48238 int res1 = 0 ;
48239 PyObject *swig_obj[1] ;
48240
48241 if (!args) SWIG_fail;
48242 swig_obj[0] = args;
48243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48244 if (!SWIG_IsOK(res1)) {
48245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48246 }
48247 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48248 {
48249 PyThreadState* __tstate = wxPyBeginAllowThreads();
48250 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48251 wxPyEndAllowThreads(__tstate);
48252 if (PyErr_Occurred()) SWIG_fail;
48253 }
48254 resultobj = SWIG_From_int(static_cast< int >(result));
48255 return resultobj;
48256fail:
48257 return NULL;
48258}
48259
48260
48261SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48262 PyObject *resultobj = 0;
48263 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48264 wxString *arg2 = 0 ;
48265 bool result;
48266 void *argp1 = 0 ;
48267 int res1 = 0 ;
48268 bool temp2 = false ;
48269 PyObject * obj0 = 0 ;
48270 PyObject * obj1 = 0 ;
48271 char * kwnames[] = {
48272 (char *) "self",(char *) "s", NULL
48273 };
48274
48275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48277 if (!SWIG_IsOK(res1)) {
48278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48279 }
48280 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48281 {
48282 arg2 = wxString_in_helper(obj1);
48283 if (arg2 == NULL) SWIG_fail;
48284 temp2 = true;
48285 }
48286 {
48287 PyThreadState* __tstate = wxPyBeginAllowThreads();
48288 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48289 wxPyEndAllowThreads(__tstate);
48290 if (PyErr_Occurred()) SWIG_fail;
48291 }
48292 {
48293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48294 }
48295 {
48296 if (temp2)
48297 delete arg2;
48298 }
48299 return resultobj;
48300fail:
48301 {
48302 if (temp2)
48303 delete arg2;
48304 }
48305 return NULL;
d55e5bfc
RD
48306}
48307
48308
1bd55598
RD
48309SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48310 PyObject *resultobj = 0;
48311 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48312 wxString result;
48313 void *argp1 = 0 ;
48314 int res1 = 0 ;
48315 PyObject *swig_obj[1] ;
48316
48317 if (!args) SWIG_fail;
48318 swig_obj[0] = args;
48319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48320 if (!SWIG_IsOK(res1)) {
48321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48322 }
48323 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48324 {
48325 PyThreadState* __tstate = wxPyBeginAllowThreads();
48326 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48327 wxPyEndAllowThreads(__tstate);
48328 if (PyErr_Occurred()) SWIG_fail;
48329 }
48330 {
48331#if wxUSE_UNICODE
48332 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48333#else
48334 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48335#endif
48336 }
48337 return resultobj;
48338fail:
48339 return NULL;
48340}
48341
48342
48343SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48344 PyObject *resultobj = 0;
48345 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48346 int arg2 ;
48347 void *argp1 = 0 ;
48348 int res1 = 0 ;
48349 int val2 ;
48350 int ecode2 = 0 ;
48351 PyObject * obj0 = 0 ;
48352 PyObject * obj1 = 0 ;
48353 char * kwnames[] = {
48354 (char *) "self",(char *) "n", NULL
48355 };
48356
48357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48359 if (!SWIG_IsOK(res1)) {
48360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48361 }
48362 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48363 ecode2 = SWIG_AsVal_int(obj1, &val2);
48364 if (!SWIG_IsOK(ecode2)) {
48365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48366 }
48367 arg2 = static_cast< int >(val2);
48368 {
48369 PyThreadState* __tstate = wxPyBeginAllowThreads();
48370 (arg1)->Select(arg2);
48371 wxPyEndAllowThreads(__tstate);
48372 if (PyErr_Occurred()) SWIG_fail;
48373 }
48374 resultobj = SWIG_Py_Void();
48375 return resultobj;
48376fail:
48377 return NULL;
d55e5bfc
RD
48378}
48379
48380
1bd55598
RD
48381SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48382 PyObject *obj;
48383 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48384 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48385 return SWIG_Py_Void();
d55e5bfc
RD
48386}
48387
1bd55598
RD
48388SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48389 PyObject *obj;
48390 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48391 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48392 return SWIG_Py_Void();
d55e5bfc
RD
48393}
48394
1bd55598
RD
48395SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48396 PyObject *resultobj = 0;
48397 wxSizerItem *result = 0 ;
48398
48399 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48400 {
48401 PyThreadState* __tstate = wxPyBeginAllowThreads();
48402 result = (wxSizerItem *)new wxSizerItem();
48403 wxPyEndAllowThreads(__tstate);
48404 if (PyErr_Occurred()) SWIG_fail;
48405 }
48406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48407 return resultobj;
48408fail:
48409 return NULL;
d55e5bfc
RD
48410}
48411
48412
1bd55598
RD
48413SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48414 PyObject *resultobj = 0;
48415 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
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_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48423 if (!SWIG_IsOK(res1)) {
48424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48425 }
48426 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48427 {
48428 PyThreadState* __tstate = wxPyBeginAllowThreads();
48429 delete arg1;
d55e5bfc 48430
1bd55598
RD
48431 wxPyEndAllowThreads(__tstate);
48432 if (PyErr_Occurred()) SWIG_fail;
48433 }
48434 resultobj = SWIG_Py_Void();
48435 return resultobj;
48436fail:
48437 return NULL;
48438}
48439
48440
48441SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48442 PyObject *resultobj = 0;
48443 wxWindow *arg1 = (wxWindow *) 0 ;
48444 int arg2 ;
48445 int arg3 ;
48446 int arg4 ;
48447 PyObject *arg5 = (PyObject *) NULL ;
48448 wxSizerItem *result = 0 ;
48449 void *argp1 = 0 ;
48450 int res1 = 0 ;
48451 int val2 ;
48452 int ecode2 = 0 ;
48453 int val3 ;
48454 int ecode3 = 0 ;
48455 int val4 ;
48456 int ecode4 = 0 ;
48457 PyObject * obj0 = 0 ;
48458 PyObject * obj1 = 0 ;
48459 PyObject * obj2 = 0 ;
48460 PyObject * obj3 = 0 ;
48461 PyObject * obj4 = 0 ;
48462 char * kwnames[] = {
48463 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48464 };
48465
48466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48468 if (!SWIG_IsOK(res1)) {
48469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48470 }
48471 arg1 = reinterpret_cast< wxWindow * >(argp1);
48472 ecode2 = SWIG_AsVal_int(obj1, &val2);
48473 if (!SWIG_IsOK(ecode2)) {
48474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48475 }
48476 arg2 = static_cast< int >(val2);
48477 ecode3 = SWIG_AsVal_int(obj2, &val3);
48478 if (!SWIG_IsOK(ecode3)) {
48479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48480 }
48481 arg3 = static_cast< int >(val3);
48482 ecode4 = SWIG_AsVal_int(obj3, &val4);
48483 if (!SWIG_IsOK(ecode4)) {
48484 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48485 }
48486 arg4 = static_cast< int >(val4);
48487 if (obj4) {
48488 arg5 = obj4;
48489 }
48490 {
48491 PyThreadState* __tstate = wxPyBeginAllowThreads();
48492 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48493 wxPyEndAllowThreads(__tstate);
48494 if (PyErr_Occurred()) SWIG_fail;
48495 }
48496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48497 return resultobj;
48498fail:
48499 return NULL;
48500}
48501
48502
48503SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48504 PyObject *resultobj = 0;
48505 int arg1 ;
48506 int arg2 ;
48507 int arg3 ;
48508 int arg4 ;
48509 int arg5 ;
48510 PyObject *arg6 = (PyObject *) NULL ;
48511 wxSizerItem *result = 0 ;
48512 int val1 ;
48513 int ecode1 = 0 ;
48514 int val2 ;
48515 int ecode2 = 0 ;
48516 int val3 ;
48517 int ecode3 = 0 ;
48518 int val4 ;
48519 int ecode4 = 0 ;
48520 int val5 ;
48521 int ecode5 = 0 ;
48522 PyObject * obj0 = 0 ;
48523 PyObject * obj1 = 0 ;
48524 PyObject * obj2 = 0 ;
48525 PyObject * obj3 = 0 ;
48526 PyObject * obj4 = 0 ;
48527 PyObject * obj5 = 0 ;
48528 char * kwnames[] = {
48529 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48530 };
48531
48532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48533 ecode1 = SWIG_AsVal_int(obj0, &val1);
48534 if (!SWIG_IsOK(ecode1)) {
48535 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48536 }
48537 arg1 = static_cast< int >(val1);
48538 ecode2 = SWIG_AsVal_int(obj1, &val2);
48539 if (!SWIG_IsOK(ecode2)) {
48540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48541 }
48542 arg2 = static_cast< int >(val2);
48543 ecode3 = SWIG_AsVal_int(obj2, &val3);
48544 if (!SWIG_IsOK(ecode3)) {
48545 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48546 }
48547 arg3 = static_cast< int >(val3);
48548 ecode4 = SWIG_AsVal_int(obj3, &val4);
48549 if (!SWIG_IsOK(ecode4)) {
48550 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48551 }
48552 arg4 = static_cast< int >(val4);
48553 ecode5 = SWIG_AsVal_int(obj4, &val5);
48554 if (!SWIG_IsOK(ecode5)) {
48555 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48556 }
48557 arg5 = static_cast< int >(val5);
48558 if (obj5) {
48559 arg6 = obj5;
48560 }
48561 {
48562 PyThreadState* __tstate = wxPyBeginAllowThreads();
48563 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48564 wxPyEndAllowThreads(__tstate);
48565 if (PyErr_Occurred()) SWIG_fail;
48566 }
48567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48568 return resultobj;
48569fail:
48570 return NULL;
48571}
48572
48573
48574SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48575 PyObject *resultobj = 0;
48576 wxSizer *arg1 = (wxSizer *) 0 ;
48577 int arg2 ;
48578 int arg3 ;
48579 int arg4 ;
48580 PyObject *arg5 = (PyObject *) NULL ;
48581 wxSizerItem *result = 0 ;
48582 int res1 = 0 ;
48583 int val2 ;
48584 int ecode2 = 0 ;
48585 int val3 ;
48586 int ecode3 = 0 ;
48587 int val4 ;
48588 int ecode4 = 0 ;
48589 PyObject * obj0 = 0 ;
48590 PyObject * obj1 = 0 ;
48591 PyObject * obj2 = 0 ;
48592 PyObject * obj3 = 0 ;
48593 PyObject * obj4 = 0 ;
48594 char * kwnames[] = {
48595 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48596 };
48597
48598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48599 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48600 if (!SWIG_IsOK(res1)) {
48601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48602 }
48603 ecode2 = SWIG_AsVal_int(obj1, &val2);
48604 if (!SWIG_IsOK(ecode2)) {
48605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48606 }
48607 arg2 = static_cast< int >(val2);
48608 ecode3 = SWIG_AsVal_int(obj2, &val3);
48609 if (!SWIG_IsOK(ecode3)) {
48610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48611 }
48612 arg3 = static_cast< int >(val3);
48613 ecode4 = SWIG_AsVal_int(obj3, &val4);
48614 if (!SWIG_IsOK(ecode4)) {
48615 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48616 }
48617 arg4 = static_cast< int >(val4);
48618 if (obj4) {
48619 arg5 = obj4;
48620 }
48621 {
48622 PyThreadState* __tstate = wxPyBeginAllowThreads();
48623 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48624 wxPyEndAllowThreads(__tstate);
48625 if (PyErr_Occurred()) SWIG_fail;
48626 }
48627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48628 return resultobj;
48629fail:
48630 return NULL;
d55e5bfc
RD
48631}
48632
48633
1bd55598
RD
48634SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48635 PyObject *resultobj = 0;
48636 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48637 void *argp1 = 0 ;
48638 int res1 = 0 ;
48639 PyObject *swig_obj[1] ;
48640
48641 if (!args) SWIG_fail;
48642 swig_obj[0] = args;
48643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48644 if (!SWIG_IsOK(res1)) {
48645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48646 }
48647 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48648 {
48649 PyThreadState* __tstate = wxPyBeginAllowThreads();
48650 (arg1)->DeleteWindows();
48651 wxPyEndAllowThreads(__tstate);
48652 if (PyErr_Occurred()) SWIG_fail;
48653 }
48654 resultobj = SWIG_Py_Void();
48655 return resultobj;
48656fail:
48657 return NULL;
d55e5bfc
RD
48658}
48659
48660
1bd55598
RD
48661SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48662 PyObject *resultobj = 0;
48663 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48664 void *argp1 = 0 ;
48665 int res1 = 0 ;
48666 PyObject *swig_obj[1] ;
48667
48668 if (!args) SWIG_fail;
48669 swig_obj[0] = args;
48670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48671 if (!SWIG_IsOK(res1)) {
48672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48673 }
48674 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48675 {
48676 PyThreadState* __tstate = wxPyBeginAllowThreads();
48677 (arg1)->DetachSizer();
48678 wxPyEndAllowThreads(__tstate);
48679 if (PyErr_Occurred()) SWIG_fail;
48680 }
48681 resultobj = SWIG_Py_Void();
48682 return resultobj;
48683fail:
48684 return NULL;
d55e5bfc
RD
48685}
48686
48687
1bd55598
RD
48688SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48689 PyObject *resultobj = 0;
48690 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48691 wxSize result;
48692 void *argp1 = 0 ;
48693 int res1 = 0 ;
48694 PyObject *swig_obj[1] ;
48695
48696 if (!args) SWIG_fail;
48697 swig_obj[0] = args;
48698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48699 if (!SWIG_IsOK(res1)) {
48700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48701 }
48702 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48703 {
48704 PyThreadState* __tstate = wxPyBeginAllowThreads();
48705 result = (arg1)->GetSize();
48706 wxPyEndAllowThreads(__tstate);
48707 if (PyErr_Occurred()) SWIG_fail;
48708 }
48709 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48710 return resultobj;
48711fail:
48712 return NULL;
d55e5bfc
RD
48713}
48714
48715
1bd55598
RD
48716SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48717 PyObject *resultobj = 0;
48718 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48719 wxSize result;
48720 void *argp1 = 0 ;
48721 int res1 = 0 ;
48722 PyObject *swig_obj[1] ;
48723
48724 if (!args) SWIG_fail;
48725 swig_obj[0] = args;
48726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48727 if (!SWIG_IsOK(res1)) {
48728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48729 }
48730 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48731 {
48732 PyThreadState* __tstate = wxPyBeginAllowThreads();
48733 result = (arg1)->CalcMin();
48734 wxPyEndAllowThreads(__tstate);
48735 if (PyErr_Occurred()) SWIG_fail;
48736 }
48737 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48738 return resultobj;
48739fail:
48740 return NULL;
48741}
48742
48743
48744SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48745 PyObject *resultobj = 0;
48746 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48747 wxPoint *arg2 = 0 ;
48748 wxSize *arg3 = 0 ;
48749 void *argp1 = 0 ;
48750 int res1 = 0 ;
48751 wxPoint temp2 ;
48752 wxSize temp3 ;
48753 PyObject * obj0 = 0 ;
48754 PyObject * obj1 = 0 ;
48755 PyObject * obj2 = 0 ;
48756 char * kwnames[] = {
48757 (char *) "self",(char *) "pos",(char *) "size", NULL
48758 };
48759
48760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48762 if (!SWIG_IsOK(res1)) {
48763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48764 }
48765 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48766 {
48767 arg2 = &temp2;
48768 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48769 }
48770 {
48771 arg3 = &temp3;
48772 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48773 }
48774 {
48775 PyThreadState* __tstate = wxPyBeginAllowThreads();
48776 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48777 wxPyEndAllowThreads(__tstate);
48778 if (PyErr_Occurred()) SWIG_fail;
48779 }
48780 resultobj = SWIG_Py_Void();
48781 return resultobj;
48782fail:
48783 return NULL;
d55e5bfc
RD
48784}
48785
48786
1bd55598
RD
48787SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48788 PyObject *resultobj = 0;
48789 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48790 wxSize result;
48791 void *argp1 = 0 ;
48792 int res1 = 0 ;
48793 PyObject *swig_obj[1] ;
48794
48795 if (!args) SWIG_fail;
48796 swig_obj[0] = args;
48797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48798 if (!SWIG_IsOK(res1)) {
48799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48800 }
48801 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48802 {
48803 PyThreadState* __tstate = wxPyBeginAllowThreads();
48804 result = (arg1)->GetMinSize();
48805 wxPyEndAllowThreads(__tstate);
48806 if (PyErr_Occurred()) SWIG_fail;
48807 }
48808 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48809 return resultobj;
48810fail:
48811 return NULL;
d55e5bfc
RD
48812}
48813
48814
1bd55598
RD
48815SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48816 PyObject *resultobj = 0;
48817 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48818 wxSize result;
48819 void *argp1 = 0 ;
48820 int res1 = 0 ;
48821 PyObject *swig_obj[1] ;
48822
48823 if (!args) SWIG_fail;
48824 swig_obj[0] = args;
48825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48826 if (!SWIG_IsOK(res1)) {
48827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48828 }
48829 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48830 {
48831 PyThreadState* __tstate = wxPyBeginAllowThreads();
48832 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48833 wxPyEndAllowThreads(__tstate);
48834 if (PyErr_Occurred()) SWIG_fail;
48835 }
48836 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48837 return resultobj;
48838fail:
48839 return NULL;
48840}
48841
48842
48843SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48844 PyObject *resultobj = 0;
48845 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48846 int arg2 ;
48847 int arg3 ;
48848 void *argp1 = 0 ;
48849 int res1 = 0 ;
48850 int val2 ;
48851 int ecode2 = 0 ;
48852 int val3 ;
48853 int ecode3 = 0 ;
48854 PyObject * obj0 = 0 ;
48855 PyObject * obj1 = 0 ;
48856 PyObject * obj2 = 0 ;
48857 char * kwnames[] = {
48858 (char *) "self",(char *) "x",(char *) "y", NULL
48859 };
48860
48861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48863 if (!SWIG_IsOK(res1)) {
48864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48865 }
48866 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48867 ecode2 = SWIG_AsVal_int(obj1, &val2);
48868 if (!SWIG_IsOK(ecode2)) {
48869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48870 }
48871 arg2 = static_cast< int >(val2);
48872 ecode3 = SWIG_AsVal_int(obj2, &val3);
48873 if (!SWIG_IsOK(ecode3)) {
48874 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48875 }
48876 arg3 = static_cast< int >(val3);
48877 {
48878 PyThreadState* __tstate = wxPyBeginAllowThreads();
48879 (arg1)->SetInitSize(arg2,arg3);
48880 wxPyEndAllowThreads(__tstate);
48881 if (PyErr_Occurred()) SWIG_fail;
48882 }
48883 resultobj = SWIG_Py_Void();
48884 return resultobj;
48885fail:
48886 return NULL;
48887}
48888
48889
48890SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48891 PyObject *resultobj = 0;
48892 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48893 int arg2 ;
48894 int arg3 ;
48895 void *argp1 = 0 ;
48896 int res1 = 0 ;
48897 int val2 ;
48898 int ecode2 = 0 ;
48899 int val3 ;
48900 int ecode3 = 0 ;
48901 PyObject * obj0 = 0 ;
48902 PyObject * obj1 = 0 ;
48903 PyObject * obj2 = 0 ;
48904 char * kwnames[] = {
48905 (char *) "self",(char *) "width",(char *) "height", NULL
48906 };
48907
48908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48910 if (!SWIG_IsOK(res1)) {
48911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48912 }
48913 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48914 ecode2 = SWIG_AsVal_int(obj1, &val2);
48915 if (!SWIG_IsOK(ecode2)) {
48916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48917 }
48918 arg2 = static_cast< int >(val2);
48919 ecode3 = SWIG_AsVal_int(obj2, &val3);
48920 if (!SWIG_IsOK(ecode3)) {
48921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48922 }
48923 arg3 = static_cast< int >(val3);
48924 {
48925 PyThreadState* __tstate = wxPyBeginAllowThreads();
48926 (arg1)->SetRatio(arg2,arg3);
48927 wxPyEndAllowThreads(__tstate);
48928 if (PyErr_Occurred()) SWIG_fail;
48929 }
48930 resultobj = SWIG_Py_Void();
48931 return resultobj;
48932fail:
48933 return NULL;
48934}
48935
48936
48937SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48938 PyObject *resultobj = 0;
48939 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48940 wxSize *arg2 = 0 ;
48941 void *argp1 = 0 ;
48942 int res1 = 0 ;
48943 wxSize temp2 ;
48944 PyObject * obj0 = 0 ;
48945 PyObject * obj1 = 0 ;
48946 char * kwnames[] = {
48947 (char *) "self",(char *) "size", NULL
48948 };
48949
48950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48952 if (!SWIG_IsOK(res1)) {
48953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48954 }
48955 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48956 {
48957 arg2 = &temp2;
48958 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48959 }
48960 {
48961 PyThreadState* __tstate = wxPyBeginAllowThreads();
48962 (arg1)->SetRatio((wxSize const &)*arg2);
48963 wxPyEndAllowThreads(__tstate);
48964 if (PyErr_Occurred()) SWIG_fail;
48965 }
48966 resultobj = SWIG_Py_Void();
48967 return resultobj;
48968fail:
48969 return NULL;
48970}
48971
48972
48973SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48974 PyObject *resultobj = 0;
48975 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48976 float arg2 ;
48977 void *argp1 = 0 ;
48978 int res1 = 0 ;
48979 float val2 ;
48980 int ecode2 = 0 ;
48981 PyObject * obj0 = 0 ;
48982 PyObject * obj1 = 0 ;
48983 char * kwnames[] = {
48984 (char *) "self",(char *) "ratio", NULL
48985 };
48986
48987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
48988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48989 if (!SWIG_IsOK(res1)) {
48990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48991 }
48992 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48993 ecode2 = SWIG_AsVal_float(obj1, &val2);
48994 if (!SWIG_IsOK(ecode2)) {
48995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
48996 }
48997 arg2 = static_cast< float >(val2);
48998 {
48999 PyThreadState* __tstate = wxPyBeginAllowThreads();
49000 (arg1)->SetRatio(arg2);
49001 wxPyEndAllowThreads(__tstate);
49002 if (PyErr_Occurred()) SWIG_fail;
49003 }
49004 resultobj = SWIG_Py_Void();
49005 return resultobj;
49006fail:
49007 return NULL;
d55e5bfc
RD
49008}
49009
49010
1bd55598
RD
49011SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49012 PyObject *resultobj = 0;
49013 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49014 float result;
49015 void *argp1 = 0 ;
49016 int res1 = 0 ;
49017 PyObject *swig_obj[1] ;
49018
49019 if (!args) SWIG_fail;
49020 swig_obj[0] = args;
49021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49022 if (!SWIG_IsOK(res1)) {
49023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49024 }
49025 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49026 {
49027 PyThreadState* __tstate = wxPyBeginAllowThreads();
49028 result = (float)(arg1)->GetRatio();
49029 wxPyEndAllowThreads(__tstate);
49030 if (PyErr_Occurred()) SWIG_fail;
49031 }
49032 resultobj = SWIG_From_float(static_cast< float >(result));
49033 return resultobj;
49034fail:
49035 return NULL;
d55e5bfc
RD
49036}
49037
49038
1bd55598
RD
49039SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49040 PyObject *resultobj = 0;
49041 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49042 wxRect result;
49043 void *argp1 = 0 ;
49044 int res1 = 0 ;
49045 PyObject *swig_obj[1] ;
49046
49047 if (!args) SWIG_fail;
49048 swig_obj[0] = args;
49049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49050 if (!SWIG_IsOK(res1)) {
49051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49052 }
49053 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49054 {
49055 PyThreadState* __tstate = wxPyBeginAllowThreads();
49056 result = (arg1)->GetRect();
49057 wxPyEndAllowThreads(__tstate);
49058 if (PyErr_Occurred()) SWIG_fail;
49059 }
49060 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
49061 return resultobj;
49062fail:
49063 return NULL;
d55e5bfc
RD
49064}
49065
49066
1bd55598
RD
49067SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49068 PyObject *resultobj = 0;
49069 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49070 bool result;
49071 void *argp1 = 0 ;
49072 int res1 = 0 ;
49073 PyObject *swig_obj[1] ;
49074
49075 if (!args) SWIG_fail;
49076 swig_obj[0] = args;
49077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49078 if (!SWIG_IsOK(res1)) {
49079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49080 }
49081 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49082 {
49083 PyThreadState* __tstate = wxPyBeginAllowThreads();
49084 result = (bool)(arg1)->IsWindow();
49085 wxPyEndAllowThreads(__tstate);
49086 if (PyErr_Occurred()) SWIG_fail;
49087 }
49088 {
49089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49090 }
49091 return resultobj;
49092fail:
49093 return NULL;
f8167d6e
RD
49094}
49095
49096
1bd55598
RD
49097SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49098 PyObject *resultobj = 0;
49099 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49100 bool result;
49101 void *argp1 = 0 ;
49102 int res1 = 0 ;
49103 PyObject *swig_obj[1] ;
49104
49105 if (!args) SWIG_fail;
49106 swig_obj[0] = args;
49107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49108 if (!SWIG_IsOK(res1)) {
49109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49110 }
49111 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49112 {
49113 PyThreadState* __tstate = wxPyBeginAllowThreads();
49114 result = (bool)(arg1)->IsSizer();
49115 wxPyEndAllowThreads(__tstate);
49116 if (PyErr_Occurred()) SWIG_fail;
49117 }
49118 {
49119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49120 }
49121 return resultobj;
49122fail:
49123 return NULL;
d55e5bfc
RD
49124}
49125
49126
1bd55598
RD
49127SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49128 PyObject *resultobj = 0;
49129 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49130 bool result;
49131 void *argp1 = 0 ;
49132 int res1 = 0 ;
49133 PyObject *swig_obj[1] ;
49134
49135 if (!args) SWIG_fail;
49136 swig_obj[0] = args;
49137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49138 if (!SWIG_IsOK(res1)) {
49139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49140 }
49141 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49142 {
49143 PyThreadState* __tstate = wxPyBeginAllowThreads();
49144 result = (bool)(arg1)->IsSpacer();
49145 wxPyEndAllowThreads(__tstate);
49146 if (PyErr_Occurred()) SWIG_fail;
49147 }
49148 {
49149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49150 }
49151 return resultobj;
49152fail:
49153 return NULL;
49154}
49155
49156
49157SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49158 PyObject *resultobj = 0;
49159 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49160 int arg2 ;
49161 void *argp1 = 0 ;
49162 int res1 = 0 ;
49163 int val2 ;
49164 int ecode2 = 0 ;
49165 PyObject * obj0 = 0 ;
49166 PyObject * obj1 = 0 ;
49167 char * kwnames[] = {
49168 (char *) "self",(char *) "proportion", NULL
49169 };
49170
49171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49173 if (!SWIG_IsOK(res1)) {
49174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49175 }
49176 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49177 ecode2 = SWIG_AsVal_int(obj1, &val2);
49178 if (!SWIG_IsOK(ecode2)) {
49179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49180 }
49181 arg2 = static_cast< int >(val2);
49182 {
49183 PyThreadState* __tstate = wxPyBeginAllowThreads();
49184 (arg1)->SetProportion(arg2);
49185 wxPyEndAllowThreads(__tstate);
49186 if (PyErr_Occurred()) SWIG_fail;
49187 }
49188 resultobj = SWIG_Py_Void();
49189 return resultobj;
49190fail:
49191 return NULL;
d55e5bfc
RD
49192}
49193
49194
1bd55598
RD
49195SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49196 PyObject *resultobj = 0;
49197 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49198 int result;
49199 void *argp1 = 0 ;
49200 int res1 = 0 ;
49201 PyObject *swig_obj[1] ;
49202
49203 if (!args) SWIG_fail;
49204 swig_obj[0] = args;
49205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49206 if (!SWIG_IsOK(res1)) {
49207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49208 }
49209 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49210 {
49211 PyThreadState* __tstate = wxPyBeginAllowThreads();
49212 result = (int)(arg1)->GetProportion();
49213 wxPyEndAllowThreads(__tstate);
49214 if (PyErr_Occurred()) SWIG_fail;
49215 }
49216 resultobj = SWIG_From_int(static_cast< int >(result));
49217 return resultobj;
49218fail:
49219 return NULL;
49220}
49221
49222
49223SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49224 PyObject *resultobj = 0;
49225 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49226 int arg2 ;
49227 void *argp1 = 0 ;
49228 int res1 = 0 ;
49229 int val2 ;
49230 int ecode2 = 0 ;
49231 PyObject * obj0 = 0 ;
49232 PyObject * obj1 = 0 ;
49233 char * kwnames[] = {
49234 (char *) "self",(char *) "flag", NULL
49235 };
49236
49237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49239 if (!SWIG_IsOK(res1)) {
49240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49241 }
49242 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49243 ecode2 = SWIG_AsVal_int(obj1, &val2);
49244 if (!SWIG_IsOK(ecode2)) {
49245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49246 }
49247 arg2 = static_cast< int >(val2);
49248 {
49249 PyThreadState* __tstate = wxPyBeginAllowThreads();
49250 (arg1)->SetFlag(arg2);
49251 wxPyEndAllowThreads(__tstate);
49252 if (PyErr_Occurred()) SWIG_fail;
49253 }
49254 resultobj = SWIG_Py_Void();
49255 return resultobj;
49256fail:
49257 return NULL;
d55e5bfc
RD
49258}
49259
49260
1bd55598
RD
49261SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49262 PyObject *resultobj = 0;
49263 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49264 int result;
49265 void *argp1 = 0 ;
49266 int res1 = 0 ;
49267 PyObject *swig_obj[1] ;
49268
49269 if (!args) SWIG_fail;
49270 swig_obj[0] = args;
49271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49272 if (!SWIG_IsOK(res1)) {
49273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49274 }
49275 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49276 {
49277 PyThreadState* __tstate = wxPyBeginAllowThreads();
49278 result = (int)(arg1)->GetFlag();
49279 wxPyEndAllowThreads(__tstate);
49280 if (PyErr_Occurred()) SWIG_fail;
49281 }
49282 resultobj = SWIG_From_int(static_cast< int >(result));
49283 return resultobj;
49284fail:
49285 return NULL;
49286}
49287
49288
49289SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49290 PyObject *resultobj = 0;
49291 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49292 int arg2 ;
49293 void *argp1 = 0 ;
49294 int res1 = 0 ;
49295 int val2 ;
49296 int ecode2 = 0 ;
49297 PyObject * obj0 = 0 ;
49298 PyObject * obj1 = 0 ;
49299 char * kwnames[] = {
49300 (char *) "self",(char *) "border", NULL
49301 };
49302
49303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49305 if (!SWIG_IsOK(res1)) {
49306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49307 }
49308 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49309 ecode2 = SWIG_AsVal_int(obj1, &val2);
49310 if (!SWIG_IsOK(ecode2)) {
49311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49312 }
49313 arg2 = static_cast< int >(val2);
49314 {
49315 PyThreadState* __tstate = wxPyBeginAllowThreads();
49316 (arg1)->SetBorder(arg2);
49317 wxPyEndAllowThreads(__tstate);
49318 if (PyErr_Occurred()) SWIG_fail;
49319 }
49320 resultobj = SWIG_Py_Void();
49321 return resultobj;
49322fail:
49323 return NULL;
d55e5bfc
RD
49324}
49325
49326
1bd55598
RD
49327SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49328 PyObject *resultobj = 0;
49329 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49330 int result;
49331 void *argp1 = 0 ;
49332 int res1 = 0 ;
49333 PyObject *swig_obj[1] ;
49334
49335 if (!args) SWIG_fail;
49336 swig_obj[0] = args;
49337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49338 if (!SWIG_IsOK(res1)) {
49339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49340 }
49341 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49342 {
49343 PyThreadState* __tstate = wxPyBeginAllowThreads();
49344 result = (int)(arg1)->GetBorder();
49345 wxPyEndAllowThreads(__tstate);
49346 if (PyErr_Occurred()) SWIG_fail;
49347 }
49348 resultobj = SWIG_From_int(static_cast< int >(result));
49349 return resultobj;
49350fail:
49351 return NULL;
d55e5bfc
RD
49352}
49353
49354
1bd55598
RD
49355SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49356 PyObject *resultobj = 0;
49357 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49358 wxWindow *result = 0 ;
49359 void *argp1 = 0 ;
49360 int res1 = 0 ;
49361 PyObject *swig_obj[1] ;
49362
49363 if (!args) SWIG_fail;
49364 swig_obj[0] = args;
49365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49366 if (!SWIG_IsOK(res1)) {
49367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49368 }
49369 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49370 {
49371 PyThreadState* __tstate = wxPyBeginAllowThreads();
49372 result = (wxWindow *)(arg1)->GetWindow();
49373 wxPyEndAllowThreads(__tstate);
49374 if (PyErr_Occurred()) SWIG_fail;
49375 }
49376 {
49377 resultobj = wxPyMake_wxObject(result, 0);
49378 }
49379 return resultobj;
49380fail:
49381 return NULL;
49382}
49383
49384
49385SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49386 PyObject *resultobj = 0;
49387 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49388 wxWindow *arg2 = (wxWindow *) 0 ;
49389 void *argp1 = 0 ;
49390 int res1 = 0 ;
49391 void *argp2 = 0 ;
49392 int res2 = 0 ;
49393 PyObject * obj0 = 0 ;
49394 PyObject * obj1 = 0 ;
49395 char * kwnames[] = {
49396 (char *) "self",(char *) "window", NULL
49397 };
49398
49399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49401 if (!SWIG_IsOK(res1)) {
49402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49403 }
49404 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49405 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49406 if (!SWIG_IsOK(res2)) {
49407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49408 }
49409 arg2 = reinterpret_cast< wxWindow * >(argp2);
49410 {
49411 PyThreadState* __tstate = wxPyBeginAllowThreads();
49412 (arg1)->SetWindow(arg2);
49413 wxPyEndAllowThreads(__tstate);
49414 if (PyErr_Occurred()) SWIG_fail;
49415 }
49416 resultobj = SWIG_Py_Void();
49417 return resultobj;
49418fail:
49419 return NULL;
d55e5bfc
RD
49420}
49421
49422
1bd55598
RD
49423SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49424 PyObject *resultobj = 0;
49425 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49426 wxSizer *result = 0 ;
49427 void *argp1 = 0 ;
49428 int res1 = 0 ;
49429 PyObject *swig_obj[1] ;
49430
49431 if (!args) SWIG_fail;
49432 swig_obj[0] = args;
49433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49434 if (!SWIG_IsOK(res1)) {
49435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49436 }
49437 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49438 {
49439 PyThreadState* __tstate = wxPyBeginAllowThreads();
49440 result = (wxSizer *)(arg1)->GetSizer();
49441 wxPyEndAllowThreads(__tstate);
49442 if (PyErr_Occurred()) SWIG_fail;
49443 }
49444 {
49445 resultobj = wxPyMake_wxObject(result, (bool)0);
49446 }
49447 return resultobj;
49448fail:
49449 return NULL;
49450}
49451
49452
49453SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49454 PyObject *resultobj = 0;
49455 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49456 wxSizer *arg2 = (wxSizer *) 0 ;
49457 void *argp1 = 0 ;
49458 int res1 = 0 ;
49459 int res2 = 0 ;
49460 PyObject * obj0 = 0 ;
49461 PyObject * obj1 = 0 ;
49462 char * kwnames[] = {
49463 (char *) "self",(char *) "sizer", NULL
49464 };
49465
49466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49468 if (!SWIG_IsOK(res1)) {
49469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49470 }
49471 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49472 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49473 if (!SWIG_IsOK(res2)) {
49474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49475 }
49476 {
49477 PyThreadState* __tstate = wxPyBeginAllowThreads();
49478 (arg1)->SetSizer(arg2);
49479 wxPyEndAllowThreads(__tstate);
49480 if (PyErr_Occurred()) SWIG_fail;
49481 }
49482 resultobj = SWIG_Py_Void();
49483 return resultobj;
49484fail:
49485 return NULL;
d55e5bfc
RD
49486}
49487
49488
1bd55598
RD
49489SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49490 PyObject *resultobj = 0;
49491 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
7753ca6b 49492 wxSize result;
1bd55598
RD
49493 void *argp1 = 0 ;
49494 int res1 = 0 ;
49495 PyObject *swig_obj[1] ;
49496
49497 if (!args) SWIG_fail;
49498 swig_obj[0] = args;
49499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49500 if (!SWIG_IsOK(res1)) {
49501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49502 }
49503 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49504 {
49505 PyThreadState* __tstate = wxPyBeginAllowThreads();
7753ca6b 49506 result = (arg1)->GetSpacer();
1bd55598
RD
49507 wxPyEndAllowThreads(__tstate);
49508 if (PyErr_Occurred()) SWIG_fail;
49509 }
7753ca6b 49510 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
1bd55598
RD
49511 return resultobj;
49512fail:
49513 return NULL;
49514}
49515
49516
49517SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49518 PyObject *resultobj = 0;
49519 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49520 wxSize *arg2 = 0 ;
49521 void *argp1 = 0 ;
49522 int res1 = 0 ;
49523 wxSize temp2 ;
49524 PyObject * obj0 = 0 ;
49525 PyObject * obj1 = 0 ;
49526 char * kwnames[] = {
49527 (char *) "self",(char *) "size", NULL
49528 };
49529
49530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49532 if (!SWIG_IsOK(res1)) {
49533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49534 }
49535 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49536 {
49537 arg2 = &temp2;
49538 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49539 }
49540 {
49541 PyThreadState* __tstate = wxPyBeginAllowThreads();
49542 (arg1)->SetSpacer((wxSize const &)*arg2);
49543 wxPyEndAllowThreads(__tstate);
49544 if (PyErr_Occurred()) SWIG_fail;
49545 }
49546 resultobj = SWIG_Py_Void();
49547 return resultobj;
49548fail:
49549 return NULL;
49550}
49551
49552
49553SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49554 PyObject *resultobj = 0;
49555 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49556 bool arg2 ;
49557 void *argp1 = 0 ;
49558 int res1 = 0 ;
49559 bool val2 ;
49560 int ecode2 = 0 ;
49561 PyObject * obj0 = 0 ;
49562 PyObject * obj1 = 0 ;
49563 char * kwnames[] = {
49564 (char *) "self",(char *) "show", NULL
49565 };
49566
49567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49569 if (!SWIG_IsOK(res1)) {
49570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49571 }
49572 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49573 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49574 if (!SWIG_IsOK(ecode2)) {
49575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49576 }
49577 arg2 = static_cast< bool >(val2);
49578 {
49579 PyThreadState* __tstate = wxPyBeginAllowThreads();
49580 (arg1)->Show(arg2);
49581 wxPyEndAllowThreads(__tstate);
49582 if (PyErr_Occurred()) SWIG_fail;
49583 }
49584 resultobj = SWIG_Py_Void();
49585 return resultobj;
49586fail:
49587 return NULL;
d55e5bfc
RD
49588}
49589
49590
1bd55598
RD
49591SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49592 PyObject *resultobj = 0;
49593 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49594 bool result;
49595 void *argp1 = 0 ;
49596 int res1 = 0 ;
49597 PyObject *swig_obj[1] ;
49598
49599 if (!args) SWIG_fail;
49600 swig_obj[0] = args;
49601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49602 if (!SWIG_IsOK(res1)) {
49603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49604 }
49605 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49606 {
49607 PyThreadState* __tstate = wxPyBeginAllowThreads();
49608 result = (bool)(arg1)->IsShown();
49609 wxPyEndAllowThreads(__tstate);
49610 if (PyErr_Occurred()) SWIG_fail;
49611 }
49612 {
49613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49614 }
49615 return resultobj;
49616fail:
49617 return NULL;
d55e5bfc
RD
49618}
49619
49620
1bd55598
RD
49621SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49622 PyObject *resultobj = 0;
49623 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49624 wxPoint result;
49625 void *argp1 = 0 ;
49626 int res1 = 0 ;
49627 PyObject *swig_obj[1] ;
49628
49629 if (!args) SWIG_fail;
49630 swig_obj[0] = args;
49631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49632 if (!SWIG_IsOK(res1)) {
49633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49634 }
49635 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49636 {
49637 PyThreadState* __tstate = wxPyBeginAllowThreads();
49638 result = (arg1)->GetPosition();
49639 wxPyEndAllowThreads(__tstate);
49640 if (PyErr_Occurred()) SWIG_fail;
49641 }
49642 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49643 return resultobj;
49644fail:
49645 return NULL;
d55e5bfc
RD
49646}
49647
49648
1bd55598
RD
49649SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49650 PyObject *resultobj = 0;
49651 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49652 PyObject *result = 0 ;
49653 void *argp1 = 0 ;
49654 int res1 = 0 ;
49655 PyObject *swig_obj[1] ;
49656
49657 if (!args) SWIG_fail;
49658 swig_obj[0] = args;
49659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49660 if (!SWIG_IsOK(res1)) {
49661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49662 }
49663 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49664 {
49665 PyThreadState* __tstate = wxPyBeginAllowThreads();
49666 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49667 wxPyEndAllowThreads(__tstate);
49668 if (PyErr_Occurred()) SWIG_fail;
49669 }
49670 resultobj = result;
49671 return resultobj;
49672fail:
49673 return NULL;
49674}
49675
49676
49677SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49678 PyObject *resultobj = 0;
49679 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49680 PyObject *arg2 = (PyObject *) 0 ;
49681 void *argp1 = 0 ;
49682 int res1 = 0 ;
49683 PyObject * obj0 = 0 ;
49684 PyObject * obj1 = 0 ;
49685 char * kwnames[] = {
49686 (char *) "self",(char *) "userData", NULL
49687 };
49688
49689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49691 if (!SWIG_IsOK(res1)) {
49692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49693 }
49694 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49695 arg2 = obj1;
49696 {
49697 PyThreadState* __tstate = wxPyBeginAllowThreads();
49698 wxSizerItem_SetUserData(arg1,arg2);
49699 wxPyEndAllowThreads(__tstate);
49700 if (PyErr_Occurred()) SWIG_fail;
49701 }
49702 resultobj = SWIG_Py_Void();
49703 return resultobj;
49704fail:
49705 return NULL;
d55e5bfc
RD
49706}
49707
49708
1bd55598
RD
49709SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49710 PyObject *obj;
49711 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49712 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49713 return SWIG_Py_Void();
d55e5bfc
RD
49714}
49715
1bd55598
RD
49716SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49717 return SWIG_Python_InitShadowInstance(args);
49718}
d55e5bfc 49719
1bd55598
RD
49720SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49721 PyObject *resultobj = 0;
49722 wxSizer *arg1 = (wxSizer *) 0 ;
49723 void *argp1 = 0 ;
49724 int res1 = 0 ;
49725 PyObject *swig_obj[1] ;
49726
49727 if (!args) SWIG_fail;
49728 swig_obj[0] = args;
49729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49730 if (!SWIG_IsOK(res1)) {
49731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49732 }
49733 arg1 = reinterpret_cast< wxSizer * >(argp1);
49734 {
49735 PyThreadState* __tstate = wxPyBeginAllowThreads();
49736 delete arg1;
d55e5bfc 49737
1bd55598
RD
49738 wxPyEndAllowThreads(__tstate);
49739 if (PyErr_Occurred()) SWIG_fail;
49740 }
49741 resultobj = SWIG_Py_Void();
49742 return resultobj;
49743fail:
49744 return NULL;
49745}
49746
49747
49748SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49749 PyObject *resultobj = 0;
49750 wxSizer *arg1 = (wxSizer *) 0 ;
49751 PyObject *arg2 = (PyObject *) 0 ;
49752 void *argp1 = 0 ;
49753 int res1 = 0 ;
49754 PyObject * obj0 = 0 ;
49755 PyObject * obj1 = 0 ;
49756 char * kwnames[] = {
49757 (char *) "self",(char *) "_self", NULL
49758 };
49759
49760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49762 if (!SWIG_IsOK(res1)) {
49763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49764 }
49765 arg1 = reinterpret_cast< wxSizer * >(argp1);
49766 arg2 = obj1;
49767 {
49768 PyThreadState* __tstate = wxPyBeginAllowThreads();
49769 wxSizer__setOORInfo(arg1,arg2);
49770 wxPyEndAllowThreads(__tstate);
49771 if (PyErr_Occurred()) SWIG_fail;
49772 }
49773 resultobj = SWIG_Py_Void();
49774 return resultobj;
49775fail:
49776 return NULL;
49777}
49778
49779
49780SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49781 PyObject *resultobj = 0;
49782 wxSizer *arg1 = (wxSizer *) 0 ;
49783 PyObject *arg2 = (PyObject *) 0 ;
49784 int arg3 = (int) 0 ;
49785 int arg4 = (int) 0 ;
49786 int arg5 = (int) 0 ;
49787 PyObject *arg6 = (PyObject *) NULL ;
49788 wxSizerItem *result = 0 ;
49789 void *argp1 = 0 ;
49790 int res1 = 0 ;
49791 int val3 ;
49792 int ecode3 = 0 ;
49793 int val4 ;
49794 int ecode4 = 0 ;
49795 int val5 ;
49796 int ecode5 = 0 ;
49797 PyObject * obj0 = 0 ;
49798 PyObject * obj1 = 0 ;
49799 PyObject * obj2 = 0 ;
49800 PyObject * obj3 = 0 ;
49801 PyObject * obj4 = 0 ;
49802 PyObject * obj5 = 0 ;
49803 char * kwnames[] = {
49804 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49805 };
49806
49807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49809 if (!SWIG_IsOK(res1)) {
49810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49811 }
49812 arg1 = reinterpret_cast< wxSizer * >(argp1);
49813 arg2 = obj1;
49814 if (obj2) {
49815 ecode3 = SWIG_AsVal_int(obj2, &val3);
49816 if (!SWIG_IsOK(ecode3)) {
49817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49818 }
49819 arg3 = static_cast< int >(val3);
49820 }
49821 if (obj3) {
49822 ecode4 = SWIG_AsVal_int(obj3, &val4);
49823 if (!SWIG_IsOK(ecode4)) {
49824 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49825 }
49826 arg4 = static_cast< int >(val4);
49827 }
49828 if (obj4) {
49829 ecode5 = SWIG_AsVal_int(obj4, &val5);
49830 if (!SWIG_IsOK(ecode5)) {
49831 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49832 }
49833 arg5 = static_cast< int >(val5);
49834 }
49835 if (obj5) {
49836 arg6 = obj5;
49837 }
49838 {
49839 PyThreadState* __tstate = wxPyBeginAllowThreads();
49840 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49841 wxPyEndAllowThreads(__tstate);
49842 if (PyErr_Occurred()) SWIG_fail;
49843 }
49844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49845 return resultobj;
49846fail:
49847 return NULL;
49848}
49849
49850
49851SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49852 PyObject *resultobj = 0;
49853 wxSizer *arg1 = (wxSizer *) 0 ;
49854 int arg2 ;
49855 PyObject *arg3 = (PyObject *) 0 ;
49856 int arg4 = (int) 0 ;
49857 int arg5 = (int) 0 ;
49858 int arg6 = (int) 0 ;
49859 PyObject *arg7 = (PyObject *) NULL ;
49860 wxSizerItem *result = 0 ;
49861 void *argp1 = 0 ;
49862 int res1 = 0 ;
49863 int val2 ;
49864 int ecode2 = 0 ;
49865 int val4 ;
49866 int ecode4 = 0 ;
49867 int val5 ;
49868 int ecode5 = 0 ;
49869 int val6 ;
49870 int ecode6 = 0 ;
49871 PyObject * obj0 = 0 ;
49872 PyObject * obj1 = 0 ;
49873 PyObject * obj2 = 0 ;
49874 PyObject * obj3 = 0 ;
49875 PyObject * obj4 = 0 ;
49876 PyObject * obj5 = 0 ;
49877 PyObject * obj6 = 0 ;
49878 char * kwnames[] = {
49879 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49880 };
49881
49882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49884 if (!SWIG_IsOK(res1)) {
49885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49886 }
49887 arg1 = reinterpret_cast< wxSizer * >(argp1);
49888 ecode2 = SWIG_AsVal_int(obj1, &val2);
49889 if (!SWIG_IsOK(ecode2)) {
49890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49891 }
49892 arg2 = static_cast< int >(val2);
49893 arg3 = obj2;
49894 if (obj3) {
49895 ecode4 = SWIG_AsVal_int(obj3, &val4);
49896 if (!SWIG_IsOK(ecode4)) {
49897 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49898 }
49899 arg4 = static_cast< int >(val4);
49900 }
49901 if (obj4) {
49902 ecode5 = SWIG_AsVal_int(obj4, &val5);
49903 if (!SWIG_IsOK(ecode5)) {
49904 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49905 }
49906 arg5 = static_cast< int >(val5);
49907 }
49908 if (obj5) {
49909 ecode6 = SWIG_AsVal_int(obj5, &val6);
49910 if (!SWIG_IsOK(ecode6)) {
49911 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49912 }
49913 arg6 = static_cast< int >(val6);
49914 }
49915 if (obj6) {
49916 arg7 = obj6;
49917 }
49918 {
49919 PyThreadState* __tstate = wxPyBeginAllowThreads();
49920 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49921 wxPyEndAllowThreads(__tstate);
49922 if (PyErr_Occurred()) SWIG_fail;
49923 }
49924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49925 return resultobj;
49926fail:
49927 return NULL;
49928}
49929
49930
49931SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49932 PyObject *resultobj = 0;
49933 wxSizer *arg1 = (wxSizer *) 0 ;
49934 PyObject *arg2 = (PyObject *) 0 ;
49935 int arg3 = (int) 0 ;
49936 int arg4 = (int) 0 ;
49937 int arg5 = (int) 0 ;
49938 PyObject *arg6 = (PyObject *) NULL ;
49939 wxSizerItem *result = 0 ;
49940 void *argp1 = 0 ;
49941 int res1 = 0 ;
49942 int val3 ;
49943 int ecode3 = 0 ;
49944 int val4 ;
49945 int ecode4 = 0 ;
49946 int val5 ;
49947 int ecode5 = 0 ;
49948 PyObject * obj0 = 0 ;
49949 PyObject * obj1 = 0 ;
49950 PyObject * obj2 = 0 ;
49951 PyObject * obj3 = 0 ;
49952 PyObject * obj4 = 0 ;
49953 PyObject * obj5 = 0 ;
49954 char * kwnames[] = {
49955 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49956 };
49957
49958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49960 if (!SWIG_IsOK(res1)) {
49961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
49962 }
49963 arg1 = reinterpret_cast< wxSizer * >(argp1);
49964 arg2 = obj1;
49965 if (obj2) {
49966 ecode3 = SWIG_AsVal_int(obj2, &val3);
49967 if (!SWIG_IsOK(ecode3)) {
49968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
49969 }
49970 arg3 = static_cast< int >(val3);
49971 }
49972 if (obj3) {
49973 ecode4 = SWIG_AsVal_int(obj3, &val4);
49974 if (!SWIG_IsOK(ecode4)) {
49975 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
49976 }
49977 arg4 = static_cast< int >(val4);
49978 }
49979 if (obj4) {
49980 ecode5 = SWIG_AsVal_int(obj4, &val5);
49981 if (!SWIG_IsOK(ecode5)) {
49982 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
49983 }
49984 arg5 = static_cast< int >(val5);
49985 }
49986 if (obj5) {
49987 arg6 = obj5;
49988 }
49989 {
49990 PyThreadState* __tstate = wxPyBeginAllowThreads();
49991 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
49992 wxPyEndAllowThreads(__tstate);
49993 if (PyErr_Occurred()) SWIG_fail;
49994 }
49995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49996 return resultobj;
49997fail:
49998 return NULL;
49999}
50000
50001
50002SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50003 PyObject *resultobj = 0;
50004 wxSizer *arg1 = (wxSizer *) 0 ;
50005 PyObject *arg2 = (PyObject *) 0 ;
50006 bool result;
50007 void *argp1 = 0 ;
50008 int res1 = 0 ;
50009 PyObject * obj0 = 0 ;
50010 PyObject * obj1 = 0 ;
50011 char * kwnames[] = {
50012 (char *) "self",(char *) "item", NULL
50013 };
50014
50015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
50016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50017 if (!SWIG_IsOK(res1)) {
50018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
50019 }
50020 arg1 = reinterpret_cast< wxSizer * >(argp1);
50021 arg2 = obj1;
50022 {
50023 PyThreadState* __tstate = wxPyBeginAllowThreads();
50024 result = (bool)wxSizer_Remove(arg1,arg2);
50025 wxPyEndAllowThreads(__tstate);
50026 if (PyErr_Occurred()) SWIG_fail;
50027 }
50028 {
50029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50030 }
50031 return resultobj;
50032fail:
50033 return NULL;
50034}
50035
50036
50037SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50038 PyObject *resultobj = 0;
50039 wxSizer *arg1 = (wxSizer *) 0 ;
50040 PyObject *arg2 = (PyObject *) 0 ;
50041 bool result;
50042 void *argp1 = 0 ;
50043 int res1 = 0 ;
50044 PyObject * obj0 = 0 ;
50045 PyObject * obj1 = 0 ;
50046 char * kwnames[] = {
50047 (char *) "self",(char *) "item", NULL
50048 };
50049
50050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
50051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50052 if (!SWIG_IsOK(res1)) {
50053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
50054 }
50055 arg1 = reinterpret_cast< wxSizer * >(argp1);
50056 arg2 = obj1;
50057 {
50058 PyThreadState* __tstate = wxPyBeginAllowThreads();
50059 result = (bool)wxSizer_Detach(arg1,arg2);
50060 wxPyEndAllowThreads(__tstate);
50061 if (PyErr_Occurred()) SWIG_fail;
50062 }
50063 {
50064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50065 }
50066 return resultobj;
50067fail:
50068 return NULL;
50069}
50070
50071
50072SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50073 PyObject *resultobj = 0;
50074 wxSizer *arg1 = (wxSizer *) 0 ;
50075 PyObject *arg2 = (PyObject *) 0 ;
50076 wxSizerItem *result = 0 ;
50077 void *argp1 = 0 ;
50078 int res1 = 0 ;
50079 PyObject * obj0 = 0 ;
50080 PyObject * obj1 = 0 ;
50081 char * kwnames[] = {
50082 (char *) "self",(char *) "item", NULL
50083 };
50084
50085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50087 if (!SWIG_IsOK(res1)) {
50088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50089 }
50090 arg1 = reinterpret_cast< wxSizer * >(argp1);
50091 arg2 = obj1;
50092 {
50093 PyThreadState* __tstate = wxPyBeginAllowThreads();
50094 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50095 wxPyEndAllowThreads(__tstate);
50096 if (PyErr_Occurred()) SWIG_fail;
50097 }
50098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50099 return resultobj;
50100fail:
50101 return NULL;
50102}
50103
50104
50105SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50106 PyObject *resultobj = 0;
50107 wxSizer *arg1 = (wxSizer *) 0 ;
50108 PyObject *arg2 = (PyObject *) 0 ;
50109 wxSize *arg3 = 0 ;
50110 void *argp1 = 0 ;
50111 int res1 = 0 ;
50112 wxSize temp3 ;
50113 PyObject * obj0 = 0 ;
50114 PyObject * obj1 = 0 ;
50115 PyObject * obj2 = 0 ;
50116 char * kwnames[] = {
50117 (char *) "self",(char *) "item",(char *) "size", NULL
50118 };
50119
50120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50122 if (!SWIG_IsOK(res1)) {
50123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50124 }
50125 arg1 = reinterpret_cast< wxSizer * >(argp1);
50126 arg2 = obj1;
50127 {
50128 arg3 = &temp3;
50129 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50130 }
50131 {
50132 PyThreadState* __tstate = wxPyBeginAllowThreads();
50133 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50134 wxPyEndAllowThreads(__tstate);
50135 if (PyErr_Occurred()) SWIG_fail;
50136 }
50137 resultobj = SWIG_Py_Void();
50138 return resultobj;
50139fail:
50140 return NULL;
50141}
50142
50143
ac5d357a
RD
50144SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50145 PyObject *resultobj = 0;
50146 wxSizer *arg1 = (wxSizer *) 0 ;
50147 wxWindow *arg2 = (wxWindow *) 0 ;
50148 wxWindow *arg3 = (wxWindow *) 0 ;
50149 bool arg4 = (bool) false ;
50150 bool result;
50151 void *argp1 = 0 ;
50152 int res1 = 0 ;
50153 void *argp2 = 0 ;
50154 int res2 = 0 ;
50155 void *argp3 = 0 ;
50156 int res3 = 0 ;
50157 bool val4 ;
50158 int ecode4 = 0 ;
50159 PyObject * obj0 = 0 ;
50160 PyObject * obj1 = 0 ;
50161 PyObject * obj2 = 0 ;
50162 PyObject * obj3 = 0 ;
50163 char * kwnames[] = {
50164 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50165 };
50166
50167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50169 if (!SWIG_IsOK(res1)) {
50170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50171 }
50172 arg1 = reinterpret_cast< wxSizer * >(argp1);
50173 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50174 if (!SWIG_IsOK(res2)) {
50175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50176 }
50177 arg2 = reinterpret_cast< wxWindow * >(argp2);
50178 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50179 if (!SWIG_IsOK(res3)) {
50180 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50181 }
50182 arg3 = reinterpret_cast< wxWindow * >(argp3);
50183 if (obj3) {
50184 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50185 if (!SWIG_IsOK(ecode4)) {
50186 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50187 }
50188 arg4 = static_cast< bool >(val4);
50189 }
50190 {
50191 PyThreadState* __tstate = wxPyBeginAllowThreads();
50192 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50193 wxPyEndAllowThreads(__tstate);
50194 if (PyErr_Occurred()) SWIG_fail;
50195 }
50196 {
50197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50198 }
50199 return resultobj;
50200fail:
50201 return NULL;
50202}
50203
50204
50205SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50206 PyObject *resultobj = 0;
50207 wxSizer *arg1 = (wxSizer *) 0 ;
50208 wxSizer *arg2 = (wxSizer *) 0 ;
50209 wxSizer *arg3 = (wxSizer *) 0 ;
50210 bool arg4 = (bool) false ;
50211 bool result;
50212 void *argp1 = 0 ;
50213 int res1 = 0 ;
50214 void *argp2 = 0 ;
50215 int res2 = 0 ;
50216 void *argp3 = 0 ;
50217 int res3 = 0 ;
50218 bool val4 ;
50219 int ecode4 = 0 ;
50220 PyObject * obj0 = 0 ;
50221 PyObject * obj1 = 0 ;
50222 PyObject * obj2 = 0 ;
50223 PyObject * obj3 = 0 ;
50224 char * kwnames[] = {
50225 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50226 };
50227
50228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50230 if (!SWIG_IsOK(res1)) {
50231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50232 }
50233 arg1 = reinterpret_cast< wxSizer * >(argp1);
50234 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50235 if (!SWIG_IsOK(res2)) {
50236 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50237 }
50238 arg2 = reinterpret_cast< wxSizer * >(argp2);
50239 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50240 if (!SWIG_IsOK(res3)) {
50241 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50242 }
50243 arg3 = reinterpret_cast< wxSizer * >(argp3);
50244 if (obj3) {
50245 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50246 if (!SWIG_IsOK(ecode4)) {
50247 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50248 }
50249 arg4 = static_cast< bool >(val4);
50250 }
50251 {
50252 PyThreadState* __tstate = wxPyBeginAllowThreads();
50253 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50254 wxPyEndAllowThreads(__tstate);
50255 if (PyErr_Occurred()) SWIG_fail;
50256 }
50257 {
50258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50259 }
50260 return resultobj;
50261fail:
50262 return NULL;
50263}
50264
50265
50266SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50267 PyObject *resultobj = 0;
50268 wxSizer *arg1 = (wxSizer *) 0 ;
50269 size_t arg2 ;
50270 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50271 bool result;
50272 void *argp1 = 0 ;
50273 int res1 = 0 ;
50274 size_t val2 ;
50275 int ecode2 = 0 ;
50276 void *argp3 = 0 ;
50277 int res3 = 0 ;
50278 PyObject * obj0 = 0 ;
50279 PyObject * obj1 = 0 ;
50280 PyObject * obj2 = 0 ;
50281 char * kwnames[] = {
50282 (char *) "self",(char *) "index",(char *) "newitem", NULL
50283 };
50284
50285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50287 if (!SWIG_IsOK(res1)) {
50288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50289 }
50290 arg1 = reinterpret_cast< wxSizer * >(argp1);
50291 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50292 if (!SWIG_IsOK(ecode2)) {
50293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50294 }
50295 arg2 = static_cast< size_t >(val2);
50296 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50297 if (!SWIG_IsOK(res3)) {
50298 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50299 }
50300 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50301 {
50302 PyThreadState* __tstate = wxPyBeginAllowThreads();
50303 result = (bool)(arg1)->Replace(arg2,arg3);
50304 wxPyEndAllowThreads(__tstate);
50305 if (PyErr_Occurred()) SWIG_fail;
50306 }
50307 {
50308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50309 }
50310 return resultobj;
50311fail:
50312 return NULL;
50313}
50314
50315
50316SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50317 PyObject *resultobj = 0;
50318 wxSizer *arg1 = (wxSizer *) 0 ;
50319 wxWindow *arg2 = (wxWindow *) 0 ;
50320 void *argp1 = 0 ;
50321 int res1 = 0 ;
50322 void *argp2 = 0 ;
50323 int res2 = 0 ;
50324 PyObject * obj0 = 0 ;
50325 PyObject * obj1 = 0 ;
50326 char * kwnames[] = {
50327 (char *) "self",(char *) "window", NULL
50328 };
50329
50330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50332 if (!SWIG_IsOK(res1)) {
50333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50334 }
50335 arg1 = reinterpret_cast< wxSizer * >(argp1);
50336 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50337 if (!SWIG_IsOK(res2)) {
50338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50339 }
50340 arg2 = reinterpret_cast< wxWindow * >(argp2);
50341 {
50342 PyThreadState* __tstate = wxPyBeginAllowThreads();
50343 (arg1)->SetContainingWindow(arg2);
50344 wxPyEndAllowThreads(__tstate);
50345 if (PyErr_Occurred()) SWIG_fail;
50346 }
50347 resultobj = SWIG_Py_Void();
50348 return resultobj;
50349fail:
50350 return NULL;
50351}
50352
50353
50354SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50355 PyObject *resultobj = 0;
50356 wxSizer *arg1 = (wxSizer *) 0 ;
50357 wxWindow *result = 0 ;
50358 void *argp1 = 0 ;
50359 int res1 = 0 ;
50360 PyObject *swig_obj[1] ;
50361
50362 if (!args) SWIG_fail;
50363 swig_obj[0] = args;
50364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50365 if (!SWIG_IsOK(res1)) {
50366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50367 }
50368 arg1 = reinterpret_cast< wxSizer * >(argp1);
50369 {
50370 PyThreadState* __tstate = wxPyBeginAllowThreads();
50371 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50372 wxPyEndAllowThreads(__tstate);
50373 if (PyErr_Occurred()) SWIG_fail;
50374 }
50375 {
50376 resultobj = wxPyMake_wxObject(result, 0);
50377 }
50378 return resultobj;
50379fail:
50380 return NULL;
50381}
50382
50383
1bd55598
RD
50384SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50385 PyObject *resultobj = 0;
50386 wxSizer *arg1 = (wxSizer *) 0 ;
50387 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50388 wxSizerItem *result = 0 ;
50389 void *argp1 = 0 ;
50390 int res1 = 0 ;
50391 int res2 = 0 ;
50392 PyObject * obj0 = 0 ;
50393 PyObject * obj1 = 0 ;
50394 char * kwnames[] = {
50395 (char *) "self",(char *) "item", NULL
50396 };
50397
50398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50400 if (!SWIG_IsOK(res1)) {
50401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50402 }
50403 arg1 = reinterpret_cast< wxSizer * >(argp1);
50404 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50405 if (!SWIG_IsOK(res2)) {
50406 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50407 }
50408 {
50409 PyThreadState* __tstate = wxPyBeginAllowThreads();
50410 result = (wxSizerItem *)(arg1)->Add(arg2);
50411 wxPyEndAllowThreads(__tstate);
50412 if (PyErr_Occurred()) SWIG_fail;
50413 }
50414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50415 return resultobj;
50416fail:
50417 return NULL;
50418}
50419
50420
50421SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50422 PyObject *resultobj = 0;
50423 wxSizer *arg1 = (wxSizer *) 0 ;
50424 size_t arg2 ;
50425 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50426 wxSizerItem *result = 0 ;
50427 void *argp1 = 0 ;
50428 int res1 = 0 ;
50429 size_t val2 ;
50430 int ecode2 = 0 ;
50431 int res3 = 0 ;
50432 PyObject * obj0 = 0 ;
50433 PyObject * obj1 = 0 ;
50434 PyObject * obj2 = 0 ;
50435 char * kwnames[] = {
50436 (char *) "self",(char *) "index",(char *) "item", NULL
50437 };
50438
50439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50441 if (!SWIG_IsOK(res1)) {
50442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50443 }
50444 arg1 = reinterpret_cast< wxSizer * >(argp1);
50445 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50446 if (!SWIG_IsOK(ecode2)) {
50447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50448 }
50449 arg2 = static_cast< size_t >(val2);
50450 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50451 if (!SWIG_IsOK(res3)) {
50452 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50453 }
50454 {
50455 PyThreadState* __tstate = wxPyBeginAllowThreads();
50456 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50457 wxPyEndAllowThreads(__tstate);
50458 if (PyErr_Occurred()) SWIG_fail;
50459 }
50460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50461 return resultobj;
50462fail:
50463 return NULL;
50464}
50465
50466
50467SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50468 PyObject *resultobj = 0;
50469 wxSizer *arg1 = (wxSizer *) 0 ;
50470 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50471 wxSizerItem *result = 0 ;
50472 void *argp1 = 0 ;
50473 int res1 = 0 ;
50474 int res2 = 0 ;
50475 PyObject * obj0 = 0 ;
50476 PyObject * obj1 = 0 ;
50477 char * kwnames[] = {
50478 (char *) "self",(char *) "item", NULL
50479 };
50480
50481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50483 if (!SWIG_IsOK(res1)) {
50484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50485 }
50486 arg1 = reinterpret_cast< wxSizer * >(argp1);
50487 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50488 if (!SWIG_IsOK(res2)) {
50489 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50490 }
50491 {
50492 PyThreadState* __tstate = wxPyBeginAllowThreads();
50493 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50494 wxPyEndAllowThreads(__tstate);
50495 if (PyErr_Occurred()) SWIG_fail;
50496 }
50497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50498 return resultobj;
50499fail:
50500 return NULL;
50501}
50502
50503
50504SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50505 PyObject *resultobj = 0;
50506 wxSizer *arg1 = (wxSizer *) 0 ;
50507 int arg2 ;
50508 int arg3 ;
50509 int arg4 ;
50510 int arg5 ;
50511 void *argp1 = 0 ;
50512 int res1 = 0 ;
50513 int val2 ;
50514 int ecode2 = 0 ;
50515 int val3 ;
50516 int ecode3 = 0 ;
50517 int val4 ;
50518 int ecode4 = 0 ;
50519 int val5 ;
50520 int ecode5 = 0 ;
50521 PyObject * obj0 = 0 ;
50522 PyObject * obj1 = 0 ;
50523 PyObject * obj2 = 0 ;
50524 PyObject * obj3 = 0 ;
50525 PyObject * obj4 = 0 ;
50526 char * kwnames[] = {
50527 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50528 };
50529
50530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50532 if (!SWIG_IsOK(res1)) {
50533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50534 }
50535 arg1 = reinterpret_cast< wxSizer * >(argp1);
50536 ecode2 = SWIG_AsVal_int(obj1, &val2);
50537 if (!SWIG_IsOK(ecode2)) {
50538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50539 }
50540 arg2 = static_cast< int >(val2);
50541 ecode3 = SWIG_AsVal_int(obj2, &val3);
50542 if (!SWIG_IsOK(ecode3)) {
50543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50544 }
50545 arg3 = static_cast< int >(val3);
50546 ecode4 = SWIG_AsVal_int(obj3, &val4);
50547 if (!SWIG_IsOK(ecode4)) {
50548 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50549 }
50550 arg4 = static_cast< int >(val4);
50551 ecode5 = SWIG_AsVal_int(obj4, &val5);
50552 if (!SWIG_IsOK(ecode5)) {
50553 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50554 }
50555 arg5 = static_cast< int >(val5);
50556 {
50557 PyThreadState* __tstate = wxPyBeginAllowThreads();
50558 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50559 wxPyEndAllowThreads(__tstate);
50560 if (PyErr_Occurred()) SWIG_fail;
50561 }
50562 resultobj = SWIG_Py_Void();
50563 return resultobj;
50564fail:
50565 return NULL;
50566}
50567
50568
50569SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50570 PyObject *resultobj = 0;
50571 wxSizer *arg1 = (wxSizer *) 0 ;
50572 wxSize *arg2 = 0 ;
50573 void *argp1 = 0 ;
50574 int res1 = 0 ;
50575 wxSize temp2 ;
50576 PyObject * obj0 = 0 ;
50577 PyObject * obj1 = 0 ;
50578 char * kwnames[] = {
50579 (char *) "self",(char *) "size", NULL
50580 };
50581
50582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50584 if (!SWIG_IsOK(res1)) {
50585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50586 }
50587 arg1 = reinterpret_cast< wxSizer * >(argp1);
50588 {
50589 arg2 = &temp2;
50590 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50591 }
50592 {
50593 PyThreadState* __tstate = wxPyBeginAllowThreads();
50594 (arg1)->SetMinSize((wxSize const &)*arg2);
50595 wxPyEndAllowThreads(__tstate);
50596 if (PyErr_Occurred()) SWIG_fail;
50597 }
50598 resultobj = SWIG_Py_Void();
50599 return resultobj;
50600fail:
50601 return NULL;
d55e5bfc
RD
50602}
50603
50604
1bd55598
RD
50605SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50606 PyObject *resultobj = 0;
50607 wxSizer *arg1 = (wxSizer *) 0 ;
50608 wxSize result;
50609 void *argp1 = 0 ;
50610 int res1 = 0 ;
50611 PyObject *swig_obj[1] ;
50612
50613 if (!args) SWIG_fail;
50614 swig_obj[0] = args;
50615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50616 if (!SWIG_IsOK(res1)) {
50617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50618 }
50619 arg1 = reinterpret_cast< wxSizer * >(argp1);
50620 {
50621 PyThreadState* __tstate = wxPyBeginAllowThreads();
50622 result = (arg1)->GetSize();
50623 wxPyEndAllowThreads(__tstate);
50624 if (PyErr_Occurred()) SWIG_fail;
50625 }
50626 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50627 return resultobj;
50628fail:
50629 return NULL;
d55e5bfc
RD
50630}
50631
50632
1bd55598
RD
50633SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50634 PyObject *resultobj = 0;
50635 wxSizer *arg1 = (wxSizer *) 0 ;
50636 wxPoint result;
50637 void *argp1 = 0 ;
50638 int res1 = 0 ;
50639 PyObject *swig_obj[1] ;
50640
50641 if (!args) SWIG_fail;
50642 swig_obj[0] = args;
50643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50644 if (!SWIG_IsOK(res1)) {
50645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50646 }
50647 arg1 = reinterpret_cast< wxSizer * >(argp1);
50648 {
50649 PyThreadState* __tstate = wxPyBeginAllowThreads();
50650 result = (arg1)->GetPosition();
50651 wxPyEndAllowThreads(__tstate);
50652 if (PyErr_Occurred()) SWIG_fail;
50653 }
50654 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50655 return resultobj;
50656fail:
50657 return NULL;
d55e5bfc
RD
50658}
50659
50660
1bd55598
RD
50661SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50662 PyObject *resultobj = 0;
50663 wxSizer *arg1 = (wxSizer *) 0 ;
50664 wxSize result;
50665 void *argp1 = 0 ;
50666 int res1 = 0 ;
50667 PyObject *swig_obj[1] ;
50668
50669 if (!args) SWIG_fail;
50670 swig_obj[0] = args;
50671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50672 if (!SWIG_IsOK(res1)) {
50673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50674 }
50675 arg1 = reinterpret_cast< wxSizer * >(argp1);
50676 {
50677 PyThreadState* __tstate = wxPyBeginAllowThreads();
50678 result = (arg1)->GetMinSize();
50679 wxPyEndAllowThreads(__tstate);
50680 if (PyErr_Occurred()) SWIG_fail;
50681 }
50682 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50683 return resultobj;
50684fail:
50685 return NULL;
d55e5bfc
RD
50686}
50687
50688
1bd55598
RD
50689SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50690 PyObject *resultobj = 0;
50691 wxSizer *arg1 = (wxSizer *) 0 ;
50692 void *argp1 = 0 ;
50693 int res1 = 0 ;
50694 PyObject *swig_obj[1] ;
50695
50696 if (!args) SWIG_fail;
50697 swig_obj[0] = args;
50698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50699 if (!SWIG_IsOK(res1)) {
50700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50701 }
50702 arg1 = reinterpret_cast< wxSizer * >(argp1);
50703 {
50704 PyThreadState* __tstate = wxPyBeginAllowThreads();
50705 (arg1)->RecalcSizes();
50706 wxPyEndAllowThreads(__tstate);
50707 if (PyErr_Occurred()) SWIG_fail;
50708 }
50709 resultobj = SWIG_Py_Void();
50710 return resultobj;
50711fail:
50712 return NULL;
a001823c
RD
50713}
50714
50715
1bd55598
RD
50716SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50717 PyObject *resultobj = 0;
50718 wxSizer *arg1 = (wxSizer *) 0 ;
50719 wxSize result;
50720 void *argp1 = 0 ;
50721 int res1 = 0 ;
50722 PyObject *swig_obj[1] ;
50723
50724 if (!args) SWIG_fail;
50725 swig_obj[0] = args;
50726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50727 if (!SWIG_IsOK(res1)) {
50728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50729 }
50730 arg1 = reinterpret_cast< wxSizer * >(argp1);
50731 {
50732 PyThreadState* __tstate = wxPyBeginAllowThreads();
50733 result = (arg1)->CalcMin();
50734 wxPyEndAllowThreads(__tstate);
50735 if (PyErr_Occurred()) SWIG_fail;
50736 }
50737 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50738 return resultobj;
50739fail:
50740 return NULL;
e2813725
RD
50741}
50742
50743
1bd55598
RD
50744SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50745 PyObject *resultobj = 0;
50746 wxSizer *arg1 = (wxSizer *) 0 ;
50747 void *argp1 = 0 ;
50748 int res1 = 0 ;
50749 PyObject *swig_obj[1] ;
50750
50751 if (!args) SWIG_fail;
50752 swig_obj[0] = args;
50753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50754 if (!SWIG_IsOK(res1)) {
50755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50756 }
50757 arg1 = reinterpret_cast< wxSizer * >(argp1);
50758 {
50759 PyThreadState* __tstate = wxPyBeginAllowThreads();
50760 (arg1)->Layout();
50761 wxPyEndAllowThreads(__tstate);
50762 if (PyErr_Occurred()) SWIG_fail;
50763 }
50764 resultobj = SWIG_Py_Void();
50765 return resultobj;
50766fail:
50767 return NULL;
50768}
50769
50770
50771SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50772 PyObject *resultobj = 0;
50773 wxSizer *arg1 = (wxSizer *) 0 ;
50774 wxWindow *arg2 = (wxWindow *) 0 ;
50775 wxSize result;
50776 void *argp1 = 0 ;
50777 int res1 = 0 ;
50778 void *argp2 = 0 ;
50779 int res2 = 0 ;
50780 PyObject * obj0 = 0 ;
50781 PyObject * obj1 = 0 ;
50782 char * kwnames[] = {
50783 (char *) "self",(char *) "window", NULL
50784 };
50785
50786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50788 if (!SWIG_IsOK(res1)) {
50789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50790 }
50791 arg1 = reinterpret_cast< wxSizer * >(argp1);
50792 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50793 if (!SWIG_IsOK(res2)) {
50794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50795 }
50796 arg2 = reinterpret_cast< wxWindow * >(argp2);
50797 {
50798 PyThreadState* __tstate = wxPyBeginAllowThreads();
50799 result = (arg1)->Fit(arg2);
50800 wxPyEndAllowThreads(__tstate);
50801 if (PyErr_Occurred()) SWIG_fail;
50802 }
50803 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50804 return resultobj;
50805fail:
50806 return NULL;
50807}
50808
50809
50810SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50811 PyObject *resultobj = 0;
50812 wxSizer *arg1 = (wxSizer *) 0 ;
50813 wxWindow *arg2 = (wxWindow *) 0 ;
50814 void *argp1 = 0 ;
50815 int res1 = 0 ;
50816 void *argp2 = 0 ;
50817 int res2 = 0 ;
50818 PyObject * obj0 = 0 ;
50819 PyObject * obj1 = 0 ;
50820 char * kwnames[] = {
50821 (char *) "self",(char *) "window", NULL
50822 };
50823
50824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50826 if (!SWIG_IsOK(res1)) {
50827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50828 }
50829 arg1 = reinterpret_cast< wxSizer * >(argp1);
50830 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50831 if (!SWIG_IsOK(res2)) {
50832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50833 }
50834 arg2 = reinterpret_cast< wxWindow * >(argp2);
50835 {
50836 PyThreadState* __tstate = wxPyBeginAllowThreads();
50837 (arg1)->FitInside(arg2);
50838 wxPyEndAllowThreads(__tstate);
50839 if (PyErr_Occurred()) SWIG_fail;
50840 }
50841 resultobj = SWIG_Py_Void();
50842 return resultobj;
50843fail:
50844 return NULL;
50845}
50846
50847
50848SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50849 PyObject *resultobj = 0;
50850 wxSizer *arg1 = (wxSizer *) 0 ;
50851 wxWindow *arg2 = (wxWindow *) 0 ;
50852 void *argp1 = 0 ;
50853 int res1 = 0 ;
50854 void *argp2 = 0 ;
50855 int res2 = 0 ;
50856 PyObject * obj0 = 0 ;
50857 PyObject * obj1 = 0 ;
50858 char * kwnames[] = {
50859 (char *) "self",(char *) "window", NULL
50860 };
50861
50862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50864 if (!SWIG_IsOK(res1)) {
50865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50866 }
50867 arg1 = reinterpret_cast< wxSizer * >(argp1);
50868 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50869 if (!SWIG_IsOK(res2)) {
50870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50871 }
50872 arg2 = reinterpret_cast< wxWindow * >(argp2);
50873 {
50874 PyThreadState* __tstate = wxPyBeginAllowThreads();
50875 (arg1)->SetSizeHints(arg2);
50876 wxPyEndAllowThreads(__tstate);
50877 if (PyErr_Occurred()) SWIG_fail;
50878 }
50879 resultobj = SWIG_Py_Void();
50880 return resultobj;
50881fail:
50882 return NULL;
50883}
50884
50885
50886SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50887 PyObject *resultobj = 0;
50888 wxSizer *arg1 = (wxSizer *) 0 ;
50889 wxWindow *arg2 = (wxWindow *) 0 ;
50890 void *argp1 = 0 ;
50891 int res1 = 0 ;
50892 void *argp2 = 0 ;
50893 int res2 = 0 ;
50894 PyObject * obj0 = 0 ;
50895 PyObject * obj1 = 0 ;
50896 char * kwnames[] = {
50897 (char *) "self",(char *) "window", NULL
50898 };
50899
50900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50902 if (!SWIG_IsOK(res1)) {
50903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50904 }
50905 arg1 = reinterpret_cast< wxSizer * >(argp1);
50906 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50907 if (!SWIG_IsOK(res2)) {
50908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50909 }
50910 arg2 = reinterpret_cast< wxWindow * >(argp2);
50911 {
50912 PyThreadState* __tstate = wxPyBeginAllowThreads();
50913 (arg1)->SetVirtualSizeHints(arg2);
50914 wxPyEndAllowThreads(__tstate);
50915 if (PyErr_Occurred()) SWIG_fail;
50916 }
50917 resultobj = SWIG_Py_Void();
50918 return resultobj;
50919fail:
50920 return NULL;
50921}
50922
50923
50924SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50925 PyObject *resultobj = 0;
50926 wxSizer *arg1 = (wxSizer *) 0 ;
50927 bool arg2 = (bool) false ;
50928 void *argp1 = 0 ;
50929 int res1 = 0 ;
50930 bool val2 ;
50931 int ecode2 = 0 ;
50932 PyObject * obj0 = 0 ;
50933 PyObject * obj1 = 0 ;
50934 char * kwnames[] = {
50935 (char *) "self",(char *) "deleteWindows", NULL
50936 };
50937
50938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50940 if (!SWIG_IsOK(res1)) {
50941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50942 }
50943 arg1 = reinterpret_cast< wxSizer * >(argp1);
50944 if (obj1) {
50945 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50946 if (!SWIG_IsOK(ecode2)) {
50947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50948 }
50949 arg2 = static_cast< bool >(val2);
50950 }
50951 {
50952 PyThreadState* __tstate = wxPyBeginAllowThreads();
50953 (arg1)->Clear(arg2);
50954 wxPyEndAllowThreads(__tstate);
50955 if (PyErr_Occurred()) SWIG_fail;
50956 }
50957 resultobj = SWIG_Py_Void();
50958 return resultobj;
50959fail:
50960 return NULL;
a001823c
RD
50961}
50962
50963
1bd55598
RD
50964SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50965 PyObject *resultobj = 0;
50966 wxSizer *arg1 = (wxSizer *) 0 ;
50967 void *argp1 = 0 ;
50968 int res1 = 0 ;
50969 PyObject *swig_obj[1] ;
50970
50971 if (!args) SWIG_fail;
50972 swig_obj[0] = args;
50973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50974 if (!SWIG_IsOK(res1)) {
50975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
50976 }
50977 arg1 = reinterpret_cast< wxSizer * >(argp1);
50978 {
50979 PyThreadState* __tstate = wxPyBeginAllowThreads();
50980 (arg1)->DeleteWindows();
50981 wxPyEndAllowThreads(__tstate);
50982 if (PyErr_Occurred()) SWIG_fail;
50983 }
50984 resultobj = SWIG_Py_Void();
50985 return resultobj;
50986fail:
50987 return NULL;
d55e5bfc
RD
50988}
50989
50990
1bd55598
RD
50991SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50992 PyObject *resultobj = 0;
50993 wxSizer *arg1 = (wxSizer *) 0 ;
50994 PyObject *result = 0 ;
50995 void *argp1 = 0 ;
50996 int res1 = 0 ;
50997 PyObject *swig_obj[1] ;
50998
50999 if (!args) SWIG_fail;
51000 swig_obj[0] = args;
51001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51002 if (!SWIG_IsOK(res1)) {
51003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
51004 }
51005 arg1 = reinterpret_cast< wxSizer * >(argp1);
51006 {
51007 PyThreadState* __tstate = wxPyBeginAllowThreads();
51008 result = (PyObject *)wxSizer_GetChildren(arg1);
51009 wxPyEndAllowThreads(__tstate);
51010 if (PyErr_Occurred()) SWIG_fail;
51011 }
51012 resultobj = result;
51013 return resultobj;
51014fail:
51015 return NULL;
51016}
51017
51018
51019SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51020 PyObject *resultobj = 0;
51021 wxSizer *arg1 = (wxSizer *) 0 ;
51022 PyObject *arg2 = (PyObject *) 0 ;
51023 bool arg3 = (bool) true ;
51024 bool arg4 = (bool) false ;
51025 bool result;
51026 void *argp1 = 0 ;
51027 int res1 = 0 ;
51028 bool val3 ;
51029 int ecode3 = 0 ;
51030 bool val4 ;
51031 int ecode4 = 0 ;
51032 PyObject * obj0 = 0 ;
51033 PyObject * obj1 = 0 ;
51034 PyObject * obj2 = 0 ;
51035 PyObject * obj3 = 0 ;
51036 char * kwnames[] = {
51037 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
51038 };
51039
51040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51042 if (!SWIG_IsOK(res1)) {
51043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
51044 }
51045 arg1 = reinterpret_cast< wxSizer * >(argp1);
51046 arg2 = obj1;
51047 if (obj2) {
51048 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51049 if (!SWIG_IsOK(ecode3)) {
51050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
51051 }
51052 arg3 = static_cast< bool >(val3);
51053 }
51054 if (obj3) {
51055 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51056 if (!SWIG_IsOK(ecode4)) {
51057 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
51058 }
51059 arg4 = static_cast< bool >(val4);
51060 }
51061 {
51062 PyThreadState* __tstate = wxPyBeginAllowThreads();
51063 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
51064 wxPyEndAllowThreads(__tstate);
51065 if (PyErr_Occurred()) SWIG_fail;
51066 }
51067 {
51068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51069 }
51070 return resultobj;
51071fail:
51072 return NULL;
51073}
51074
51075
51076SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51077 PyObject *resultobj = 0;
51078 wxSizer *arg1 = (wxSizer *) 0 ;
51079 PyObject *arg2 = (PyObject *) 0 ;
51080 bool result;
51081 void *argp1 = 0 ;
51082 int res1 = 0 ;
51083 PyObject * obj0 = 0 ;
51084 PyObject * obj1 = 0 ;
51085 char * kwnames[] = {
51086 (char *) "self",(char *) "item", NULL
51087 };
51088
51089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51091 if (!SWIG_IsOK(res1)) {
51092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51093 }
51094 arg1 = reinterpret_cast< wxSizer * >(argp1);
51095 arg2 = obj1;
51096 {
51097 PyThreadState* __tstate = wxPyBeginAllowThreads();
51098 result = (bool)wxSizer_IsShown(arg1,arg2);
51099 wxPyEndAllowThreads(__tstate);
51100 if (PyErr_Occurred()) SWIG_fail;
51101 }
51102 {
51103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51104 }
51105 return resultobj;
51106fail:
51107 return NULL;
51108}
51109
51110
51111SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51112 PyObject *resultobj = 0;
51113 wxSizer *arg1 = (wxSizer *) 0 ;
51114 bool arg2 ;
51115 void *argp1 = 0 ;
51116 int res1 = 0 ;
51117 bool val2 ;
51118 int ecode2 = 0 ;
51119 PyObject * obj0 = 0 ;
51120 PyObject * obj1 = 0 ;
51121 char * kwnames[] = {
51122 (char *) "self",(char *) "show", NULL
51123 };
51124
51125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51127 if (!SWIG_IsOK(res1)) {
51128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51129 }
51130 arg1 = reinterpret_cast< wxSizer * >(argp1);
51131 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51132 if (!SWIG_IsOK(ecode2)) {
51133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51134 }
51135 arg2 = static_cast< bool >(val2);
51136 {
51137 PyThreadState* __tstate = wxPyBeginAllowThreads();
51138 (arg1)->ShowItems(arg2);
51139 wxPyEndAllowThreads(__tstate);
51140 if (PyErr_Occurred()) SWIG_fail;
51141 }
51142 resultobj = SWIG_Py_Void();
51143 return resultobj;
51144fail:
51145 return NULL;
d55e5bfc
RD
51146}
51147
51148
1bd55598
RD
51149SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51150 PyObject *obj;
51151 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51152 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51153 return SWIG_Py_Void();
d55e5bfc
RD
51154}
51155
1bd55598
RD
51156SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51157 PyObject *resultobj = 0;
51158 wxPySizer *result = 0 ;
51159
51160 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51161 {
51162 PyThreadState* __tstate = wxPyBeginAllowThreads();
51163 result = (wxPySizer *)new wxPySizer();
51164 wxPyEndAllowThreads(__tstate);
51165 if (PyErr_Occurred()) SWIG_fail;
51166 }
51167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51168 return resultobj;
51169fail:
51170 return NULL;
51171}
51172
51173
51174SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51175 PyObject *resultobj = 0;
51176 wxPySizer *arg1 = (wxPySizer *) 0 ;
51177 PyObject *arg2 = (PyObject *) 0 ;
51178 PyObject *arg3 = (PyObject *) 0 ;
51179 void *argp1 = 0 ;
51180 int res1 = 0 ;
51181 PyObject * obj0 = 0 ;
51182 PyObject * obj1 = 0 ;
51183 PyObject * obj2 = 0 ;
51184 char * kwnames[] = {
51185 (char *) "self",(char *) "self",(char *) "_class", NULL
51186 };
51187
51188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51190 if (!SWIG_IsOK(res1)) {
51191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51192 }
51193 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51194 arg2 = obj1;
51195 arg3 = obj2;
51196 {
51197 PyThreadState* __tstate = wxPyBeginAllowThreads();
51198 (arg1)->_setCallbackInfo(arg2,arg3);
51199 wxPyEndAllowThreads(__tstate);
51200 if (PyErr_Occurred()) SWIG_fail;
51201 }
51202 resultobj = SWIG_Py_Void();
51203 return resultobj;
51204fail:
51205 return NULL;
51206}
d55e5bfc 51207
1bd55598
RD
51208
51209SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51210 PyObject *obj;
51211 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51212 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51213 return SWIG_Py_Void();
d55e5bfc
RD
51214}
51215
1bd55598
RD
51216SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51217 return SWIG_Python_InitShadowInstance(args);
51218}
d55e5bfc 51219
1bd55598
RD
51220SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51221 PyObject *resultobj = 0;
51222 int arg1 = (int) wxHORIZONTAL ;
51223 wxBoxSizer *result = 0 ;
51224 int val1 ;
51225 int ecode1 = 0 ;
51226 PyObject * obj0 = 0 ;
51227 char * kwnames[] = {
51228 (char *) "orient", NULL
51229 };
51230
51231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51232 if (obj0) {
51233 ecode1 = SWIG_AsVal_int(obj0, &val1);
51234 if (!SWIG_IsOK(ecode1)) {
51235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51236 }
51237 arg1 = static_cast< int >(val1);
51238 }
51239 {
51240 PyThreadState* __tstate = wxPyBeginAllowThreads();
51241 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51242 wxPyEndAllowThreads(__tstate);
51243 if (PyErr_Occurred()) SWIG_fail;
51244 }
51245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51246 return resultobj;
51247fail:
51248 return NULL;
d55e5bfc
RD
51249}
51250
51251
1bd55598
RD
51252SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51253 PyObject *resultobj = 0;
51254 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51255 int result;
51256 void *argp1 = 0 ;
51257 int res1 = 0 ;
51258 PyObject *swig_obj[1] ;
51259
51260 if (!args) SWIG_fail;
51261 swig_obj[0] = args;
51262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51263 if (!SWIG_IsOK(res1)) {
51264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51265 }
51266 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51267 {
51268 PyThreadState* __tstate = wxPyBeginAllowThreads();
51269 result = (int)(arg1)->GetOrientation();
51270 wxPyEndAllowThreads(__tstate);
51271 if (PyErr_Occurred()) SWIG_fail;
51272 }
51273 resultobj = SWIG_From_int(static_cast< int >(result));
51274 return resultobj;
51275fail:
51276 return NULL;
51277}
51278
51279
51280SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51281 PyObject *resultobj = 0;
51282 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51283 int arg2 ;
51284 void *argp1 = 0 ;
51285 int res1 = 0 ;
51286 int val2 ;
51287 int ecode2 = 0 ;
51288 PyObject * obj0 = 0 ;
51289 PyObject * obj1 = 0 ;
51290 char * kwnames[] = {
51291 (char *) "self",(char *) "orient", NULL
51292 };
51293
51294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51296 if (!SWIG_IsOK(res1)) {
51297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51298 }
51299 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51300 ecode2 = SWIG_AsVal_int(obj1, &val2);
51301 if (!SWIG_IsOK(ecode2)) {
51302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51303 }
51304 arg2 = static_cast< int >(val2);
51305 {
51306 PyThreadState* __tstate = wxPyBeginAllowThreads();
51307 (arg1)->SetOrientation(arg2);
51308 wxPyEndAllowThreads(__tstate);
51309 if (PyErr_Occurred()) SWIG_fail;
51310 }
51311 resultobj = SWIG_Py_Void();
51312 return resultobj;
51313fail:
51314 return NULL;
d55e5bfc
RD
51315}
51316
51317
1bd55598
RD
51318SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51319 PyObject *obj;
51320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51321 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51322 return SWIG_Py_Void();
d55e5bfc
RD
51323}
51324
1bd55598
RD
51325SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51326 return SWIG_Python_InitShadowInstance(args);
51327}
d55e5bfc 51328
1bd55598
RD
51329SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51330 PyObject *resultobj = 0;
51331 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51332 int arg2 = (int) wxHORIZONTAL ;
51333 wxStaticBoxSizer *result = 0 ;
51334 void *argp1 = 0 ;
51335 int res1 = 0 ;
51336 int val2 ;
51337 int ecode2 = 0 ;
51338 PyObject * obj0 = 0 ;
51339 PyObject * obj1 = 0 ;
51340 char * kwnames[] = {
51341 (char *) "box",(char *) "orient", NULL
51342 };
51343
51344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51346 if (!SWIG_IsOK(res1)) {
51347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51348 }
51349 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51350 if (obj1) {
51351 ecode2 = SWIG_AsVal_int(obj1, &val2);
51352 if (!SWIG_IsOK(ecode2)) {
51353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51354 }
51355 arg2 = static_cast< int >(val2);
51356 }
51357 {
51358 PyThreadState* __tstate = wxPyBeginAllowThreads();
51359 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51360 wxPyEndAllowThreads(__tstate);
51361 if (PyErr_Occurred()) SWIG_fail;
51362 }
51363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51364 return resultobj;
51365fail:
51366 return NULL;
d55e5bfc
RD
51367}
51368
51369
1bd55598
RD
51370SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51371 PyObject *resultobj = 0;
51372 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51373 wxStaticBox *result = 0 ;
51374 void *argp1 = 0 ;
51375 int res1 = 0 ;
51376 PyObject *swig_obj[1] ;
51377
51378 if (!args) SWIG_fail;
51379 swig_obj[0] = args;
51380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51381 if (!SWIG_IsOK(res1)) {
51382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51383 }
51384 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51385 {
51386 PyThreadState* __tstate = wxPyBeginAllowThreads();
51387 result = (wxStaticBox *)(arg1)->GetStaticBox();
51388 wxPyEndAllowThreads(__tstate);
51389 if (PyErr_Occurred()) SWIG_fail;
51390 }
51391 {
51392 resultobj = wxPyMake_wxObject(result, (bool)0);
51393 }
51394 return resultobj;
51395fail:
51396 return NULL;
51397}
51398
51399
51400SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51401 PyObject *obj;
51402 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51403 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51404 return SWIG_Py_Void();
51405}
51406
51407SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51408 return SWIG_Python_InitShadowInstance(args);
51409}
51410
51411SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51412 PyObject *resultobj = 0;
51413 int arg1 = (int) 1 ;
51414 int arg2 = (int) 0 ;
51415 int arg3 = (int) 0 ;
51416 int arg4 = (int) 0 ;
51417 wxGridSizer *result = 0 ;
51418 int val1 ;
51419 int ecode1 = 0 ;
51420 int val2 ;
51421 int ecode2 = 0 ;
51422 int val3 ;
51423 int ecode3 = 0 ;
51424 int val4 ;
51425 int ecode4 = 0 ;
51426 PyObject * obj0 = 0 ;
51427 PyObject * obj1 = 0 ;
51428 PyObject * obj2 = 0 ;
51429 PyObject * obj3 = 0 ;
51430 char * kwnames[] = {
51431 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51432 };
51433
51434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51435 if (obj0) {
51436 ecode1 = SWIG_AsVal_int(obj0, &val1);
51437 if (!SWIG_IsOK(ecode1)) {
51438 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51439 }
51440 arg1 = static_cast< int >(val1);
51441 }
51442 if (obj1) {
51443 ecode2 = SWIG_AsVal_int(obj1, &val2);
51444 if (!SWIG_IsOK(ecode2)) {
51445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51446 }
51447 arg2 = static_cast< int >(val2);
51448 }
51449 if (obj2) {
51450 ecode3 = SWIG_AsVal_int(obj2, &val3);
51451 if (!SWIG_IsOK(ecode3)) {
51452 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51453 }
51454 arg3 = static_cast< int >(val3);
51455 }
51456 if (obj3) {
51457 ecode4 = SWIG_AsVal_int(obj3, &val4);
51458 if (!SWIG_IsOK(ecode4)) {
51459 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51460 }
51461 arg4 = static_cast< int >(val4);
51462 }
51463 {
51464 PyThreadState* __tstate = wxPyBeginAllowThreads();
51465 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51466 wxPyEndAllowThreads(__tstate);
51467 if (PyErr_Occurred()) SWIG_fail;
51468 }
51469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51470 return resultobj;
51471fail:
51472 return NULL;
51473}
51474
51475
51476SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51477 PyObject *resultobj = 0;
51478 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51479 int arg2 ;
51480 void *argp1 = 0 ;
51481 int res1 = 0 ;
51482 int val2 ;
51483 int ecode2 = 0 ;
51484 PyObject * obj0 = 0 ;
51485 PyObject * obj1 = 0 ;
51486 char * kwnames[] = {
51487 (char *) "self",(char *) "cols", NULL
51488 };
51489
51490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51492 if (!SWIG_IsOK(res1)) {
51493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51494 }
51495 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51496 ecode2 = SWIG_AsVal_int(obj1, &val2);
51497 if (!SWIG_IsOK(ecode2)) {
51498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51499 }
51500 arg2 = static_cast< int >(val2);
51501 {
51502 PyThreadState* __tstate = wxPyBeginAllowThreads();
51503 (arg1)->SetCols(arg2);
51504 wxPyEndAllowThreads(__tstate);
51505 if (PyErr_Occurred()) SWIG_fail;
51506 }
51507 resultobj = SWIG_Py_Void();
51508 return resultobj;
51509fail:
51510 return NULL;
51511}
51512
51513
51514SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51515 PyObject *resultobj = 0;
51516 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51517 int arg2 ;
51518 void *argp1 = 0 ;
51519 int res1 = 0 ;
51520 int val2 ;
51521 int ecode2 = 0 ;
51522 PyObject * obj0 = 0 ;
51523 PyObject * obj1 = 0 ;
51524 char * kwnames[] = {
51525 (char *) "self",(char *) "rows", NULL
51526 };
51527
51528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51530 if (!SWIG_IsOK(res1)) {
51531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51532 }
51533 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51534 ecode2 = SWIG_AsVal_int(obj1, &val2);
51535 if (!SWIG_IsOK(ecode2)) {
51536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51537 }
51538 arg2 = static_cast< int >(val2);
51539 {
51540 PyThreadState* __tstate = wxPyBeginAllowThreads();
51541 (arg1)->SetRows(arg2);
51542 wxPyEndAllowThreads(__tstate);
51543 if (PyErr_Occurred()) SWIG_fail;
51544 }
51545 resultobj = SWIG_Py_Void();
51546 return resultobj;
51547fail:
51548 return NULL;
51549}
51550
51551
51552SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51553 PyObject *resultobj = 0;
51554 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51555 int arg2 ;
51556 void *argp1 = 0 ;
51557 int res1 = 0 ;
51558 int val2 ;
51559 int ecode2 = 0 ;
51560 PyObject * obj0 = 0 ;
51561 PyObject * obj1 = 0 ;
51562 char * kwnames[] = {
51563 (char *) "self",(char *) "gap", NULL
51564 };
51565
51566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51568 if (!SWIG_IsOK(res1)) {
51569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51570 }
51571 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51572 ecode2 = SWIG_AsVal_int(obj1, &val2);
51573 if (!SWIG_IsOK(ecode2)) {
51574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51575 }
51576 arg2 = static_cast< int >(val2);
51577 {
51578 PyThreadState* __tstate = wxPyBeginAllowThreads();
51579 (arg1)->SetVGap(arg2);
51580 wxPyEndAllowThreads(__tstate);
51581 if (PyErr_Occurred()) SWIG_fail;
51582 }
51583 resultobj = SWIG_Py_Void();
51584 return resultobj;
51585fail:
51586 return NULL;
51587}
51588
51589
51590SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51591 PyObject *resultobj = 0;
51592 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51593 int arg2 ;
51594 void *argp1 = 0 ;
51595 int res1 = 0 ;
51596 int val2 ;
51597 int ecode2 = 0 ;
51598 PyObject * obj0 = 0 ;
51599 PyObject * obj1 = 0 ;
51600 char * kwnames[] = {
51601 (char *) "self",(char *) "gap", NULL
51602 };
51603
51604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51606 if (!SWIG_IsOK(res1)) {
51607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51608 }
51609 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51610 ecode2 = SWIG_AsVal_int(obj1, &val2);
51611 if (!SWIG_IsOK(ecode2)) {
51612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51613 }
51614 arg2 = static_cast< int >(val2);
51615 {
51616 PyThreadState* __tstate = wxPyBeginAllowThreads();
51617 (arg1)->SetHGap(arg2);
51618 wxPyEndAllowThreads(__tstate);
51619 if (PyErr_Occurred()) SWIG_fail;
51620 }
51621 resultobj = SWIG_Py_Void();
51622 return resultobj;
51623fail:
51624 return NULL;
d55e5bfc
RD
51625}
51626
51627
1bd55598
RD
51628SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51629 PyObject *resultobj = 0;
51630 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51631 int result;
51632 void *argp1 = 0 ;
51633 int res1 = 0 ;
51634 PyObject *swig_obj[1] ;
51635
51636 if (!args) SWIG_fail;
51637 swig_obj[0] = args;
51638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51639 if (!SWIG_IsOK(res1)) {
51640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51641 }
51642 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51643 {
51644 PyThreadState* __tstate = wxPyBeginAllowThreads();
51645 result = (int)(arg1)->GetCols();
51646 wxPyEndAllowThreads(__tstate);
51647 if (PyErr_Occurred()) SWIG_fail;
51648 }
51649 resultobj = SWIG_From_int(static_cast< int >(result));
51650 return resultobj;
51651fail:
51652 return NULL;
d55e5bfc
RD
51653}
51654
51655
1bd55598
RD
51656SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51657 PyObject *resultobj = 0;
51658 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51659 int result;
51660 void *argp1 = 0 ;
51661 int res1 = 0 ;
51662 PyObject *swig_obj[1] ;
51663
51664 if (!args) SWIG_fail;
51665 swig_obj[0] = args;
51666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51667 if (!SWIG_IsOK(res1)) {
51668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51669 }
51670 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51671 {
51672 PyThreadState* __tstate = wxPyBeginAllowThreads();
51673 result = (int)(arg1)->GetRows();
51674 wxPyEndAllowThreads(__tstate);
51675 if (PyErr_Occurred()) SWIG_fail;
51676 }
51677 resultobj = SWIG_From_int(static_cast< int >(result));
51678 return resultobj;
51679fail:
51680 return NULL;
d55e5bfc
RD
51681}
51682
51683
1bd55598
RD
51684SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51685 PyObject *resultobj = 0;
51686 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51687 int result;
51688 void *argp1 = 0 ;
51689 int res1 = 0 ;
51690 PyObject *swig_obj[1] ;
51691
51692 if (!args) SWIG_fail;
51693 swig_obj[0] = args;
51694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51695 if (!SWIG_IsOK(res1)) {
51696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51697 }
51698 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51699 {
51700 PyThreadState* __tstate = wxPyBeginAllowThreads();
51701 result = (int)(arg1)->GetVGap();
51702 wxPyEndAllowThreads(__tstate);
51703 if (PyErr_Occurred()) SWIG_fail;
51704 }
51705 resultobj = SWIG_From_int(static_cast< int >(result));
51706 return resultobj;
51707fail:
51708 return NULL;
908b74cd
RD
51709}
51710
51711
1bd55598
RD
51712SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51713 PyObject *resultobj = 0;
51714 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51715 int result;
51716 void *argp1 = 0 ;
51717 int res1 = 0 ;
51718 PyObject *swig_obj[1] ;
51719
51720 if (!args) SWIG_fail;
51721 swig_obj[0] = args;
51722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51723 if (!SWIG_IsOK(res1)) {
51724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51725 }
51726 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51727 {
51728 PyThreadState* __tstate = wxPyBeginAllowThreads();
51729 result = (int)(arg1)->GetHGap();
51730 wxPyEndAllowThreads(__tstate);
51731 if (PyErr_Occurred()) SWIG_fail;
51732 }
51733 resultobj = SWIG_From_int(static_cast< int >(result));
51734 return resultobj;
51735fail:
51736 return NULL;
51737}
51738
51739
51740SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51741 PyObject *obj;
51742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51743 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51744 return SWIG_Py_Void();
51745}
51746
51747SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51748 return SWIG_Python_InitShadowInstance(args);
51749}
51750
51751SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51752 PyObject *resultobj = 0;
51753 int arg1 = (int) 1 ;
51754 int arg2 = (int) 0 ;
51755 int arg3 = (int) 0 ;
51756 int arg4 = (int) 0 ;
51757 wxFlexGridSizer *result = 0 ;
51758 int val1 ;
51759 int ecode1 = 0 ;
51760 int val2 ;
51761 int ecode2 = 0 ;
51762 int val3 ;
51763 int ecode3 = 0 ;
51764 int val4 ;
51765 int ecode4 = 0 ;
51766 PyObject * obj0 = 0 ;
51767 PyObject * obj1 = 0 ;
51768 PyObject * obj2 = 0 ;
51769 PyObject * obj3 = 0 ;
51770 char * kwnames[] = {
51771 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51772 };
51773
51774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51775 if (obj0) {
51776 ecode1 = SWIG_AsVal_int(obj0, &val1);
51777 if (!SWIG_IsOK(ecode1)) {
51778 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51779 }
51780 arg1 = static_cast< int >(val1);
51781 }
51782 if (obj1) {
51783 ecode2 = SWIG_AsVal_int(obj1, &val2);
51784 if (!SWIG_IsOK(ecode2)) {
51785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51786 }
51787 arg2 = static_cast< int >(val2);
51788 }
51789 if (obj2) {
51790 ecode3 = SWIG_AsVal_int(obj2, &val3);
51791 if (!SWIG_IsOK(ecode3)) {
51792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51793 }
51794 arg3 = static_cast< int >(val3);
51795 }
51796 if (obj3) {
51797 ecode4 = SWIG_AsVal_int(obj3, &val4);
51798 if (!SWIG_IsOK(ecode4)) {
51799 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51800 }
51801 arg4 = static_cast< int >(val4);
51802 }
51803 {
51804 PyThreadState* __tstate = wxPyBeginAllowThreads();
51805 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51806 wxPyEndAllowThreads(__tstate);
51807 if (PyErr_Occurred()) SWIG_fail;
51808 }
51809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51810 return resultobj;
51811fail:
51812 return NULL;
51813}
51814
51815
51816SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51817 PyObject *resultobj = 0;
51818 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51819 size_t arg2 ;
51820 int arg3 = (int) 0 ;
51821 void *argp1 = 0 ;
51822 int res1 = 0 ;
51823 size_t val2 ;
51824 int ecode2 = 0 ;
51825 int val3 ;
51826 int ecode3 = 0 ;
51827 PyObject * obj0 = 0 ;
51828 PyObject * obj1 = 0 ;
51829 PyObject * obj2 = 0 ;
51830 char * kwnames[] = {
51831 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51832 };
51833
51834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51836 if (!SWIG_IsOK(res1)) {
51837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51838 }
51839 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51840 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51841 if (!SWIG_IsOK(ecode2)) {
51842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51843 }
51844 arg2 = static_cast< size_t >(val2);
51845 if (obj2) {
51846 ecode3 = SWIG_AsVal_int(obj2, &val3);
51847 if (!SWIG_IsOK(ecode3)) {
51848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51849 }
51850 arg3 = static_cast< int >(val3);
51851 }
51852 {
51853 PyThreadState* __tstate = wxPyBeginAllowThreads();
51854 (arg1)->AddGrowableRow(arg2,arg3);
51855 wxPyEndAllowThreads(__tstate);
51856 if (PyErr_Occurred()) SWIG_fail;
51857 }
51858 resultobj = SWIG_Py_Void();
51859 return resultobj;
51860fail:
51861 return NULL;
51862}
51863
51864
51865SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51866 PyObject *resultobj = 0;
51867 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51868 size_t arg2 ;
51869 void *argp1 = 0 ;
51870 int res1 = 0 ;
51871 size_t val2 ;
51872 int ecode2 = 0 ;
51873 PyObject * obj0 = 0 ;
51874 PyObject * obj1 = 0 ;
51875 char * kwnames[] = {
51876 (char *) "self",(char *) "idx", NULL
51877 };
51878
51879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51881 if (!SWIG_IsOK(res1)) {
51882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51883 }
51884 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51885 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51886 if (!SWIG_IsOK(ecode2)) {
51887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51888 }
51889 arg2 = static_cast< size_t >(val2);
51890 {
51891 PyThreadState* __tstate = wxPyBeginAllowThreads();
51892 (arg1)->RemoveGrowableRow(arg2);
51893 wxPyEndAllowThreads(__tstate);
51894 if (PyErr_Occurred()) SWIG_fail;
51895 }
51896 resultobj = SWIG_Py_Void();
51897 return resultobj;
51898fail:
51899 return NULL;
51900}
51901
51902
51903SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51904 PyObject *resultobj = 0;
51905 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51906 size_t arg2 ;
51907 int arg3 = (int) 0 ;
51908 void *argp1 = 0 ;
51909 int res1 = 0 ;
51910 size_t val2 ;
51911 int ecode2 = 0 ;
51912 int val3 ;
51913 int ecode3 = 0 ;
51914 PyObject * obj0 = 0 ;
51915 PyObject * obj1 = 0 ;
51916 PyObject * obj2 = 0 ;
51917 char * kwnames[] = {
51918 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51919 };
51920
51921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51923 if (!SWIG_IsOK(res1)) {
51924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51925 }
51926 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51927 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51928 if (!SWIG_IsOK(ecode2)) {
51929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51930 }
51931 arg2 = static_cast< size_t >(val2);
51932 if (obj2) {
51933 ecode3 = SWIG_AsVal_int(obj2, &val3);
51934 if (!SWIG_IsOK(ecode3)) {
51935 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51936 }
51937 arg3 = static_cast< int >(val3);
51938 }
51939 {
51940 PyThreadState* __tstate = wxPyBeginAllowThreads();
51941 (arg1)->AddGrowableCol(arg2,arg3);
51942 wxPyEndAllowThreads(__tstate);
51943 if (PyErr_Occurred()) SWIG_fail;
51944 }
51945 resultobj = SWIG_Py_Void();
51946 return resultobj;
51947fail:
51948 return NULL;
51949}
51950
51951
51952SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51953 PyObject *resultobj = 0;
51954 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51955 size_t arg2 ;
51956 void *argp1 = 0 ;
51957 int res1 = 0 ;
51958 size_t val2 ;
51959 int ecode2 = 0 ;
51960 PyObject * obj0 = 0 ;
51961 PyObject * obj1 = 0 ;
51962 char * kwnames[] = {
51963 (char *) "self",(char *) "idx", NULL
51964 };
51965
51966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
51967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51968 if (!SWIG_IsOK(res1)) {
51969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51970 }
51971 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51972 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51973 if (!SWIG_IsOK(ecode2)) {
51974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51975 }
51976 arg2 = static_cast< size_t >(val2);
51977 {
51978 PyThreadState* __tstate = wxPyBeginAllowThreads();
51979 (arg1)->RemoveGrowableCol(arg2);
51980 wxPyEndAllowThreads(__tstate);
51981 if (PyErr_Occurred()) SWIG_fail;
51982 }
51983 resultobj = SWIG_Py_Void();
51984 return resultobj;
51985fail:
51986 return NULL;
51987}
51988
51989
51990SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51991 PyObject *resultobj = 0;
51992 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51993 int arg2 ;
51994 void *argp1 = 0 ;
51995 int res1 = 0 ;
51996 int val2 ;
51997 int ecode2 = 0 ;
51998 PyObject * obj0 = 0 ;
51999 PyObject * obj1 = 0 ;
52000 char * kwnames[] = {
52001 (char *) "self",(char *) "direction", NULL
52002 };
52003
52004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
52005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52006 if (!SWIG_IsOK(res1)) {
52007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52008 }
52009 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52010 ecode2 = SWIG_AsVal_int(obj1, &val2);
52011 if (!SWIG_IsOK(ecode2)) {
52012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
52013 }
52014 arg2 = static_cast< int >(val2);
52015 {
52016 PyThreadState* __tstate = wxPyBeginAllowThreads();
52017 (arg1)->SetFlexibleDirection(arg2);
52018 wxPyEndAllowThreads(__tstate);
52019 if (PyErr_Occurred()) SWIG_fail;
52020 }
52021 resultobj = SWIG_Py_Void();
52022 return resultobj;
52023fail:
52024 return NULL;
908b74cd
RD
52025}
52026
52027
1bd55598
RD
52028SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52029 PyObject *resultobj = 0;
52030 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52031 int result;
52032 void *argp1 = 0 ;
52033 int res1 = 0 ;
52034 PyObject *swig_obj[1] ;
52035
52036 if (!args) SWIG_fail;
52037 swig_obj[0] = args;
52038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52039 if (!SWIG_IsOK(res1)) {
52040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52041 }
52042 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52043 {
52044 PyThreadState* __tstate = wxPyBeginAllowThreads();
52045 result = (int)(arg1)->GetFlexibleDirection();
52046 wxPyEndAllowThreads(__tstate);
52047 if (PyErr_Occurred()) SWIG_fail;
52048 }
52049 resultobj = SWIG_From_int(static_cast< int >(result));
52050 return resultobj;
52051fail:
52052 return NULL;
52053}
52054
52055
52056SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52057 PyObject *resultobj = 0;
52058 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52059 wxFlexSizerGrowMode arg2 ;
52060 void *argp1 = 0 ;
52061 int res1 = 0 ;
52062 int val2 ;
52063 int ecode2 = 0 ;
52064 PyObject * obj0 = 0 ;
52065 PyObject * obj1 = 0 ;
52066 char * kwnames[] = {
52067 (char *) "self",(char *) "mode", NULL
52068 };
52069
52070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52072 if (!SWIG_IsOK(res1)) {
52073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52074 }
52075 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52076 ecode2 = SWIG_AsVal_int(obj1, &val2);
52077 if (!SWIG_IsOK(ecode2)) {
52078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52079 }
52080 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52081 {
52082 PyThreadState* __tstate = wxPyBeginAllowThreads();
52083 (arg1)->SetNonFlexibleGrowMode(arg2);
52084 wxPyEndAllowThreads(__tstate);
52085 if (PyErr_Occurred()) SWIG_fail;
52086 }
52087 resultobj = SWIG_Py_Void();
52088 return resultobj;
52089fail:
52090 return NULL;
d55e5bfc
RD
52091}
52092
52093
1bd55598
RD
52094SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52095 PyObject *resultobj = 0;
52096 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52097 wxFlexSizerGrowMode result;
52098 void *argp1 = 0 ;
52099 int res1 = 0 ;
52100 PyObject *swig_obj[1] ;
52101
52102 if (!args) SWIG_fail;
52103 swig_obj[0] = args;
52104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52105 if (!SWIG_IsOK(res1)) {
52106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52107 }
52108 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52109 {
52110 PyThreadState* __tstate = wxPyBeginAllowThreads();
52111 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52112 wxPyEndAllowThreads(__tstate);
52113 if (PyErr_Occurred()) SWIG_fail;
52114 }
52115 resultobj = SWIG_From_int(static_cast< int >(result));
52116 return resultobj;
52117fail:
52118 return NULL;
d55e5bfc
RD
52119}
52120
52121
1bd55598
RD
52122SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52123 PyObject *resultobj = 0;
52124 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52125 wxArrayInt *result = 0 ;
52126 void *argp1 = 0 ;
52127 int res1 = 0 ;
52128 PyObject *swig_obj[1] ;
52129
52130 if (!args) SWIG_fail;
52131 swig_obj[0] = args;
52132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52133 if (!SWIG_IsOK(res1)) {
52134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52135 }
52136 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52137 {
52138 PyThreadState* __tstate = wxPyBeginAllowThreads();
d55e5bfc 52139 {
1bd55598
RD
52140 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52141 result = (wxArrayInt *) &_result_ref;
d55e5bfc 52142 }
1bd55598
RD
52143 wxPyEndAllowThreads(__tstate);
52144 if (PyErr_Occurred()) SWIG_fail;
52145 }
52146 {
b39fe951 52147 resultobj = wxArrayInt2PyList_helper(*result);
1bd55598
RD
52148 }
52149 return resultobj;
52150fail:
52151 return NULL;
d55e5bfc
RD
52152}
52153
52154
1bd55598
RD
52155SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52156 PyObject *resultobj = 0;
52157 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52158 wxArrayInt *result = 0 ;
52159 void *argp1 = 0 ;
52160 int res1 = 0 ;
52161 PyObject *swig_obj[1] ;
52162
52163 if (!args) SWIG_fail;
52164 swig_obj[0] = args;
52165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52166 if (!SWIG_IsOK(res1)) {
52167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52168 }
52169 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52170 {
52171 PyThreadState* __tstate = wxPyBeginAllowThreads();
d55e5bfc 52172 {
1bd55598
RD
52173 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52174 result = (wxArrayInt *) &_result_ref;
d55e5bfc 52175 }
1bd55598
RD
52176 wxPyEndAllowThreads(__tstate);
52177 if (PyErr_Occurred()) SWIG_fail;
52178 }
52179 {
b39fe951 52180 resultobj = wxArrayInt2PyList_helper(*result);
1bd55598
RD
52181 }
52182 return resultobj;
52183fail:
52184 return NULL;
d55e5bfc
RD
52185}
52186
52187
1bd55598
RD
52188SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52189 PyObject *obj;
52190 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52191 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52192 return SWIG_Py_Void();
d55e5bfc
RD
52193}
52194
1bd55598
RD
52195SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52196 return SWIG_Python_InitShadowInstance(args);
52197}
d55e5bfc 52198
1bd55598
RD
52199SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52200 PyObject *resultobj = 0;
52201 wxStdDialogButtonSizer *result = 0 ;
52202
52203 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52204 {
52205 PyThreadState* __tstate = wxPyBeginAllowThreads();
52206 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52207 wxPyEndAllowThreads(__tstate);
52208 if (PyErr_Occurred()) SWIG_fail;
52209 }
52210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52211 return resultobj;
52212fail:
52213 return NULL;
52214}
52215
52216
52217SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52218 PyObject *resultobj = 0;
52219 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52220 wxButton *arg2 = (wxButton *) 0 ;
52221 void *argp1 = 0 ;
52222 int res1 = 0 ;
52223 void *argp2 = 0 ;
52224 int res2 = 0 ;
52225 PyObject * obj0 = 0 ;
52226 PyObject * obj1 = 0 ;
52227 char * kwnames[] = {
52228 (char *) "self",(char *) "button", NULL
52229 };
52230
52231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52233 if (!SWIG_IsOK(res1)) {
52234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52235 }
52236 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52237 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52238 if (!SWIG_IsOK(res2)) {
52239 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52240 }
52241 arg2 = reinterpret_cast< wxButton * >(argp2);
52242 {
52243 PyThreadState* __tstate = wxPyBeginAllowThreads();
52244 (arg1)->AddButton(arg2);
52245 wxPyEndAllowThreads(__tstate);
52246 if (PyErr_Occurred()) SWIG_fail;
52247 }
52248 resultobj = SWIG_Py_Void();
52249 return resultobj;
52250fail:
52251 return NULL;
d55e5bfc
RD
52252}
52253
52254
1bd55598
RD
52255SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52256 PyObject *resultobj = 0;
52257 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52258 void *argp1 = 0 ;
52259 int res1 = 0 ;
52260 PyObject *swig_obj[1] ;
52261
52262 if (!args) SWIG_fail;
52263 swig_obj[0] = args;
52264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52265 if (!SWIG_IsOK(res1)) {
52266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52267 }
52268 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52269 {
52270 PyThreadState* __tstate = wxPyBeginAllowThreads();
52271 (arg1)->Realize();
52272 wxPyEndAllowThreads(__tstate);
52273 if (PyErr_Occurred()) SWIG_fail;
52274 }
52275 resultobj = SWIG_Py_Void();
52276 return resultobj;
52277fail:
52278 return NULL;
52279}
52280
52281
52282SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52283 PyObject *resultobj = 0;
52284 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52285 wxButton *arg2 = (wxButton *) 0 ;
52286 void *argp1 = 0 ;
52287 int res1 = 0 ;
52288 void *argp2 = 0 ;
52289 int res2 = 0 ;
52290 PyObject * obj0 = 0 ;
52291 PyObject * obj1 = 0 ;
52292 char * kwnames[] = {
52293 (char *) "self",(char *) "button", NULL
52294 };
52295
52296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52298 if (!SWIG_IsOK(res1)) {
52299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52300 }
52301 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52302 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52303 if (!SWIG_IsOK(res2)) {
52304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52305 }
52306 arg2 = reinterpret_cast< wxButton * >(argp2);
52307 {
52308 PyThreadState* __tstate = wxPyBeginAllowThreads();
52309 (arg1)->SetAffirmativeButton(arg2);
52310 wxPyEndAllowThreads(__tstate);
52311 if (PyErr_Occurred()) SWIG_fail;
52312 }
52313 resultobj = SWIG_Py_Void();
52314 return resultobj;
52315fail:
52316 return NULL;
52317}
52318
52319
52320SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52321 PyObject *resultobj = 0;
52322 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52323 wxButton *arg2 = (wxButton *) 0 ;
52324 void *argp1 = 0 ;
52325 int res1 = 0 ;
52326 void *argp2 = 0 ;
52327 int res2 = 0 ;
52328 PyObject * obj0 = 0 ;
52329 PyObject * obj1 = 0 ;
52330 char * kwnames[] = {
52331 (char *) "self",(char *) "button", NULL
52332 };
52333
52334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52336 if (!SWIG_IsOK(res1)) {
52337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52338 }
52339 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52340 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52341 if (!SWIG_IsOK(res2)) {
52342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52343 }
52344 arg2 = reinterpret_cast< wxButton * >(argp2);
52345 {
52346 PyThreadState* __tstate = wxPyBeginAllowThreads();
52347 (arg1)->SetNegativeButton(arg2);
52348 wxPyEndAllowThreads(__tstate);
52349 if (PyErr_Occurred()) SWIG_fail;
52350 }
52351 resultobj = SWIG_Py_Void();
52352 return resultobj;
52353fail:
52354 return NULL;
52355}
52356
52357
52358SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52359 PyObject *resultobj = 0;
52360 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52361 wxButton *arg2 = (wxButton *) 0 ;
52362 void *argp1 = 0 ;
52363 int res1 = 0 ;
52364 void *argp2 = 0 ;
52365 int res2 = 0 ;
52366 PyObject * obj0 = 0 ;
52367 PyObject * obj1 = 0 ;
52368 char * kwnames[] = {
52369 (char *) "self",(char *) "button", NULL
52370 };
52371
52372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52374 if (!SWIG_IsOK(res1)) {
52375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52376 }
52377 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52378 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52379 if (!SWIG_IsOK(res2)) {
52380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52381 }
52382 arg2 = reinterpret_cast< wxButton * >(argp2);
52383 {
52384 PyThreadState* __tstate = wxPyBeginAllowThreads();
52385 (arg1)->SetCancelButton(arg2);
52386 wxPyEndAllowThreads(__tstate);
52387 if (PyErr_Occurred()) SWIG_fail;
52388 }
52389 resultobj = SWIG_Py_Void();
52390 return resultobj;
52391fail:
52392 return NULL;
d55e5bfc
RD
52393}
52394
52395
1bd55598
RD
52396SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52397 PyObject *resultobj = 0;
52398 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52399 wxButton *result = 0 ;
52400 void *argp1 = 0 ;
52401 int res1 = 0 ;
52402 PyObject *swig_obj[1] ;
52403
52404 if (!args) SWIG_fail;
52405 swig_obj[0] = args;
52406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52407 if (!SWIG_IsOK(res1)) {
52408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52409 }
52410 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52411 {
52412 PyThreadState* __tstate = wxPyBeginAllowThreads();
52413 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52414 wxPyEndAllowThreads(__tstate);
52415 if (PyErr_Occurred()) SWIG_fail;
52416 }
52417 {
52418 resultobj = wxPyMake_wxObject(result, (bool)0);
52419 }
52420 return resultobj;
52421fail:
52422 return NULL;
d55e5bfc
RD
52423}
52424
52425
1bd55598
RD
52426SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52427 PyObject *resultobj = 0;
52428 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52429 wxButton *result = 0 ;
52430 void *argp1 = 0 ;
52431 int res1 = 0 ;
52432 PyObject *swig_obj[1] ;
52433
52434 if (!args) SWIG_fail;
52435 swig_obj[0] = args;
52436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52437 if (!SWIG_IsOK(res1)) {
52438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52439 }
52440 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52441 {
52442 PyThreadState* __tstate = wxPyBeginAllowThreads();
52443 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52444 wxPyEndAllowThreads(__tstate);
52445 if (PyErr_Occurred()) SWIG_fail;
52446 }
52447 {
52448 resultobj = wxPyMake_wxObject(result, (bool)0);
52449 }
52450 return resultobj;
52451fail:
52452 return NULL;
d55e5bfc
RD
52453}
52454
52455
1bd55598
RD
52456SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52457 PyObject *resultobj = 0;
52458 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52459 wxButton *result = 0 ;
52460 void *argp1 = 0 ;
52461 int res1 = 0 ;
52462 PyObject *swig_obj[1] ;
52463
52464 if (!args) SWIG_fail;
52465 swig_obj[0] = args;
52466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52467 if (!SWIG_IsOK(res1)) {
52468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52469 }
52470 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52471 {
52472 PyThreadState* __tstate = wxPyBeginAllowThreads();
52473 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52474 wxPyEndAllowThreads(__tstate);
52475 if (PyErr_Occurred()) SWIG_fail;
52476 }
52477 {
52478 resultobj = wxPyMake_wxObject(result, (bool)0);
52479 }
52480 return resultobj;
52481fail:
52482 return NULL;
d55e5bfc
RD
52483}
52484
52485
1bd55598
RD
52486SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52487 PyObject *resultobj = 0;
52488 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52489 wxButton *result = 0 ;
52490 void *argp1 = 0 ;
52491 int res1 = 0 ;
52492 PyObject *swig_obj[1] ;
52493
52494 if (!args) SWIG_fail;
52495 swig_obj[0] = args;
52496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52497 if (!SWIG_IsOK(res1)) {
52498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52499 }
52500 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52501 {
52502 PyThreadState* __tstate = wxPyBeginAllowThreads();
52503 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52504 wxPyEndAllowThreads(__tstate);
52505 if (PyErr_Occurred()) SWIG_fail;
52506 }
52507 {
52508 resultobj = wxPyMake_wxObject(result, (bool)0);
52509 }
52510 return resultobj;
52511fail:
52512 return NULL;
d55e5bfc
RD
52513}
52514
52515
1bd55598
RD
52516SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52517 PyObject *resultobj = 0;
52518 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52519 wxButton *result = 0 ;
52520 void *argp1 = 0 ;
52521 int res1 = 0 ;
52522 PyObject *swig_obj[1] ;
52523
52524 if (!args) SWIG_fail;
52525 swig_obj[0] = args;
52526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52527 if (!SWIG_IsOK(res1)) {
52528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52529 }
52530 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52531 {
52532 PyThreadState* __tstate = wxPyBeginAllowThreads();
52533 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52534 wxPyEndAllowThreads(__tstate);
52535 if (PyErr_Occurred()) SWIG_fail;
52536 }
52537 {
52538 resultobj = wxPyMake_wxObject(result, (bool)0);
52539 }
52540 return resultobj;
52541fail:
52542 return NULL;
d55e5bfc
RD
52543}
52544
52545
1bd55598
RD
52546SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52547 PyObject *obj;
52548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52549 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52550 return SWIG_Py_Void();
d55e5bfc
RD
52551}
52552
1bd55598
RD
52553SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52554 return SWIG_Python_InitShadowInstance(args);
52555}
d55e5bfc 52556
1bd55598
RD
52557SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52558 PyObject *resultobj = 0;
52559 int arg1 = (int) 0 ;
52560 int arg2 = (int) 0 ;
52561 wxGBPosition *result = 0 ;
52562 int val1 ;
52563 int ecode1 = 0 ;
52564 int val2 ;
52565 int ecode2 = 0 ;
52566 PyObject * obj0 = 0 ;
52567 PyObject * obj1 = 0 ;
52568 char * kwnames[] = {
52569 (char *) "row",(char *) "col", NULL
52570 };
52571
52572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52573 if (obj0) {
52574 ecode1 = SWIG_AsVal_int(obj0, &val1);
52575 if (!SWIG_IsOK(ecode1)) {
52576 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52577 }
52578 arg1 = static_cast< int >(val1);
52579 }
52580 if (obj1) {
52581 ecode2 = SWIG_AsVal_int(obj1, &val2);
52582 if (!SWIG_IsOK(ecode2)) {
52583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52584 }
52585 arg2 = static_cast< int >(val2);
52586 }
52587 {
52588 PyThreadState* __tstate = wxPyBeginAllowThreads();
52589 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52590 wxPyEndAllowThreads(__tstate);
52591 if (PyErr_Occurred()) SWIG_fail;
52592 }
52593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52594 return resultobj;
52595fail:
52596 return NULL;
d55e5bfc
RD
52597}
52598
52599
1bd55598
RD
52600SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52601 PyObject *resultobj = 0;
52602 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52603 void *argp1 = 0 ;
52604 int res1 = 0 ;
52605 PyObject *swig_obj[1] ;
52606
52607 if (!args) SWIG_fail;
52608 swig_obj[0] = args;
52609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52610 if (!SWIG_IsOK(res1)) {
52611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52612 }
52613 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52614 {
52615 PyThreadState* __tstate = wxPyBeginAllowThreads();
52616 delete arg1;
d55e5bfc 52617
1bd55598
RD
52618 wxPyEndAllowThreads(__tstate);
52619 if (PyErr_Occurred()) SWIG_fail;
52620 }
52621 resultobj = SWIG_Py_Void();
52622 return resultobj;
52623fail:
52624 return NULL;
d55e5bfc
RD
52625}
52626
52627
1bd55598
RD
52628SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52629 PyObject *resultobj = 0;
52630 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52631 int result;
52632 void *argp1 = 0 ;
52633 int res1 = 0 ;
52634 PyObject *swig_obj[1] ;
52635
52636 if (!args) SWIG_fail;
52637 swig_obj[0] = args;
52638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52639 if (!SWIG_IsOK(res1)) {
52640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52641 }
52642 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52643 {
52644 PyThreadState* __tstate = wxPyBeginAllowThreads();
52645 result = (int)((wxGBPosition const *)arg1)->GetRow();
52646 wxPyEndAllowThreads(__tstate);
52647 if (PyErr_Occurred()) SWIG_fail;
52648 }
52649 resultobj = SWIG_From_int(static_cast< int >(result));
52650 return resultobj;
52651fail:
52652 return NULL;
d55e5bfc
RD
52653}
52654
52655
1bd55598
RD
52656SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52657 PyObject *resultobj = 0;
52658 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52659 int result;
52660 void *argp1 = 0 ;
52661 int res1 = 0 ;
52662 PyObject *swig_obj[1] ;
52663
52664 if (!args) SWIG_fail;
52665 swig_obj[0] = args;
52666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52667 if (!SWIG_IsOK(res1)) {
52668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52669 }
52670 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52671 {
52672 PyThreadState* __tstate = wxPyBeginAllowThreads();
52673 result = (int)((wxGBPosition const *)arg1)->GetCol();
52674 wxPyEndAllowThreads(__tstate);
52675 if (PyErr_Occurred()) SWIG_fail;
52676 }
52677 resultobj = SWIG_From_int(static_cast< int >(result));
52678 return resultobj;
52679fail:
52680 return NULL;
52681}
52682
52683
52684SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52685 PyObject *resultobj = 0;
52686 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52687 int arg2 ;
52688 void *argp1 = 0 ;
52689 int res1 = 0 ;
52690 int val2 ;
52691 int ecode2 = 0 ;
52692 PyObject * obj0 = 0 ;
52693 PyObject * obj1 = 0 ;
52694 char * kwnames[] = {
52695 (char *) "self",(char *) "row", NULL
52696 };
52697
52698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52700 if (!SWIG_IsOK(res1)) {
52701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52702 }
52703 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52704 ecode2 = SWIG_AsVal_int(obj1, &val2);
52705 if (!SWIG_IsOK(ecode2)) {
52706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52707 }
52708 arg2 = static_cast< int >(val2);
52709 {
52710 PyThreadState* __tstate = wxPyBeginAllowThreads();
52711 (arg1)->SetRow(arg2);
52712 wxPyEndAllowThreads(__tstate);
52713 if (PyErr_Occurred()) SWIG_fail;
52714 }
52715 resultobj = SWIG_Py_Void();
52716 return resultobj;
52717fail:
52718 return NULL;
52719}
52720
52721
52722SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52723 PyObject *resultobj = 0;
52724 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52725 int arg2 ;
52726 void *argp1 = 0 ;
52727 int res1 = 0 ;
52728 int val2 ;
52729 int ecode2 = 0 ;
52730 PyObject * obj0 = 0 ;
52731 PyObject * obj1 = 0 ;
52732 char * kwnames[] = {
52733 (char *) "self",(char *) "col", NULL
52734 };
52735
52736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52738 if (!SWIG_IsOK(res1)) {
52739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52740 }
52741 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52742 ecode2 = SWIG_AsVal_int(obj1, &val2);
52743 if (!SWIG_IsOK(ecode2)) {
52744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52745 }
52746 arg2 = static_cast< int >(val2);
52747 {
52748 PyThreadState* __tstate = wxPyBeginAllowThreads();
52749 (arg1)->SetCol(arg2);
52750 wxPyEndAllowThreads(__tstate);
52751 if (PyErr_Occurred()) SWIG_fail;
52752 }
52753 resultobj = SWIG_Py_Void();
52754 return resultobj;
52755fail:
52756 return NULL;
52757}
52758
52759
52760SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52761 PyObject *resultobj = 0;
52762 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
e9d6f3a4 52763 PyObject *arg2 = (PyObject *) 0 ;
1bd55598
RD
52764 bool result;
52765 void *argp1 = 0 ;
52766 int res1 = 0 ;
1bd55598
RD
52767 PyObject * obj0 = 0 ;
52768 PyObject * obj1 = 0 ;
52769 char * kwnames[] = {
52770 (char *) "self",(char *) "other", NULL
52771 };
52772
52773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52775 if (!SWIG_IsOK(res1)) {
52776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52777 }
52778 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
e9d6f3a4 52779 arg2 = obj1;
1bd55598 52780 {
e9d6f3a4 52781 result = (bool)wxGBPosition___eq__(arg1,arg2);
1bd55598
RD
52782 if (PyErr_Occurred()) SWIG_fail;
52783 }
52784 {
52785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52786 }
52787 return resultobj;
52788fail:
52789 return NULL;
52790}
52791
52792
52793SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52794 PyObject *resultobj = 0;
52795 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
e9d6f3a4 52796 PyObject *arg2 = (PyObject *) 0 ;
1bd55598
RD
52797 bool result;
52798 void *argp1 = 0 ;
52799 int res1 = 0 ;
1bd55598
RD
52800 PyObject * obj0 = 0 ;
52801 PyObject * obj1 = 0 ;
52802 char * kwnames[] = {
52803 (char *) "self",(char *) "other", NULL
52804 };
52805
52806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52808 if (!SWIG_IsOK(res1)) {
52809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52810 }
52811 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
e9d6f3a4 52812 arg2 = obj1;
1bd55598 52813 {
e9d6f3a4 52814 result = (bool)wxGBPosition___ne__(arg1,arg2);
1bd55598
RD
52815 if (PyErr_Occurred()) SWIG_fail;
52816 }
52817 {
52818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52819 }
52820 return resultobj;
52821fail:
52822 return NULL;
52823}
52824
52825
52826SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52827 PyObject *resultobj = 0;
52828 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52829 int arg2 = (int) 0 ;
52830 int arg3 = (int) 0 ;
52831 void *argp1 = 0 ;
52832 int res1 = 0 ;
52833 int val2 ;
52834 int ecode2 = 0 ;
52835 int val3 ;
52836 int ecode3 = 0 ;
52837 PyObject * obj0 = 0 ;
52838 PyObject * obj1 = 0 ;
52839 PyObject * obj2 = 0 ;
52840 char * kwnames[] = {
52841 (char *) "self",(char *) "row",(char *) "col", NULL
52842 };
52843
52844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52846 if (!SWIG_IsOK(res1)) {
52847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52848 }
52849 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52850 if (obj1) {
52851 ecode2 = SWIG_AsVal_int(obj1, &val2);
52852 if (!SWIG_IsOK(ecode2)) {
52853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52854 }
52855 arg2 = static_cast< int >(val2);
52856 }
52857 if (obj2) {
52858 ecode3 = SWIG_AsVal_int(obj2, &val3);
52859 if (!SWIG_IsOK(ecode3)) {
52860 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52861 }
52862 arg3 = static_cast< int >(val3);
52863 }
52864 {
52865 PyThreadState* __tstate = wxPyBeginAllowThreads();
52866 wxGBPosition_Set(arg1,arg2,arg3);
52867 wxPyEndAllowThreads(__tstate);
52868 if (PyErr_Occurred()) SWIG_fail;
52869 }
52870 resultobj = SWIG_Py_Void();
52871 return resultobj;
52872fail:
52873 return NULL;
d55e5bfc
RD
52874}
52875
52876
1bd55598
RD
52877SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52878 PyObject *resultobj = 0;
52879 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52880 PyObject *result = 0 ;
52881 void *argp1 = 0 ;
52882 int res1 = 0 ;
52883 PyObject *swig_obj[1] ;
52884
52885 if (!args) SWIG_fail;
52886 swig_obj[0] = args;
52887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52888 if (!SWIG_IsOK(res1)) {
52889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52890 }
52891 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52892 {
52893 PyThreadState* __tstate = wxPyBeginAllowThreads();
52894 result = (PyObject *)wxGBPosition_Get(arg1);
52895 wxPyEndAllowThreads(__tstate);
52896 if (PyErr_Occurred()) SWIG_fail;
52897 }
52898 resultobj = result;
52899 return resultobj;
52900fail:
52901 return NULL;
d55e5bfc
RD
52902}
52903
52904
1bd55598
RD
52905SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52906 PyObject *obj;
52907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52908 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52909 return SWIG_Py_Void();
d55e5bfc
RD
52910}
52911
1bd55598
RD
52912SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52913 return SWIG_Python_InitShadowInstance(args);
52914}
d55e5bfc 52915
1bd55598
RD
52916SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52917 PyObject *resultobj = 0;
52918 int arg1 = (int) 1 ;
52919 int arg2 = (int) 1 ;
52920 wxGBSpan *result = 0 ;
52921 int val1 ;
52922 int ecode1 = 0 ;
52923 int val2 ;
52924 int ecode2 = 0 ;
52925 PyObject * obj0 = 0 ;
52926 PyObject * obj1 = 0 ;
52927 char * kwnames[] = {
52928 (char *) "rowspan",(char *) "colspan", NULL
52929 };
52930
52931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52932 if (obj0) {
52933 ecode1 = SWIG_AsVal_int(obj0, &val1);
52934 if (!SWIG_IsOK(ecode1)) {
52935 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52936 }
52937 arg1 = static_cast< int >(val1);
52938 }
52939 if (obj1) {
52940 ecode2 = SWIG_AsVal_int(obj1, &val2);
52941 if (!SWIG_IsOK(ecode2)) {
52942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52943 }
52944 arg2 = static_cast< int >(val2);
52945 }
52946 {
52947 PyThreadState* __tstate = wxPyBeginAllowThreads();
52948 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52949 wxPyEndAllowThreads(__tstate);
52950 if (PyErr_Occurred()) SWIG_fail;
52951 }
52952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52953 return resultobj;
52954fail:
52955 return NULL;
d55e5bfc
RD
52956}
52957
52958
1bd55598
RD
52959SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52960 PyObject *resultobj = 0;
52961 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52962 void *argp1 = 0 ;
52963 int res1 = 0 ;
52964 PyObject *swig_obj[1] ;
52965
52966 if (!args) SWIG_fail;
52967 swig_obj[0] = args;
52968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
52969 if (!SWIG_IsOK(res1)) {
52970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52971 }
52972 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52973 {
52974 PyThreadState* __tstate = wxPyBeginAllowThreads();
52975 delete arg1;
d55e5bfc 52976
1bd55598
RD
52977 wxPyEndAllowThreads(__tstate);
52978 if (PyErr_Occurred()) SWIG_fail;
52979 }
52980 resultobj = SWIG_Py_Void();
52981 return resultobj;
52982fail:
52983 return NULL;
d55e5bfc
RD
52984}
52985
52986
1bd55598
RD
52987SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52988 PyObject *resultobj = 0;
52989 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52990 int result;
52991 void *argp1 = 0 ;
52992 int res1 = 0 ;
52993 PyObject *swig_obj[1] ;
52994
52995 if (!args) SWIG_fail;
52996 swig_obj[0] = args;
52997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52998 if (!SWIG_IsOK(res1)) {
52999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53000 }
53001 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53002 {
53003 PyThreadState* __tstate = wxPyBeginAllowThreads();
53004 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
53005 wxPyEndAllowThreads(__tstate);
53006 if (PyErr_Occurred()) SWIG_fail;
53007 }
53008 resultobj = SWIG_From_int(static_cast< int >(result));
53009 return resultobj;
53010fail:
53011 return NULL;
d55e5bfc
RD
53012}
53013
53014
1bd55598
RD
53015SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53016 PyObject *resultobj = 0;
53017 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53018 int result;
53019 void *argp1 = 0 ;
53020 int res1 = 0 ;
53021 PyObject *swig_obj[1] ;
53022
53023 if (!args) SWIG_fail;
53024 swig_obj[0] = args;
53025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53026 if (!SWIG_IsOK(res1)) {
53027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53028 }
53029 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53030 {
53031 PyThreadState* __tstate = wxPyBeginAllowThreads();
53032 result = (int)((wxGBSpan const *)arg1)->GetColspan();
53033 wxPyEndAllowThreads(__tstate);
53034 if (PyErr_Occurred()) SWIG_fail;
53035 }
53036 resultobj = SWIG_From_int(static_cast< int >(result));
53037 return resultobj;
53038fail:
53039 return NULL;
53040}
53041
53042
53043SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53044 PyObject *resultobj = 0;
53045 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53046 int arg2 ;
53047 void *argp1 = 0 ;
53048 int res1 = 0 ;
53049 int val2 ;
53050 int ecode2 = 0 ;
53051 PyObject * obj0 = 0 ;
53052 PyObject * obj1 = 0 ;
53053 char * kwnames[] = {
53054 (char *) "self",(char *) "rowspan", NULL
53055 };
53056
53057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
53058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53059 if (!SWIG_IsOK(res1)) {
53060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53061 }
53062 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53063 ecode2 = SWIG_AsVal_int(obj1, &val2);
53064 if (!SWIG_IsOK(ecode2)) {
53065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
53066 }
53067 arg2 = static_cast< int >(val2);
53068 {
53069 PyThreadState* __tstate = wxPyBeginAllowThreads();
53070 (arg1)->SetRowspan(arg2);
53071 wxPyEndAllowThreads(__tstate);
53072 if (PyErr_Occurred()) SWIG_fail;
53073 }
53074 resultobj = SWIG_Py_Void();
53075 return resultobj;
53076fail:
53077 return NULL;
53078}
53079
53080
53081SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53082 PyObject *resultobj = 0;
53083 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53084 int arg2 ;
53085 void *argp1 = 0 ;
53086 int res1 = 0 ;
53087 int val2 ;
53088 int ecode2 = 0 ;
53089 PyObject * obj0 = 0 ;
53090 PyObject * obj1 = 0 ;
53091 char * kwnames[] = {
53092 (char *) "self",(char *) "colspan", NULL
53093 };
53094
53095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53097 if (!SWIG_IsOK(res1)) {
53098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53099 }
53100 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53101 ecode2 = SWIG_AsVal_int(obj1, &val2);
53102 if (!SWIG_IsOK(ecode2)) {
53103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53104 }
53105 arg2 = static_cast< int >(val2);
53106 {
53107 PyThreadState* __tstate = wxPyBeginAllowThreads();
53108 (arg1)->SetColspan(arg2);
53109 wxPyEndAllowThreads(__tstate);
53110 if (PyErr_Occurred()) SWIG_fail;
53111 }
53112 resultobj = SWIG_Py_Void();
53113 return resultobj;
53114fail:
53115 return NULL;
53116}
53117
53118
53119SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53120 PyObject *resultobj = 0;
53121 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
e9d6f3a4 53122 PyObject *arg2 = (PyObject *) 0 ;
1bd55598
RD
53123 bool result;
53124 void *argp1 = 0 ;
53125 int res1 = 0 ;
1bd55598
RD
53126 PyObject * obj0 = 0 ;
53127 PyObject * obj1 = 0 ;
53128 char * kwnames[] = {
53129 (char *) "self",(char *) "other", NULL
53130 };
53131
53132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53134 if (!SWIG_IsOK(res1)) {
53135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53136 }
53137 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
e9d6f3a4 53138 arg2 = obj1;
1bd55598 53139 {
e9d6f3a4 53140 result = (bool)wxGBSpan___eq__(arg1,arg2);
1bd55598
RD
53141 if (PyErr_Occurred()) SWIG_fail;
53142 }
53143 {
53144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53145 }
53146 return resultobj;
53147fail:
53148 return NULL;
53149}
53150
53151
53152SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53153 PyObject *resultobj = 0;
53154 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
e9d6f3a4 53155 PyObject *arg2 = (PyObject *) 0 ;
1bd55598
RD
53156 bool result;
53157 void *argp1 = 0 ;
53158 int res1 = 0 ;
1bd55598
RD
53159 PyObject * obj0 = 0 ;
53160 PyObject * obj1 = 0 ;
53161 char * kwnames[] = {
53162 (char *) "self",(char *) "other", NULL
53163 };
53164
53165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53167 if (!SWIG_IsOK(res1)) {
53168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53169 }
53170 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
e9d6f3a4 53171 arg2 = obj1;
1bd55598 53172 {
e9d6f3a4 53173 result = (bool)wxGBSpan___ne__(arg1,arg2);
1bd55598
RD
53174 if (PyErr_Occurred()) SWIG_fail;
53175 }
53176 {
53177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53178 }
53179 return resultobj;
53180fail:
53181 return NULL;
53182}
53183
53184
53185SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53186 PyObject *resultobj = 0;
53187 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53188 int arg2 = (int) 1 ;
53189 int arg3 = (int) 1 ;
53190 void *argp1 = 0 ;
53191 int res1 = 0 ;
53192 int val2 ;
53193 int ecode2 = 0 ;
53194 int val3 ;
53195 int ecode3 = 0 ;
53196 PyObject * obj0 = 0 ;
53197 PyObject * obj1 = 0 ;
53198 PyObject * obj2 = 0 ;
53199 char * kwnames[] = {
53200 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53201 };
53202
53203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53205 if (!SWIG_IsOK(res1)) {
53206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53207 }
53208 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53209 if (obj1) {
53210 ecode2 = SWIG_AsVal_int(obj1, &val2);
53211 if (!SWIG_IsOK(ecode2)) {
53212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53213 }
53214 arg2 = static_cast< int >(val2);
53215 }
53216 if (obj2) {
53217 ecode3 = SWIG_AsVal_int(obj2, &val3);
53218 if (!SWIG_IsOK(ecode3)) {
53219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53220 }
53221 arg3 = static_cast< int >(val3);
53222 }
53223 {
53224 PyThreadState* __tstate = wxPyBeginAllowThreads();
53225 wxGBSpan_Set(arg1,arg2,arg3);
53226 wxPyEndAllowThreads(__tstate);
53227 if (PyErr_Occurred()) SWIG_fail;
53228 }
53229 resultobj = SWIG_Py_Void();
53230 return resultobj;
53231fail:
53232 return NULL;
d55e5bfc
RD
53233}
53234
53235
1bd55598
RD
53236SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53237 PyObject *resultobj = 0;
53238 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53239 PyObject *result = 0 ;
53240 void *argp1 = 0 ;
53241 int res1 = 0 ;
53242 PyObject *swig_obj[1] ;
53243
53244 if (!args) SWIG_fail;
53245 swig_obj[0] = args;
53246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53247 if (!SWIG_IsOK(res1)) {
53248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53249 }
53250 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53251 {
53252 PyThreadState* __tstate = wxPyBeginAllowThreads();
53253 result = (PyObject *)wxGBSpan_Get(arg1);
53254 wxPyEndAllowThreads(__tstate);
53255 if (PyErr_Occurred()) SWIG_fail;
53256 }
53257 resultobj = result;
53258 return resultobj;
53259fail:
53260 return NULL;
d55e5bfc
RD
53261}
53262
53263
1bd55598
RD
53264SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53265 PyObject *obj;
53266 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53267 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53268 return SWIG_Py_Void();
d55e5bfc
RD
53269}
53270
1bd55598
RD
53271SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53272 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
53273}
53274
1bd55598
RD
53275SWIGINTERN int DefaultSpan_set(PyObject *) {
53276 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53277 return 1;
d55e5bfc
RD
53278}
53279
53280
1bd55598
RD
53281SWIGINTERN PyObject *DefaultSpan_get(void) {
53282 PyObject *pyobj = 0;
53283
53284 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53285 return pyobj;
d55e5bfc
RD
53286}
53287
53288
1bd55598
RD
53289SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53290 PyObject *resultobj = 0;
53291 wxGBSizerItem *result = 0 ;
53292
53293 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53294 {
53295 PyThreadState* __tstate = wxPyBeginAllowThreads();
53296 result = (wxGBSizerItem *)new wxGBSizerItem();
53297 wxPyEndAllowThreads(__tstate);
53298 if (PyErr_Occurred()) SWIG_fail;
53299 }
53300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53301 return resultobj;
53302fail:
53303 return NULL;
d55e5bfc
RD
53304}
53305
53306
1bd55598
RD
53307SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53308 PyObject *resultobj = 0;
53309 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53310 void *argp1 = 0 ;
53311 int res1 = 0 ;
53312 PyObject *swig_obj[1] ;
53313
53314 if (!args) SWIG_fail;
53315 swig_obj[0] = args;
53316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53317 if (!SWIG_IsOK(res1)) {
53318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53319 }
53320 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53321 {
53322 PyThreadState* __tstate = wxPyBeginAllowThreads();
53323 delete arg1;
d55e5bfc 53324
1bd55598
RD
53325 wxPyEndAllowThreads(__tstate);
53326 if (PyErr_Occurred()) SWIG_fail;
53327 }
53328 resultobj = SWIG_Py_Void();
53329 return resultobj;
53330fail:
53331 return NULL;
53332}
53333
53334
53335SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53336 PyObject *resultobj = 0;
53337 wxWindow *arg1 = (wxWindow *) 0 ;
53338 wxGBPosition *arg2 = 0 ;
53339 wxGBSpan *arg3 = 0 ;
53340 int arg4 ;
53341 int arg5 ;
53342 PyObject *arg6 = (PyObject *) NULL ;
53343 wxGBSizerItem *result = 0 ;
53344 void *argp1 = 0 ;
53345 int res1 = 0 ;
53346 wxGBPosition temp2 ;
53347 wxGBSpan temp3 ;
53348 int val4 ;
53349 int ecode4 = 0 ;
53350 int val5 ;
53351 int ecode5 = 0 ;
53352 PyObject * obj0 = 0 ;
53353 PyObject * obj1 = 0 ;
53354 PyObject * obj2 = 0 ;
53355 PyObject * obj3 = 0 ;
53356 PyObject * obj4 = 0 ;
53357 PyObject * obj5 = 0 ;
53358 char * kwnames[] = {
53359 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53360 };
53361
53362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53364 if (!SWIG_IsOK(res1)) {
53365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53366 }
53367 arg1 = reinterpret_cast< wxWindow * >(argp1);
53368 {
53369 arg2 = &temp2;
53370 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53371 }
53372 {
53373 arg3 = &temp3;
53374 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53375 }
53376 ecode4 = SWIG_AsVal_int(obj3, &val4);
53377 if (!SWIG_IsOK(ecode4)) {
53378 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53379 }
53380 arg4 = static_cast< int >(val4);
53381 ecode5 = SWIG_AsVal_int(obj4, &val5);
53382 if (!SWIG_IsOK(ecode5)) {
53383 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53384 }
53385 arg5 = static_cast< int >(val5);
53386 if (obj5) {
53387 arg6 = obj5;
53388 }
53389 {
53390 PyThreadState* __tstate = wxPyBeginAllowThreads();
53391 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53392 wxPyEndAllowThreads(__tstate);
53393 if (PyErr_Occurred()) SWIG_fail;
53394 }
53395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53396 return resultobj;
53397fail:
53398 return NULL;
53399}
53400
53401
53402SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53403 PyObject *resultobj = 0;
53404 wxSizer *arg1 = (wxSizer *) 0 ;
53405 wxGBPosition *arg2 = 0 ;
53406 wxGBSpan *arg3 = 0 ;
53407 int arg4 ;
53408 int arg5 ;
53409 PyObject *arg6 = (PyObject *) NULL ;
53410 wxGBSizerItem *result = 0 ;
53411 int res1 = 0 ;
53412 wxGBPosition temp2 ;
53413 wxGBSpan temp3 ;
53414 int val4 ;
53415 int ecode4 = 0 ;
53416 int val5 ;
53417 int ecode5 = 0 ;
53418 PyObject * obj0 = 0 ;
53419 PyObject * obj1 = 0 ;
53420 PyObject * obj2 = 0 ;
53421 PyObject * obj3 = 0 ;
53422 PyObject * obj4 = 0 ;
53423 PyObject * obj5 = 0 ;
53424 char * kwnames[] = {
53425 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53426 };
53427
53428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53429 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53430 if (!SWIG_IsOK(res1)) {
53431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53432 }
53433 {
53434 arg2 = &temp2;
53435 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53436 }
53437 {
53438 arg3 = &temp3;
53439 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53440 }
53441 ecode4 = SWIG_AsVal_int(obj3, &val4);
53442 if (!SWIG_IsOK(ecode4)) {
53443 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53444 }
53445 arg4 = static_cast< int >(val4);
53446 ecode5 = SWIG_AsVal_int(obj4, &val5);
53447 if (!SWIG_IsOK(ecode5)) {
53448 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53449 }
53450 arg5 = static_cast< int >(val5);
53451 if (obj5) {
53452 arg6 = obj5;
53453 }
53454 {
53455 PyThreadState* __tstate = wxPyBeginAllowThreads();
53456 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53457 wxPyEndAllowThreads(__tstate);
53458 if (PyErr_Occurred()) SWIG_fail;
53459 }
53460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53461 return resultobj;
53462fail:
53463 return NULL;
53464}
53465
53466
53467SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53468 PyObject *resultobj = 0;
53469 int arg1 ;
53470 int arg2 ;
53471 wxGBPosition *arg3 = 0 ;
53472 wxGBSpan *arg4 = 0 ;
53473 int arg5 ;
53474 int arg6 ;
53475 PyObject *arg7 = (PyObject *) NULL ;
53476 wxGBSizerItem *result = 0 ;
53477 int val1 ;
53478 int ecode1 = 0 ;
53479 int val2 ;
53480 int ecode2 = 0 ;
53481 wxGBPosition temp3 ;
53482 wxGBSpan temp4 ;
53483 int val5 ;
53484 int ecode5 = 0 ;
53485 int val6 ;
53486 int ecode6 = 0 ;
53487 PyObject * obj0 = 0 ;
53488 PyObject * obj1 = 0 ;
53489 PyObject * obj2 = 0 ;
53490 PyObject * obj3 = 0 ;
53491 PyObject * obj4 = 0 ;
53492 PyObject * obj5 = 0 ;
53493 PyObject * obj6 = 0 ;
53494 char * kwnames[] = {
53495 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53496 };
53497
53498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53499 ecode1 = SWIG_AsVal_int(obj0, &val1);
53500 if (!SWIG_IsOK(ecode1)) {
53501 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53502 }
53503 arg1 = static_cast< int >(val1);
53504 ecode2 = SWIG_AsVal_int(obj1, &val2);
53505 if (!SWIG_IsOK(ecode2)) {
53506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53507 }
53508 arg2 = static_cast< int >(val2);
53509 {
53510 arg3 = &temp3;
53511 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53512 }
53513 {
53514 arg4 = &temp4;
53515 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53516 }
53517 ecode5 = SWIG_AsVal_int(obj4, &val5);
53518 if (!SWIG_IsOK(ecode5)) {
53519 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53520 }
53521 arg5 = static_cast< int >(val5);
53522 ecode6 = SWIG_AsVal_int(obj5, &val6);
53523 if (!SWIG_IsOK(ecode6)) {
53524 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53525 }
53526 arg6 = static_cast< int >(val6);
53527 if (obj6) {
53528 arg7 = obj6;
53529 }
53530 {
53531 PyThreadState* __tstate = wxPyBeginAllowThreads();
53532 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53533 wxPyEndAllowThreads(__tstate);
53534 if (PyErr_Occurred()) SWIG_fail;
53535 }
53536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53537 return resultobj;
53538fail:
53539 return NULL;
d55e5bfc
RD
53540}
53541
53542
1bd55598
RD
53543SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53544 PyObject *resultobj = 0;
53545 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53546 wxGBPosition result;
53547 void *argp1 = 0 ;
53548 int res1 = 0 ;
53549 PyObject *swig_obj[1] ;
53550
53551 if (!args) SWIG_fail;
53552 swig_obj[0] = args;
53553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53554 if (!SWIG_IsOK(res1)) {
53555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53556 }
53557 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53558 {
53559 PyThreadState* __tstate = wxPyBeginAllowThreads();
53560 result = ((wxGBSizerItem const *)arg1)->GetPos();
53561 wxPyEndAllowThreads(__tstate);
53562 if (PyErr_Occurred()) SWIG_fail;
53563 }
53564 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53565 return resultobj;
53566fail:
53567 return NULL;
d55e5bfc
RD
53568}
53569
53570
1bd55598
RD
53571SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53572 PyObject *resultobj = 0;
53573 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53574 wxGBSpan result;
53575 void *argp1 = 0 ;
53576 int res1 = 0 ;
53577 PyObject *swig_obj[1] ;
53578
53579 if (!args) SWIG_fail;
53580 swig_obj[0] = args;
53581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53582 if (!SWIG_IsOK(res1)) {
53583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53584 }
53585 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53586 {
53587 PyThreadState* __tstate = wxPyBeginAllowThreads();
53588 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53589 wxPyEndAllowThreads(__tstate);
53590 if (PyErr_Occurred()) SWIG_fail;
53591 }
53592 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53593 return resultobj;
53594fail:
53595 return NULL;
53596}
53597
53598
53599SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53600 PyObject *resultobj = 0;
53601 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53602 wxGBPosition *arg2 = 0 ;
53603 bool result;
53604 void *argp1 = 0 ;
53605 int res1 = 0 ;
53606 wxGBPosition temp2 ;
53607 PyObject * obj0 = 0 ;
53608 PyObject * obj1 = 0 ;
53609 char * kwnames[] = {
53610 (char *) "self",(char *) "pos", NULL
53611 };
53612
53613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53615 if (!SWIG_IsOK(res1)) {
53616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53617 }
53618 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53619 {
53620 arg2 = &temp2;
53621 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53622 }
53623 {
53624 PyThreadState* __tstate = wxPyBeginAllowThreads();
53625 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53626 wxPyEndAllowThreads(__tstate);
53627 if (PyErr_Occurred()) SWIG_fail;
53628 }
53629 {
53630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53631 }
53632 return resultobj;
53633fail:
53634 return NULL;
53635}
53636
53637
53638SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53639 PyObject *resultobj = 0;
53640 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53641 wxGBSpan *arg2 = 0 ;
53642 bool result;
53643 void *argp1 = 0 ;
53644 int res1 = 0 ;
53645 wxGBSpan temp2 ;
53646 PyObject * obj0 = 0 ;
53647 PyObject * obj1 = 0 ;
53648 char * kwnames[] = {
53649 (char *) "self",(char *) "span", NULL
53650 };
53651
53652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53654 if (!SWIG_IsOK(res1)) {
53655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53656 }
53657 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53658 {
53659 arg2 = &temp2;
53660 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53661 }
53662 {
53663 PyThreadState* __tstate = wxPyBeginAllowThreads();
53664 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53665 wxPyEndAllowThreads(__tstate);
53666 if (PyErr_Occurred()) SWIG_fail;
53667 }
53668 {
53669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53670 }
53671 return resultobj;
53672fail:
53673 return NULL;
53674}
53675
53676
53677SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53678 PyObject *resultobj = 0;
53679 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53680 wxGBSizerItem *arg2 = 0 ;
53681 bool result;
53682 void *argp1 = 0 ;
53683 int res1 = 0 ;
53684 void *argp2 = 0 ;
53685 int res2 = 0 ;
53686 PyObject * obj0 = 0 ;
53687 PyObject * obj1 = 0 ;
53688 char * kwnames[] = {
53689 (char *) "self",(char *) "other", NULL
53690 };
53691
53692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53694 if (!SWIG_IsOK(res1)) {
53695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53696 }
53697 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53698 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53699 if (!SWIG_IsOK(res2)) {
53700 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53701 }
53702 if (!argp2) {
53703 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53704 }
53705 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53706 {
53707 PyThreadState* __tstate = wxPyBeginAllowThreads();
53708 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53709 wxPyEndAllowThreads(__tstate);
53710 if (PyErr_Occurred()) SWIG_fail;
53711 }
53712 {
53713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53714 }
53715 return resultobj;
53716fail:
53717 return NULL;
53718}
53719
53720
53721SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53722 PyObject *resultobj = 0;
53723 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53724 wxGBPosition *arg2 = 0 ;
53725 wxGBSpan *arg3 = 0 ;
53726 bool result;
53727 void *argp1 = 0 ;
53728 int res1 = 0 ;
53729 wxGBPosition temp2 ;
53730 wxGBSpan temp3 ;
53731 PyObject * obj0 = 0 ;
53732 PyObject * obj1 = 0 ;
53733 PyObject * obj2 = 0 ;
53734 char * kwnames[] = {
53735 (char *) "self",(char *) "pos",(char *) "span", NULL
53736 };
53737
53738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53740 if (!SWIG_IsOK(res1)) {
53741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53742 }
53743 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53744 {
53745 arg2 = &temp2;
53746 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53747 }
53748 {
53749 arg3 = &temp3;
53750 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53751 }
53752 {
53753 PyThreadState* __tstate = wxPyBeginAllowThreads();
53754 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53755 wxPyEndAllowThreads(__tstate);
53756 if (PyErr_Occurred()) SWIG_fail;
53757 }
53758 {
53759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53760 }
53761 return resultobj;
53762fail:
53763 return NULL;
d55e5bfc
RD
53764}
53765
53766
1bd55598
RD
53767SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53768 PyObject *resultobj = 0;
53769 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53770 wxGBPosition result;
53771 void *argp1 = 0 ;
53772 int res1 = 0 ;
53773 PyObject *swig_obj[1] ;
53774
53775 if (!args) SWIG_fail;
53776 swig_obj[0] = args;
53777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53778 if (!SWIG_IsOK(res1)) {
53779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53780 }
53781 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53782 {
53783 PyThreadState* __tstate = wxPyBeginAllowThreads();
53784 result = wxGBSizerItem_GetEndPos(arg1);
53785 wxPyEndAllowThreads(__tstate);
53786 if (PyErr_Occurred()) SWIG_fail;
53787 }
53788 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53789 return resultobj;
53790fail:
53791 return NULL;
908b74cd
RD
53792}
53793
53794
1bd55598
RD
53795SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53796 PyObject *resultobj = 0;
53797 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53798 wxGridBagSizer *result = 0 ;
53799 void *argp1 = 0 ;
53800 int res1 = 0 ;
53801 PyObject *swig_obj[1] ;
53802
53803 if (!args) SWIG_fail;
53804 swig_obj[0] = args;
53805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53806 if (!SWIG_IsOK(res1)) {
53807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53808 }
53809 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53810 {
53811 PyThreadState* __tstate = wxPyBeginAllowThreads();
53812 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53813 wxPyEndAllowThreads(__tstate);
53814 if (PyErr_Occurred()) SWIG_fail;
53815 }
53816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53817 return resultobj;
53818fail:
53819 return NULL;
53820}
53821
53822
53823SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53824 PyObject *resultobj = 0;
53825 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53826 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53827 void *argp1 = 0 ;
53828 int res1 = 0 ;
53829 void *argp2 = 0 ;
53830 int res2 = 0 ;
53831 PyObject * obj0 = 0 ;
53832 PyObject * obj1 = 0 ;
53833 char * kwnames[] = {
53834 (char *) "self",(char *) "sizer", NULL
53835 };
53836
53837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53839 if (!SWIG_IsOK(res1)) {
53840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53841 }
53842 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53843 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53844 if (!SWIG_IsOK(res2)) {
53845 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53846 }
53847 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53848 {
53849 PyThreadState* __tstate = wxPyBeginAllowThreads();
53850 (arg1)->SetGBSizer(arg2);
53851 wxPyEndAllowThreads(__tstate);
53852 if (PyErr_Occurred()) SWIG_fail;
53853 }
53854 resultobj = SWIG_Py_Void();
53855 return resultobj;
53856fail:
53857 return NULL;
bf26d883
RD
53858}
53859
53860
1bd55598
RD
53861SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53862 PyObject *obj;
53863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53864 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53865 return SWIG_Py_Void();
bf26d883
RD
53866}
53867
1bd55598
RD
53868SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53869 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
53870}
53871
1bd55598
RD
53872SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53873 PyObject *resultobj = 0;
53874 int arg1 = (int) 0 ;
53875 int arg2 = (int) 0 ;
53876 wxGridBagSizer *result = 0 ;
53877 int val1 ;
53878 int ecode1 = 0 ;
53879 int val2 ;
53880 int ecode2 = 0 ;
53881 PyObject * obj0 = 0 ;
53882 PyObject * obj1 = 0 ;
53883 char * kwnames[] = {
53884 (char *) "vgap",(char *) "hgap", NULL
53885 };
53886
53887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53888 if (obj0) {
53889 ecode1 = SWIG_AsVal_int(obj0, &val1);
53890 if (!SWIG_IsOK(ecode1)) {
53891 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53892 }
53893 arg1 = static_cast< int >(val1);
53894 }
53895 if (obj1) {
53896 ecode2 = SWIG_AsVal_int(obj1, &val2);
53897 if (!SWIG_IsOK(ecode2)) {
53898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53899 }
53900 arg2 = static_cast< int >(val2);
53901 }
53902 {
53903 PyThreadState* __tstate = wxPyBeginAllowThreads();
53904 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53905 wxPyEndAllowThreads(__tstate);
53906 if (PyErr_Occurred()) SWIG_fail;
53907 }
53908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53909 return resultobj;
53910fail:
53911 return NULL;
53912}
53913
53914
53915SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53916 PyObject *resultobj = 0;
53917 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53918 PyObject *arg2 = (PyObject *) 0 ;
53919 wxGBPosition *arg3 = 0 ;
53920 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53921 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53922 int arg5 = (int) 0 ;
53923 int arg6 = (int) 0 ;
53924 PyObject *arg7 = (PyObject *) NULL ;
53925 wxGBSizerItem *result = 0 ;
53926 void *argp1 = 0 ;
53927 int res1 = 0 ;
53928 wxGBPosition temp3 ;
53929 wxGBSpan temp4 ;
53930 int val5 ;
53931 int ecode5 = 0 ;
53932 int val6 ;
53933 int ecode6 = 0 ;
53934 PyObject * obj0 = 0 ;
53935 PyObject * obj1 = 0 ;
53936 PyObject * obj2 = 0 ;
53937 PyObject * obj3 = 0 ;
53938 PyObject * obj4 = 0 ;
53939 PyObject * obj5 = 0 ;
53940 PyObject * obj6 = 0 ;
53941 char * kwnames[] = {
53942 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53943 };
53944
53945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53947 if (!SWIG_IsOK(res1)) {
53948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53949 }
53950 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53951 arg2 = obj1;
53952 {
53953 arg3 = &temp3;
53954 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53955 }
53956 if (obj3) {
d55e5bfc 53957 {
1bd55598
RD
53958 arg4 = &temp4;
53959 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
d55e5bfc 53960 }
1bd55598
RD
53961 }
53962 if (obj4) {
53963 ecode5 = SWIG_AsVal_int(obj4, &val5);
53964 if (!SWIG_IsOK(ecode5)) {
53965 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
53966 }
53967 arg5 = static_cast< int >(val5);
53968 }
53969 if (obj5) {
53970 ecode6 = SWIG_AsVal_int(obj5, &val6);
53971 if (!SWIG_IsOK(ecode6)) {
53972 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
53973 }
53974 arg6 = static_cast< int >(val6);
53975 }
53976 if (obj6) {
53977 arg7 = obj6;
53978 }
53979 {
53980 PyThreadState* __tstate = wxPyBeginAllowThreads();
53981 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53982 wxPyEndAllowThreads(__tstate);
53983 if (PyErr_Occurred()) SWIG_fail;
53984 }
53985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53986 return resultobj;
53987fail:
53988 return NULL;
53989}
53990
53991
53992SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53993 PyObject *resultobj = 0;
53994 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53995 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
53996 wxGBSizerItem *result = 0 ;
53997 void *argp1 = 0 ;
53998 int res1 = 0 ;
53999 int res2 = 0 ;
54000 PyObject * obj0 = 0 ;
54001 PyObject * obj1 = 0 ;
54002 char * kwnames[] = {
54003 (char *) "self",(char *) "item", NULL
54004 };
54005
54006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
54007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54008 if (!SWIG_IsOK(res1)) {
54009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54010 }
54011 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54012 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
54013 if (!SWIG_IsOK(res2)) {
54014 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54015 }
54016 {
54017 PyThreadState* __tstate = wxPyBeginAllowThreads();
54018 result = (wxGBSizerItem *)(arg1)->Add(arg2);
54019 wxPyEndAllowThreads(__tstate);
54020 if (PyErr_Occurred()) SWIG_fail;
54021 }
54022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54023 return resultobj;
54024fail:
54025 return NULL;
54026}
54027
54028
54029SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54030 PyObject *resultobj = 0;
54031 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54032 int arg2 ;
54033 int arg3 ;
54034 wxSize result;
54035 void *argp1 = 0 ;
54036 int res1 = 0 ;
54037 int val2 ;
54038 int ecode2 = 0 ;
54039 int val3 ;
54040 int ecode3 = 0 ;
54041 PyObject * obj0 = 0 ;
54042 PyObject * obj1 = 0 ;
54043 PyObject * obj2 = 0 ;
54044 char * kwnames[] = {
54045 (char *) "self",(char *) "row",(char *) "col", NULL
54046 };
54047
54048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54050 if (!SWIG_IsOK(res1)) {
54051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54052 }
54053 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54054 ecode2 = SWIG_AsVal_int(obj1, &val2);
54055 if (!SWIG_IsOK(ecode2)) {
54056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
54057 }
54058 arg2 = static_cast< int >(val2);
54059 ecode3 = SWIG_AsVal_int(obj2, &val3);
54060 if (!SWIG_IsOK(ecode3)) {
54061 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
54062 }
54063 arg3 = static_cast< int >(val3);
54064 {
54065 PyThreadState* __tstate = wxPyBeginAllowThreads();
54066 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
54067 wxPyEndAllowThreads(__tstate);
54068 if (PyErr_Occurred()) SWIG_fail;
54069 }
54070 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54071 return resultobj;
54072fail:
54073 return NULL;
d55e5bfc
RD
54074}
54075
54076
1bd55598
RD
54077SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54078 PyObject *resultobj = 0;
54079 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54080 wxSize result;
54081 void *argp1 = 0 ;
54082 int res1 = 0 ;
54083 PyObject *swig_obj[1] ;
54084
54085 if (!args) SWIG_fail;
54086 swig_obj[0] = args;
54087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54088 if (!SWIG_IsOK(res1)) {
54089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54090 }
54091 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54092 {
54093 PyThreadState* __tstate = wxPyBeginAllowThreads();
54094 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54095 wxPyEndAllowThreads(__tstate);
54096 if (PyErr_Occurred()) SWIG_fail;
54097 }
54098 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54099 return resultobj;
54100fail:
54101 return NULL;
54102}
54103
54104
54105SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54106 PyObject *resultobj = 0;
54107 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54108 wxSize *arg2 = 0 ;
54109 void *argp1 = 0 ;
54110 int res1 = 0 ;
54111 wxSize temp2 ;
54112 PyObject * obj0 = 0 ;
54113 PyObject * obj1 = 0 ;
54114 char * kwnames[] = {
54115 (char *) "self",(char *) "sz", NULL
54116 };
54117
54118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54120 if (!SWIG_IsOK(res1)) {
54121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54122 }
54123 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54124 {
54125 arg2 = &temp2;
54126 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54127 }
54128 {
54129 PyThreadState* __tstate = wxPyBeginAllowThreads();
54130 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54131 wxPyEndAllowThreads(__tstate);
54132 if (PyErr_Occurred()) SWIG_fail;
54133 }
54134 resultobj = SWIG_Py_Void();
54135 return resultobj;
54136fail:
54137 return NULL;
54138}
54139
54140
54141SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54142 PyObject *resultobj = 0;
54143 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54144 wxWindow *arg2 = (wxWindow *) 0 ;
54145 wxGBPosition result;
54146 void *argp1 = 0 ;
54147 int res1 = 0 ;
54148 void *argp2 = 0 ;
54149 int res2 = 0 ;
54150
54151 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54153 if (!SWIG_IsOK(res1)) {
54154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54155 }
54156 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54157 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54158 if (!SWIG_IsOK(res2)) {
54159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54160 }
54161 arg2 = reinterpret_cast< wxWindow * >(argp2);
54162 {
54163 PyThreadState* __tstate = wxPyBeginAllowThreads();
54164 result = (arg1)->GetItemPosition(arg2);
54165 wxPyEndAllowThreads(__tstate);
54166 if (PyErr_Occurred()) SWIG_fail;
54167 }
54168 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54169 return resultobj;
54170fail:
54171 return NULL;
54172}
54173
54174
54175SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54176 PyObject *resultobj = 0;
54177 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54178 wxSizer *arg2 = (wxSizer *) 0 ;
54179 wxGBPosition result;
54180 void *argp1 = 0 ;
54181 int res1 = 0 ;
54182 void *argp2 = 0 ;
54183 int res2 = 0 ;
54184
54185 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54187 if (!SWIG_IsOK(res1)) {
54188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54189 }
54190 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54191 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54192 if (!SWIG_IsOK(res2)) {
54193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54194 }
54195 arg2 = reinterpret_cast< wxSizer * >(argp2);
54196 {
54197 PyThreadState* __tstate = wxPyBeginAllowThreads();
54198 result = (arg1)->GetItemPosition(arg2);
54199 wxPyEndAllowThreads(__tstate);
54200 if (PyErr_Occurred()) SWIG_fail;
54201 }
54202 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54203 return resultobj;
54204fail:
54205 return NULL;
54206}
54207
54208
54209SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54210 PyObject *resultobj = 0;
54211 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54212 size_t arg2 ;
54213 wxGBPosition result;
54214 void *argp1 = 0 ;
54215 int res1 = 0 ;
54216 size_t val2 ;
54217 int ecode2 = 0 ;
54218
54219 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54221 if (!SWIG_IsOK(res1)) {
54222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54223 }
54224 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54225 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54226 if (!SWIG_IsOK(ecode2)) {
54227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54228 }
54229 arg2 = static_cast< size_t >(val2);
54230 {
54231 PyThreadState* __tstate = wxPyBeginAllowThreads();
54232 result = (arg1)->GetItemPosition(arg2);
54233 wxPyEndAllowThreads(__tstate);
54234 if (PyErr_Occurred()) SWIG_fail;
54235 }
54236 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54237 return resultobj;
54238fail:
54239 return NULL;
d55e5bfc
RD
54240}
54241
54242
1bd55598
RD
54243SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54244 int argc;
54245 PyObject *argv[3];
54246
54247 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54248 --argc;
54249 if (argc == 2) {
54250 int _v = 0;
d55e5bfc 54251 {
1bd55598
RD
54252 void *vptr = 0;
54253 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54254 _v = SWIG_CheckState(res);
d55e5bfc 54255 }
1bd55598
RD
54256 if (!_v) goto check_1;
54257 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54258 }
54259check_1:
54260
54261 if (argc == 2) {
54262 int _v = 0;
d55e5bfc 54263 {
1bd55598
RD
54264 void *vptr = 0;
54265 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54266 _v = SWIG_CheckState(res);
d55e5bfc 54267 }
1bd55598
RD
54268 if (!_v) goto check_2;
54269 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54270 }
54271check_2:
54272
54273 if (argc == 2) {
54274 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54275 }
54276
54277fail:
54278 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54279 return NULL;
54280}
54281
54282
54283SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54284 PyObject *resultobj = 0;
54285 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54286 wxWindow *arg2 = (wxWindow *) 0 ;
54287 wxGBPosition *arg3 = 0 ;
54288 bool result;
54289 void *argp1 = 0 ;
54290 int res1 = 0 ;
54291 void *argp2 = 0 ;
54292 int res2 = 0 ;
54293 wxGBPosition temp3 ;
54294
54295 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54297 if (!SWIG_IsOK(res1)) {
54298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54299 }
54300 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54301 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54302 if (!SWIG_IsOK(res2)) {
54303 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54304 }
54305 arg2 = reinterpret_cast< wxWindow * >(argp2);
54306 {
54307 arg3 = &temp3;
54308 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54309 }
54310 {
54311 PyThreadState* __tstate = wxPyBeginAllowThreads();
54312 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54313 wxPyEndAllowThreads(__tstate);
54314 if (PyErr_Occurred()) SWIG_fail;
54315 }
54316 {
54317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54318 }
54319 return resultobj;
54320fail:
54321 return NULL;
54322}
54323
54324
54325SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54326 PyObject *resultobj = 0;
54327 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54328 wxSizer *arg2 = (wxSizer *) 0 ;
54329 wxGBPosition *arg3 = 0 ;
54330 bool result;
54331 void *argp1 = 0 ;
54332 int res1 = 0 ;
54333 void *argp2 = 0 ;
54334 int res2 = 0 ;
54335 wxGBPosition temp3 ;
54336
54337 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54339 if (!SWIG_IsOK(res1)) {
54340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54341 }
54342 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54343 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54344 if (!SWIG_IsOK(res2)) {
54345 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54346 }
54347 arg2 = reinterpret_cast< wxSizer * >(argp2);
54348 {
54349 arg3 = &temp3;
54350 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54351 }
54352 {
54353 PyThreadState* __tstate = wxPyBeginAllowThreads();
54354 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54355 wxPyEndAllowThreads(__tstate);
54356 if (PyErr_Occurred()) SWIG_fail;
54357 }
54358 {
54359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54360 }
54361 return resultobj;
54362fail:
54363 return NULL;
54364}
54365
54366
54367SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54368 PyObject *resultobj = 0;
54369 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54370 size_t arg2 ;
54371 wxGBPosition *arg3 = 0 ;
54372 bool result;
54373 void *argp1 = 0 ;
54374 int res1 = 0 ;
54375 size_t val2 ;
54376 int ecode2 = 0 ;
54377 wxGBPosition temp3 ;
54378
54379 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54381 if (!SWIG_IsOK(res1)) {
54382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54383 }
54384 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54385 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54386 if (!SWIG_IsOK(ecode2)) {
54387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54388 }
54389 arg2 = static_cast< size_t >(val2);
54390 {
54391 arg3 = &temp3;
54392 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54393 }
54394 {
54395 PyThreadState* __tstate = wxPyBeginAllowThreads();
54396 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54397 wxPyEndAllowThreads(__tstate);
54398 if (PyErr_Occurred()) SWIG_fail;
54399 }
54400 {
54401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54402 }
54403 return resultobj;
54404fail:
54405 return NULL;
d55e5bfc
RD
54406}
54407
54408
1bd55598
RD
54409SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54410 int argc;
54411 PyObject *argv[4];
54412
54413 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54414 --argc;
54415 if (argc == 3) {
54416 int _v = 0;
d55e5bfc 54417 {
1bd55598
RD
54418 void *vptr = 0;
54419 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54420 _v = SWIG_CheckState(res);
d55e5bfc 54421 }
1bd55598
RD
54422 if (!_v) goto check_1;
54423 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54424 }
54425check_1:
54426
54427 if (argc == 3) {
54428 int _v = 0;
d55e5bfc 54429 {
1bd55598
RD
54430 void *vptr = 0;
54431 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54432 _v = SWIG_CheckState(res);
d55e5bfc 54433 }
1bd55598
RD
54434 if (!_v) goto check_2;
54435 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54436 }
54437check_2:
54438
54439 if (argc == 3) {
54440 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54441 }
54442
54443fail:
54444 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54445 return NULL;
d55e5bfc
RD
54446}
54447
54448
1bd55598
RD
54449SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54450 PyObject *resultobj = 0;
54451 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54452 wxWindow *arg2 = (wxWindow *) 0 ;
54453 wxGBSpan result;
54454 void *argp1 = 0 ;
54455 int res1 = 0 ;
54456 void *argp2 = 0 ;
54457 int res2 = 0 ;
54458
54459 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54461 if (!SWIG_IsOK(res1)) {
54462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54463 }
54464 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54465 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54466 if (!SWIG_IsOK(res2)) {
54467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54468 }
54469 arg2 = reinterpret_cast< wxWindow * >(argp2);
54470 {
54471 PyThreadState* __tstate = wxPyBeginAllowThreads();
54472 result = (arg1)->GetItemSpan(arg2);
54473 wxPyEndAllowThreads(__tstate);
54474 if (PyErr_Occurred()) SWIG_fail;
54475 }
54476 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54477 return resultobj;
54478fail:
54479 return NULL;
54480}
54481
54482
54483SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54484 PyObject *resultobj = 0;
54485 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54486 wxSizer *arg2 = (wxSizer *) 0 ;
54487 wxGBSpan result;
54488 void *argp1 = 0 ;
54489 int res1 = 0 ;
54490 void *argp2 = 0 ;
54491 int res2 = 0 ;
54492
54493 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54495 if (!SWIG_IsOK(res1)) {
54496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54497 }
54498 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54499 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54500 if (!SWIG_IsOK(res2)) {
54501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54502 }
54503 arg2 = reinterpret_cast< wxSizer * >(argp2);
54504 {
54505 PyThreadState* __tstate = wxPyBeginAllowThreads();
54506 result = (arg1)->GetItemSpan(arg2);
54507 wxPyEndAllowThreads(__tstate);
54508 if (PyErr_Occurred()) SWIG_fail;
54509 }
54510 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54511 return resultobj;
54512fail:
54513 return NULL;
54514}
54515
54516
54517SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54518 PyObject *resultobj = 0;
54519 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54520 size_t arg2 ;
54521 wxGBSpan result;
54522 void *argp1 = 0 ;
54523 int res1 = 0 ;
54524 size_t val2 ;
54525 int ecode2 = 0 ;
54526
54527 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54529 if (!SWIG_IsOK(res1)) {
54530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54531 }
54532 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54533 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54534 if (!SWIG_IsOK(ecode2)) {
54535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54536 }
54537 arg2 = static_cast< size_t >(val2);
54538 {
54539 PyThreadState* __tstate = wxPyBeginAllowThreads();
54540 result = (arg1)->GetItemSpan(arg2);
54541 wxPyEndAllowThreads(__tstate);
54542 if (PyErr_Occurred()) SWIG_fail;
54543 }
54544 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54545 return resultobj;
54546fail:
54547 return NULL;
d55e5bfc
RD
54548}
54549
54550
1bd55598
RD
54551SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54552 int argc;
54553 PyObject *argv[3];
54554
54555 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54556 --argc;
54557 if (argc == 2) {
54558 int _v = 0;
d55e5bfc 54559 {
1bd55598
RD
54560 void *vptr = 0;
54561 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54562 _v = SWIG_CheckState(res);
d55e5bfc 54563 }
1bd55598
RD
54564 if (!_v) goto check_1;
54565 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54566 }
54567check_1:
54568
54569 if (argc == 2) {
54570 int _v = 0;
d55e5bfc 54571 {
1bd55598
RD
54572 void *vptr = 0;
54573 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54574 _v = SWIG_CheckState(res);
d55e5bfc 54575 }
1bd55598
RD
54576 if (!_v) goto check_2;
54577 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54578 }
54579check_2:
54580
54581 if (argc == 2) {
54582 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54583 }
54584
54585fail:
54586 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54587 return NULL;
54588}
54589
54590
54591SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54592 PyObject *resultobj = 0;
54593 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54594 wxWindow *arg2 = (wxWindow *) 0 ;
54595 wxGBSpan *arg3 = 0 ;
54596 bool result;
54597 void *argp1 = 0 ;
54598 int res1 = 0 ;
54599 void *argp2 = 0 ;
54600 int res2 = 0 ;
54601 wxGBSpan temp3 ;
54602
54603 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54605 if (!SWIG_IsOK(res1)) {
54606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54607 }
54608 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54609 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54610 if (!SWIG_IsOK(res2)) {
54611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54612 }
54613 arg2 = reinterpret_cast< wxWindow * >(argp2);
54614 {
54615 arg3 = &temp3;
54616 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54617 }
54618 {
54619 PyThreadState* __tstate = wxPyBeginAllowThreads();
54620 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54621 wxPyEndAllowThreads(__tstate);
54622 if (PyErr_Occurred()) SWIG_fail;
54623 }
54624 {
54625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54626 }
54627 return resultobj;
54628fail:
54629 return NULL;
54630}
54631
54632
54633SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54634 PyObject *resultobj = 0;
54635 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54636 wxSizer *arg2 = (wxSizer *) 0 ;
54637 wxGBSpan *arg3 = 0 ;
54638 bool result;
54639 void *argp1 = 0 ;
54640 int res1 = 0 ;
54641 void *argp2 = 0 ;
54642 int res2 = 0 ;
54643 wxGBSpan temp3 ;
54644
54645 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54647 if (!SWIG_IsOK(res1)) {
54648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54649 }
54650 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54651 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54652 if (!SWIG_IsOK(res2)) {
54653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54654 }
54655 arg2 = reinterpret_cast< wxSizer * >(argp2);
54656 {
54657 arg3 = &temp3;
54658 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54659 }
54660 {
54661 PyThreadState* __tstate = wxPyBeginAllowThreads();
54662 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54663 wxPyEndAllowThreads(__tstate);
54664 if (PyErr_Occurred()) SWIG_fail;
54665 }
54666 {
54667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54668 }
54669 return resultobj;
54670fail:
54671 return NULL;
54672}
54673
54674
54675SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54676 PyObject *resultobj = 0;
54677 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54678 size_t arg2 ;
54679 wxGBSpan *arg3 = 0 ;
54680 bool result;
54681 void *argp1 = 0 ;
54682 int res1 = 0 ;
54683 size_t val2 ;
54684 int ecode2 = 0 ;
54685 wxGBSpan temp3 ;
54686
54687 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54689 if (!SWIG_IsOK(res1)) {
54690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54691 }
54692 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54693 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54694 if (!SWIG_IsOK(ecode2)) {
54695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54696 }
54697 arg2 = static_cast< size_t >(val2);
54698 {
54699 arg3 = &temp3;
54700 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54701 }
54702 {
54703 PyThreadState* __tstate = wxPyBeginAllowThreads();
54704 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54705 wxPyEndAllowThreads(__tstate);
54706 if (PyErr_Occurred()) SWIG_fail;
54707 }
54708 {
54709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54710 }
54711 return resultobj;
54712fail:
54713 return NULL;
d55e5bfc
RD
54714}
54715
54716
1bd55598
RD
54717SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54718 int argc;
54719 PyObject *argv[4];
54720
54721 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54722 --argc;
54723 if (argc == 3) {
54724 int _v = 0;
d55e5bfc 54725 {
1bd55598
RD
54726 void *vptr = 0;
54727 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54728 _v = SWIG_CheckState(res);
d55e5bfc 54729 }
1bd55598
RD
54730 if (!_v) goto check_1;
54731 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54732 }
54733check_1:
54734
54735 if (argc == 3) {
54736 int _v = 0;
d55e5bfc 54737 {
1bd55598
RD
54738 void *vptr = 0;
54739 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54740 _v = SWIG_CheckState(res);
d55e5bfc 54741 }
1bd55598
RD
54742 if (!_v) goto check_2;
54743 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54744 }
54745check_2:
54746
54747 if (argc == 3) {
54748 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54749 }
54750
54751fail:
54752 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54753 return NULL;
d55e5bfc
RD
54754}
54755
54756
1bd55598
RD
54757SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54758 PyObject *resultobj = 0;
54759 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54760 wxWindow *arg2 = (wxWindow *) 0 ;
54761 wxGBSizerItem *result = 0 ;
54762 void *argp1 = 0 ;
54763 int res1 = 0 ;
54764 void *argp2 = 0 ;
54765 int res2 = 0 ;
54766
54767 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54769 if (!SWIG_IsOK(res1)) {
54770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54771 }
54772 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54773 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54774 if (!SWIG_IsOK(res2)) {
54775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54776 }
54777 arg2 = reinterpret_cast< wxWindow * >(argp2);
54778 {
54779 PyThreadState* __tstate = wxPyBeginAllowThreads();
54780 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54781 wxPyEndAllowThreads(__tstate);
54782 if (PyErr_Occurred()) SWIG_fail;
54783 }
54784 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54785 return resultobj;
54786fail:
54787 return NULL;
54788}
54789
54790
54791SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54792 PyObject *resultobj = 0;
54793 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54794 wxSizer *arg2 = (wxSizer *) 0 ;
54795 wxGBSizerItem *result = 0 ;
54796 void *argp1 = 0 ;
54797 int res1 = 0 ;
54798 void *argp2 = 0 ;
54799 int res2 = 0 ;
54800
54801 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54803 if (!SWIG_IsOK(res1)) {
54804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54805 }
54806 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54807 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54808 if (!SWIG_IsOK(res2)) {
54809 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54810 }
54811 arg2 = reinterpret_cast< wxSizer * >(argp2);
54812 {
54813 PyThreadState* __tstate = wxPyBeginAllowThreads();
54814 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54815 wxPyEndAllowThreads(__tstate);
54816 if (PyErr_Occurred()) SWIG_fail;
54817 }
54818 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54819 return resultobj;
54820fail:
54821 return NULL;
d55e5bfc
RD
54822}
54823
54824
1bd55598
RD
54825SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54826 int argc;
54827 PyObject *argv[3];
54828
54829 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54830 --argc;
54831 if (argc == 2) {
54832 int _v = 0;
d55e5bfc 54833 {
1bd55598
RD
54834 void *vptr = 0;
54835 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54836 _v = SWIG_CheckState(res);
d55e5bfc 54837 }
1bd55598
RD
54838 if (!_v) goto check_1;
54839 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54840 }
54841check_1:
54842
54843 if (argc == 2) {
54844 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54845 }
54846
54847fail:
54848 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54849 return NULL;
54850}
54851
54852
54853SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54854 PyObject *resultobj = 0;
54855 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54856 wxGBPosition *arg2 = 0 ;
54857 wxGBSizerItem *result = 0 ;
54858 void *argp1 = 0 ;
54859 int res1 = 0 ;
54860 wxGBPosition temp2 ;
54861 PyObject * obj0 = 0 ;
54862 PyObject * obj1 = 0 ;
54863 char * kwnames[] = {
54864 (char *) "self",(char *) "pos", NULL
54865 };
54866
54867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54869 if (!SWIG_IsOK(res1)) {
54870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54871 }
54872 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54873 {
54874 arg2 = &temp2;
54875 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54876 }
54877 {
54878 PyThreadState* __tstate = wxPyBeginAllowThreads();
54879 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54880 wxPyEndAllowThreads(__tstate);
54881 if (PyErr_Occurred()) SWIG_fail;
54882 }
54883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54884 return resultobj;
54885fail:
54886 return NULL;
54887}
54888
54889
54890SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54891 PyObject *resultobj = 0;
54892 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54893 wxPoint *arg2 = 0 ;
54894 wxGBSizerItem *result = 0 ;
54895 void *argp1 = 0 ;
54896 int res1 = 0 ;
54897 wxPoint temp2 ;
54898 PyObject * obj0 = 0 ;
54899 PyObject * obj1 = 0 ;
54900 char * kwnames[] = {
54901 (char *) "self",(char *) "pt", NULL
54902 };
54903
54904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54906 if (!SWIG_IsOK(res1)) {
54907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54908 }
54909 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54910 {
54911 arg2 = &temp2;
54912 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54913 }
54914 {
54915 PyThreadState* __tstate = wxPyBeginAllowThreads();
54916 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54917 wxPyEndAllowThreads(__tstate);
54918 if (PyErr_Occurred()) SWIG_fail;
54919 }
54920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54921 return resultobj;
54922fail:
54923 return NULL;
54924}
54925
54926
54927SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54928 PyObject *resultobj = 0;
54929 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54930 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54931 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54932 bool result;
54933 void *argp1 = 0 ;
54934 int res1 = 0 ;
54935 void *argp2 = 0 ;
54936 int res2 = 0 ;
54937 void *argp3 = 0 ;
54938 int res3 = 0 ;
54939 PyObject * obj0 = 0 ;
54940 PyObject * obj1 = 0 ;
54941 PyObject * obj2 = 0 ;
54942 char * kwnames[] = {
54943 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54944 };
54945
54946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54948 if (!SWIG_IsOK(res1)) {
54949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54950 }
54951 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54952 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54953 if (!SWIG_IsOK(res2)) {
54954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54955 }
54956 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54957 if (obj2) {
54958 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54959 if (!SWIG_IsOK(res3)) {
54960 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
d55e5bfc 54961 }
1bd55598
RD
54962 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
54963 }
54964 {
54965 PyThreadState* __tstate = wxPyBeginAllowThreads();
54966 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
54967 wxPyEndAllowThreads(__tstate);
54968 if (PyErr_Occurred()) SWIG_fail;
54969 }
54970 {
54971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54972 }
54973 return resultobj;
54974fail:
54975 return NULL;
54976}
54977
54978
54979SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54980 PyObject *resultobj = 0;
54981 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54982 wxGBPosition *arg2 = 0 ;
54983 wxGBSpan *arg3 = 0 ;
54984 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
54985 bool result;
54986 void *argp1 = 0 ;
54987 int res1 = 0 ;
54988 wxGBPosition temp2 ;
54989 wxGBSpan temp3 ;
54990 void *argp4 = 0 ;
54991 int res4 = 0 ;
54992 PyObject * obj0 = 0 ;
54993 PyObject * obj1 = 0 ;
54994 PyObject * obj2 = 0 ;
54995 PyObject * obj3 = 0 ;
54996 char * kwnames[] = {
54997 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
54998 };
54999
55000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55002 if (!SWIG_IsOK(res1)) {
55003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55004 }
55005 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55006 {
55007 arg2 = &temp2;
55008 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55009 }
55010 {
55011 arg3 = &temp3;
55012 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55013 }
55014 if (obj3) {
55015 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55016 if (!SWIG_IsOK(res4)) {
55017 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
55018 }
55019 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
55020 }
55021 {
55022 PyThreadState* __tstate = wxPyBeginAllowThreads();
55023 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
55024 wxPyEndAllowThreads(__tstate);
55025 if (PyErr_Occurred()) SWIG_fail;
55026 }
55027 {
55028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55029 }
55030 return resultobj;
55031fail:
55032 return NULL;
55033}
55034
55035
55036SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55037 PyObject *obj;
55038 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55039 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
55040 return SWIG_Py_Void();
55041}
55042
55043SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55044 return SWIG_Python_InitShadowInstance(args);
55045}
55046
55047SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55048 PyObject *resultobj = 0;
55049 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55050 wxRelationship arg2 ;
55051 wxWindow *arg3 = (wxWindow *) 0 ;
55052 wxEdge arg4 ;
55053 int arg5 = (int) 0 ;
55054 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
55055 void *argp1 = 0 ;
55056 int res1 = 0 ;
55057 int val2 ;
55058 int ecode2 = 0 ;
55059 void *argp3 = 0 ;
55060 int res3 = 0 ;
55061 int val4 ;
55062 int ecode4 = 0 ;
55063 int val5 ;
55064 int ecode5 = 0 ;
55065 int val6 ;
55066 int ecode6 = 0 ;
55067 PyObject * obj0 = 0 ;
55068 PyObject * obj1 = 0 ;
55069 PyObject * obj2 = 0 ;
55070 PyObject * obj3 = 0 ;
55071 PyObject * obj4 = 0 ;
55072 PyObject * obj5 = 0 ;
55073 char * kwnames[] = {
55074 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55075 };
55076
55077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55079 if (!SWIG_IsOK(res1)) {
55080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55081 }
55082 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55083 ecode2 = SWIG_AsVal_int(obj1, &val2);
55084 if (!SWIG_IsOK(ecode2)) {
55085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55086 }
55087 arg2 = static_cast< wxRelationship >(val2);
55088 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55089 if (!SWIG_IsOK(res3)) {
55090 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55091 }
55092 arg3 = reinterpret_cast< wxWindow * >(argp3);
55093 ecode4 = SWIG_AsVal_int(obj3, &val4);
55094 if (!SWIG_IsOK(ecode4)) {
55095 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55096 }
55097 arg4 = static_cast< wxEdge >(val4);
55098 if (obj4) {
55099 ecode5 = SWIG_AsVal_int(obj4, &val5);
55100 if (!SWIG_IsOK(ecode5)) {
55101 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55102 }
55103 arg5 = static_cast< int >(val5);
55104 }
55105 if (obj5) {
55106 ecode6 = SWIG_AsVal_int(obj5, &val6);
55107 if (!SWIG_IsOK(ecode6)) {
55108 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55109 }
55110 arg6 = static_cast< int >(val6);
55111 }
55112 {
55113 PyThreadState* __tstate = wxPyBeginAllowThreads();
55114 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55115 wxPyEndAllowThreads(__tstate);
55116 if (PyErr_Occurred()) SWIG_fail;
55117 }
55118 resultobj = SWIG_Py_Void();
55119 return resultobj;
55120fail:
55121 return NULL;
55122}
55123
55124
55125SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55126 PyObject *resultobj = 0;
55127 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55128 wxWindow *arg2 = (wxWindow *) 0 ;
55129 int arg3 = (int) 0 ;
55130 void *argp1 = 0 ;
55131 int res1 = 0 ;
55132 void *argp2 = 0 ;
55133 int res2 = 0 ;
55134 int val3 ;
55135 int ecode3 = 0 ;
55136 PyObject * obj0 = 0 ;
55137 PyObject * obj1 = 0 ;
55138 PyObject * obj2 = 0 ;
55139 char * kwnames[] = {
55140 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55141 };
55142
55143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55145 if (!SWIG_IsOK(res1)) {
55146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55147 }
55148 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55149 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55150 if (!SWIG_IsOK(res2)) {
55151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55152 }
55153 arg2 = reinterpret_cast< wxWindow * >(argp2);
55154 if (obj2) {
55155 ecode3 = SWIG_AsVal_int(obj2, &val3);
55156 if (!SWIG_IsOK(ecode3)) {
55157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55158 }
55159 arg3 = static_cast< int >(val3);
55160 }
55161 {
55162 PyThreadState* __tstate = wxPyBeginAllowThreads();
55163 (arg1)->LeftOf(arg2,arg3);
55164 wxPyEndAllowThreads(__tstate);
55165 if (PyErr_Occurred()) SWIG_fail;
55166 }
55167 resultobj = SWIG_Py_Void();
55168 return resultobj;
55169fail:
55170 return NULL;
55171}
55172
55173
55174SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55175 PyObject *resultobj = 0;
55176 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55177 wxWindow *arg2 = (wxWindow *) 0 ;
55178 int arg3 = (int) 0 ;
55179 void *argp1 = 0 ;
55180 int res1 = 0 ;
55181 void *argp2 = 0 ;
55182 int res2 = 0 ;
55183 int val3 ;
55184 int ecode3 = 0 ;
55185 PyObject * obj0 = 0 ;
55186 PyObject * obj1 = 0 ;
55187 PyObject * obj2 = 0 ;
55188 char * kwnames[] = {
55189 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55190 };
55191
55192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55194 if (!SWIG_IsOK(res1)) {
55195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55196 }
55197 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55198 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55199 if (!SWIG_IsOK(res2)) {
55200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55201 }
55202 arg2 = reinterpret_cast< wxWindow * >(argp2);
55203 if (obj2) {
55204 ecode3 = SWIG_AsVal_int(obj2, &val3);
55205 if (!SWIG_IsOK(ecode3)) {
55206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55207 }
55208 arg3 = static_cast< int >(val3);
55209 }
55210 {
55211 PyThreadState* __tstate = wxPyBeginAllowThreads();
55212 (arg1)->RightOf(arg2,arg3);
55213 wxPyEndAllowThreads(__tstate);
55214 if (PyErr_Occurred()) SWIG_fail;
55215 }
55216 resultobj = SWIG_Py_Void();
55217 return resultobj;
55218fail:
55219 return NULL;
55220}
55221
55222
55223SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55224 PyObject *resultobj = 0;
55225 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55226 wxWindow *arg2 = (wxWindow *) 0 ;
55227 int arg3 = (int) 0 ;
55228 void *argp1 = 0 ;
55229 int res1 = 0 ;
55230 void *argp2 = 0 ;
55231 int res2 = 0 ;
55232 int val3 ;
55233 int ecode3 = 0 ;
55234 PyObject * obj0 = 0 ;
55235 PyObject * obj1 = 0 ;
55236 PyObject * obj2 = 0 ;
55237 char * kwnames[] = {
55238 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55239 };
55240
55241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55243 if (!SWIG_IsOK(res1)) {
55244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55245 }
55246 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55247 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55248 if (!SWIG_IsOK(res2)) {
55249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55250 }
55251 arg2 = reinterpret_cast< wxWindow * >(argp2);
55252 if (obj2) {
55253 ecode3 = SWIG_AsVal_int(obj2, &val3);
55254 if (!SWIG_IsOK(ecode3)) {
55255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55256 }
55257 arg3 = static_cast< int >(val3);
55258 }
55259 {
55260 PyThreadState* __tstate = wxPyBeginAllowThreads();
55261 (arg1)->Above(arg2,arg3);
55262 wxPyEndAllowThreads(__tstate);
55263 if (PyErr_Occurred()) SWIG_fail;
55264 }
55265 resultobj = SWIG_Py_Void();
55266 return resultobj;
55267fail:
55268 return NULL;
55269}
55270
55271
55272SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55273 PyObject *resultobj = 0;
55274 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55275 wxWindow *arg2 = (wxWindow *) 0 ;
55276 int arg3 = (int) 0 ;
55277 void *argp1 = 0 ;
55278 int res1 = 0 ;
55279 void *argp2 = 0 ;
55280 int res2 = 0 ;
55281 int val3 ;
55282 int ecode3 = 0 ;
55283 PyObject * obj0 = 0 ;
55284 PyObject * obj1 = 0 ;
55285 PyObject * obj2 = 0 ;
55286 char * kwnames[] = {
55287 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55288 };
55289
55290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55292 if (!SWIG_IsOK(res1)) {
55293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55294 }
55295 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55296 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55297 if (!SWIG_IsOK(res2)) {
55298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55299 }
55300 arg2 = reinterpret_cast< wxWindow * >(argp2);
55301 if (obj2) {
55302 ecode3 = SWIG_AsVal_int(obj2, &val3);
55303 if (!SWIG_IsOK(ecode3)) {
55304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55305 }
55306 arg3 = static_cast< int >(val3);
55307 }
55308 {
55309 PyThreadState* __tstate = wxPyBeginAllowThreads();
55310 (arg1)->Below(arg2,arg3);
55311 wxPyEndAllowThreads(__tstate);
55312 if (PyErr_Occurred()) SWIG_fail;
55313 }
55314 resultobj = SWIG_Py_Void();
55315 return resultobj;
55316fail:
55317 return NULL;
55318}
55319
55320
55321SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55322 PyObject *resultobj = 0;
55323 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55324 wxWindow *arg2 = (wxWindow *) 0 ;
55325 wxEdge arg3 ;
55326 int arg4 = (int) 0 ;
55327 void *argp1 = 0 ;
55328 int res1 = 0 ;
55329 void *argp2 = 0 ;
55330 int res2 = 0 ;
55331 int val3 ;
55332 int ecode3 = 0 ;
55333 int val4 ;
55334 int ecode4 = 0 ;
55335 PyObject * obj0 = 0 ;
55336 PyObject * obj1 = 0 ;
55337 PyObject * obj2 = 0 ;
55338 PyObject * obj3 = 0 ;
55339 char * kwnames[] = {
55340 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55341 };
55342
55343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55345 if (!SWIG_IsOK(res1)) {
55346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55347 }
55348 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55349 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55350 if (!SWIG_IsOK(res2)) {
55351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55352 }
55353 arg2 = reinterpret_cast< wxWindow * >(argp2);
55354 ecode3 = SWIG_AsVal_int(obj2, &val3);
55355 if (!SWIG_IsOK(ecode3)) {
55356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55357 }
55358 arg3 = static_cast< wxEdge >(val3);
55359 if (obj3) {
55360 ecode4 = SWIG_AsVal_int(obj3, &val4);
55361 if (!SWIG_IsOK(ecode4)) {
55362 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55363 }
55364 arg4 = static_cast< int >(val4);
55365 }
55366 {
55367 PyThreadState* __tstate = wxPyBeginAllowThreads();
55368 (arg1)->SameAs(arg2,arg3,arg4);
55369 wxPyEndAllowThreads(__tstate);
55370 if (PyErr_Occurred()) SWIG_fail;
55371 }
55372 resultobj = SWIG_Py_Void();
55373 return resultobj;
55374fail:
55375 return NULL;
55376}
55377
55378
55379SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55380 PyObject *resultobj = 0;
55381 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55382 wxWindow *arg2 = (wxWindow *) 0 ;
55383 wxEdge arg3 ;
55384 int arg4 ;
55385 void *argp1 = 0 ;
55386 int res1 = 0 ;
55387 void *argp2 = 0 ;
55388 int res2 = 0 ;
55389 int val3 ;
55390 int ecode3 = 0 ;
55391 int val4 ;
55392 int ecode4 = 0 ;
55393 PyObject * obj0 = 0 ;
55394 PyObject * obj1 = 0 ;
55395 PyObject * obj2 = 0 ;
55396 PyObject * obj3 = 0 ;
55397 char * kwnames[] = {
55398 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55399 };
55400
55401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55403 if (!SWIG_IsOK(res1)) {
55404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55405 }
55406 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55407 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55408 if (!SWIG_IsOK(res2)) {
55409 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55410 }
55411 arg2 = reinterpret_cast< wxWindow * >(argp2);
55412 ecode3 = SWIG_AsVal_int(obj2, &val3);
55413 if (!SWIG_IsOK(ecode3)) {
55414 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55415 }
55416 arg3 = static_cast< wxEdge >(val3);
55417 ecode4 = SWIG_AsVal_int(obj3, &val4);
55418 if (!SWIG_IsOK(ecode4)) {
55419 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55420 }
55421 arg4 = static_cast< int >(val4);
55422 {
55423 PyThreadState* __tstate = wxPyBeginAllowThreads();
55424 (arg1)->PercentOf(arg2,arg3,arg4);
55425 wxPyEndAllowThreads(__tstate);
55426 if (PyErr_Occurred()) SWIG_fail;
55427 }
55428 resultobj = SWIG_Py_Void();
55429 return resultobj;
55430fail:
55431 return NULL;
55432}
55433
55434
55435SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55436 PyObject *resultobj = 0;
55437 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55438 int arg2 ;
55439 void *argp1 = 0 ;
55440 int res1 = 0 ;
55441 int val2 ;
55442 int ecode2 = 0 ;
55443 PyObject * obj0 = 0 ;
55444 PyObject * obj1 = 0 ;
55445 char * kwnames[] = {
55446 (char *) "self",(char *) "val", NULL
55447 };
55448
55449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55451 if (!SWIG_IsOK(res1)) {
55452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55453 }
55454 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55455 ecode2 = SWIG_AsVal_int(obj1, &val2);
55456 if (!SWIG_IsOK(ecode2)) {
55457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55458 }
55459 arg2 = static_cast< int >(val2);
55460 {
55461 PyThreadState* __tstate = wxPyBeginAllowThreads();
55462 (arg1)->Absolute(arg2);
55463 wxPyEndAllowThreads(__tstate);
55464 if (PyErr_Occurred()) SWIG_fail;
55465 }
55466 resultobj = SWIG_Py_Void();
55467 return resultobj;
55468fail:
55469 return NULL;
55470}
d55e5bfc
RD
55471
55472
1bd55598
RD
55473SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55474 PyObject *resultobj = 0;
55475 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55476 void *argp1 = 0 ;
55477 int res1 = 0 ;
55478 PyObject *swig_obj[1] ;
55479
55480 if (!args) SWIG_fail;
55481 swig_obj[0] = args;
55482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55483 if (!SWIG_IsOK(res1)) {
55484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55485 }
55486 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55487 {
55488 PyThreadState* __tstate = wxPyBeginAllowThreads();
55489 (arg1)->Unconstrained();
55490 wxPyEndAllowThreads(__tstate);
55491 if (PyErr_Occurred()) SWIG_fail;
55492 }
55493 resultobj = SWIG_Py_Void();
55494 return resultobj;
55495fail:
55496 return NULL;
d55e5bfc
RD
55497}
55498
55499
1bd55598
RD
55500SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55501 PyObject *resultobj = 0;
55502 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55503 void *argp1 = 0 ;
55504 int res1 = 0 ;
55505 PyObject *swig_obj[1] ;
55506
55507 if (!args) SWIG_fail;
55508 swig_obj[0] = args;
55509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55510 if (!SWIG_IsOK(res1)) {
55511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55512 }
55513 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55514 {
55515 PyThreadState* __tstate = wxPyBeginAllowThreads();
55516 (arg1)->AsIs();
55517 wxPyEndAllowThreads(__tstate);
55518 if (PyErr_Occurred()) SWIG_fail;
55519 }
55520 resultobj = SWIG_Py_Void();
55521 return resultobj;
55522fail:
55523 return NULL;
d55e5bfc
RD
55524}
55525
55526
1bd55598
RD
55527SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55528 PyObject *resultobj = 0;
55529 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55530 wxWindow *result = 0 ;
55531 void *argp1 = 0 ;
55532 int res1 = 0 ;
55533 PyObject *swig_obj[1] ;
55534
55535 if (!args) SWIG_fail;
55536 swig_obj[0] = args;
55537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55538 if (!SWIG_IsOK(res1)) {
55539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55540 }
55541 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55542 {
55543 PyThreadState* __tstate = wxPyBeginAllowThreads();
55544 result = (wxWindow *)(arg1)->GetOtherWindow();
55545 wxPyEndAllowThreads(__tstate);
55546 if (PyErr_Occurred()) SWIG_fail;
55547 }
55548 {
55549 resultobj = wxPyMake_wxObject(result, 0);
55550 }
55551 return resultobj;
55552fail:
55553 return NULL;
d55e5bfc
RD
55554}
55555
55556
1bd55598
RD
55557SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55558 PyObject *resultobj = 0;
55559 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55560 wxEdge result;
55561 void *argp1 = 0 ;
55562 int res1 = 0 ;
55563 PyObject *swig_obj[1] ;
55564
55565 if (!args) SWIG_fail;
55566 swig_obj[0] = args;
55567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55568 if (!SWIG_IsOK(res1)) {
55569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55570 }
55571 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55572 {
55573 PyThreadState* __tstate = wxPyBeginAllowThreads();
55574 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55575 wxPyEndAllowThreads(__tstate);
55576 if (PyErr_Occurred()) SWIG_fail;
55577 }
55578 resultobj = SWIG_From_int(static_cast< int >(result));
55579 return resultobj;
55580fail:
55581 return NULL;
55582}
55583
55584
55585SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55586 PyObject *resultobj = 0;
55587 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55588 wxEdge arg2 ;
55589 void *argp1 = 0 ;
55590 int res1 = 0 ;
55591 int val2 ;
55592 int ecode2 = 0 ;
55593 PyObject * obj0 = 0 ;
55594 PyObject * obj1 = 0 ;
55595 char * kwnames[] = {
55596 (char *) "self",(char *) "which", NULL
55597 };
55598
55599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55601 if (!SWIG_IsOK(res1)) {
55602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55603 }
55604 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55605 ecode2 = SWIG_AsVal_int(obj1, &val2);
55606 if (!SWIG_IsOK(ecode2)) {
55607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55608 }
55609 arg2 = static_cast< wxEdge >(val2);
55610 {
55611 PyThreadState* __tstate = wxPyBeginAllowThreads();
55612 (arg1)->SetEdge(arg2);
55613 wxPyEndAllowThreads(__tstate);
55614 if (PyErr_Occurred()) SWIG_fail;
55615 }
55616 resultobj = SWIG_Py_Void();
55617 return resultobj;
55618fail:
55619 return NULL;
55620}
55621
55622
55623SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55624 PyObject *resultobj = 0;
55625 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55626 int arg2 ;
55627 void *argp1 = 0 ;
55628 int res1 = 0 ;
55629 int val2 ;
55630 int ecode2 = 0 ;
55631 PyObject * obj0 = 0 ;
55632 PyObject * obj1 = 0 ;
55633 char * kwnames[] = {
55634 (char *) "self",(char *) "v", NULL
55635 };
55636
55637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55639 if (!SWIG_IsOK(res1)) {
55640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55641 }
55642 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55643 ecode2 = SWIG_AsVal_int(obj1, &val2);
55644 if (!SWIG_IsOK(ecode2)) {
55645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55646 }
55647 arg2 = static_cast< int >(val2);
55648 {
55649 PyThreadState* __tstate = wxPyBeginAllowThreads();
55650 (arg1)->SetValue(arg2);
55651 wxPyEndAllowThreads(__tstate);
55652 if (PyErr_Occurred()) SWIG_fail;
55653 }
55654 resultobj = SWIG_Py_Void();
55655 return resultobj;
55656fail:
55657 return NULL;
d55e5bfc
RD
55658}
55659
55660
1bd55598
RD
55661SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55662 PyObject *resultobj = 0;
55663 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55664 int result;
55665 void *argp1 = 0 ;
55666 int res1 = 0 ;
55667 PyObject *swig_obj[1] ;
55668
55669 if (!args) SWIG_fail;
55670 swig_obj[0] = args;
55671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55672 if (!SWIG_IsOK(res1)) {
55673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55674 }
55675 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55676 {
55677 PyThreadState* __tstate = wxPyBeginAllowThreads();
55678 result = (int)(arg1)->GetMargin();
55679 wxPyEndAllowThreads(__tstate);
55680 if (PyErr_Occurred()) SWIG_fail;
55681 }
55682 resultobj = SWIG_From_int(static_cast< int >(result));
55683 return resultobj;
55684fail:
55685 return NULL;
55686}
55687
55688
55689SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55690 PyObject *resultobj = 0;
55691 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55692 int arg2 ;
55693 void *argp1 = 0 ;
55694 int res1 = 0 ;
55695 int val2 ;
55696 int ecode2 = 0 ;
55697 PyObject * obj0 = 0 ;
55698 PyObject * obj1 = 0 ;
55699 char * kwnames[] = {
55700 (char *) "self",(char *) "m", NULL
55701 };
55702
55703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55705 if (!SWIG_IsOK(res1)) {
55706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55707 }
55708 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55709 ecode2 = SWIG_AsVal_int(obj1, &val2);
55710 if (!SWIG_IsOK(ecode2)) {
55711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55712 }
55713 arg2 = static_cast< int >(val2);
55714 {
55715 PyThreadState* __tstate = wxPyBeginAllowThreads();
55716 (arg1)->SetMargin(arg2);
55717 wxPyEndAllowThreads(__tstate);
55718 if (PyErr_Occurred()) SWIG_fail;
55719 }
55720 resultobj = SWIG_Py_Void();
55721 return resultobj;
55722fail:
55723 return NULL;
d55e5bfc
RD
55724}
55725
55726
1bd55598
RD
55727SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55728 PyObject *resultobj = 0;
55729 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55730 int result;
55731 void *argp1 = 0 ;
55732 int res1 = 0 ;
55733 PyObject *swig_obj[1] ;
55734
55735 if (!args) SWIG_fail;
55736 swig_obj[0] = args;
55737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55738 if (!SWIG_IsOK(res1)) {
55739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55740 }
55741 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55742 {
55743 PyThreadState* __tstate = wxPyBeginAllowThreads();
55744 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55745 wxPyEndAllowThreads(__tstate);
55746 if (PyErr_Occurred()) SWIG_fail;
55747 }
55748 resultobj = SWIG_From_int(static_cast< int >(result));
55749 return resultobj;
55750fail:
55751 return NULL;
d55e5bfc
RD
55752}
55753
55754
1bd55598
RD
55755SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55756 PyObject *resultobj = 0;
55757 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55758 int result;
55759 void *argp1 = 0 ;
55760 int res1 = 0 ;
55761 PyObject *swig_obj[1] ;
55762
55763 if (!args) SWIG_fail;
55764 swig_obj[0] = args;
55765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55766 if (!SWIG_IsOK(res1)) {
55767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55768 }
55769 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55770 {
55771 PyThreadState* __tstate = wxPyBeginAllowThreads();
55772 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55773 wxPyEndAllowThreads(__tstate);
55774 if (PyErr_Occurred()) SWIG_fail;
55775 }
55776 resultobj = SWIG_From_int(static_cast< int >(result));
55777 return resultobj;
55778fail:
55779 return NULL;
d55e5bfc
RD
55780}
55781
55782
1bd55598
RD
55783SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55784 PyObject *resultobj = 0;
55785 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55786 int result;
55787 void *argp1 = 0 ;
55788 int res1 = 0 ;
55789 PyObject *swig_obj[1] ;
55790
55791 if (!args) SWIG_fail;
55792 swig_obj[0] = args;
55793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55794 if (!SWIG_IsOK(res1)) {
55795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55796 }
55797 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55798 {
55799 PyThreadState* __tstate = wxPyBeginAllowThreads();
55800 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55801 wxPyEndAllowThreads(__tstate);
55802 if (PyErr_Occurred()) SWIG_fail;
55803 }
55804 resultobj = SWIG_From_int(static_cast< int >(result));
55805 return resultobj;
55806fail:
55807 return NULL;
d55e5bfc
RD
55808}
55809
55810
1bd55598
RD
55811SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55812 PyObject *resultobj = 0;
55813 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55814 bool result;
55815 void *argp1 = 0 ;
55816 int res1 = 0 ;
55817 PyObject *swig_obj[1] ;
55818
55819 if (!args) SWIG_fail;
55820 swig_obj[0] = args;
55821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55822 if (!SWIG_IsOK(res1)) {
55823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55824 }
55825 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55826 {
55827 PyThreadState* __tstate = wxPyBeginAllowThreads();
55828 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55829 wxPyEndAllowThreads(__tstate);
55830 if (PyErr_Occurred()) SWIG_fail;
55831 }
55832 {
55833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55834 }
55835 return resultobj;
55836fail:
55837 return NULL;
55838}
55839
55840
55841SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55842 PyObject *resultobj = 0;
55843 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55844 bool arg2 ;
55845 void *argp1 = 0 ;
55846 int res1 = 0 ;
55847 bool val2 ;
55848 int ecode2 = 0 ;
55849 PyObject * obj0 = 0 ;
55850 PyObject * obj1 = 0 ;
55851 char * kwnames[] = {
55852 (char *) "self",(char *) "d", NULL
55853 };
55854
55855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55857 if (!SWIG_IsOK(res1)) {
55858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55859 }
55860 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55861 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55862 if (!SWIG_IsOK(ecode2)) {
55863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55864 }
55865 arg2 = static_cast< bool >(val2);
55866 {
55867 PyThreadState* __tstate = wxPyBeginAllowThreads();
55868 (arg1)->SetDone(arg2);
55869 wxPyEndAllowThreads(__tstate);
55870 if (PyErr_Occurred()) SWIG_fail;
55871 }
55872 resultobj = SWIG_Py_Void();
55873 return resultobj;
55874fail:
55875 return NULL;
d55e5bfc
RD
55876}
55877
55878
1bd55598
RD
55879SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55880 PyObject *resultobj = 0;
55881 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55882 wxRelationship result;
55883 void *argp1 = 0 ;
55884 int res1 = 0 ;
55885 PyObject *swig_obj[1] ;
55886
55887 if (!args) SWIG_fail;
55888 swig_obj[0] = args;
55889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55890 if (!SWIG_IsOK(res1)) {
55891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55892 }
55893 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55894 {
55895 PyThreadState* __tstate = wxPyBeginAllowThreads();
55896 result = (wxRelationship)(arg1)->GetRelationship();
55897 wxPyEndAllowThreads(__tstate);
55898 if (PyErr_Occurred()) SWIG_fail;
55899 }
55900 resultobj = SWIG_From_int(static_cast< int >(result));
55901 return resultobj;
55902fail:
55903 return NULL;
55904}
55905
55906
55907SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55908 PyObject *resultobj = 0;
55909 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55910 wxRelationship arg2 ;
55911 void *argp1 = 0 ;
55912 int res1 = 0 ;
55913 int val2 ;
55914 int ecode2 = 0 ;
55915 PyObject * obj0 = 0 ;
55916 PyObject * obj1 = 0 ;
55917 char * kwnames[] = {
55918 (char *) "self",(char *) "r", NULL
55919 };
55920
55921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55923 if (!SWIG_IsOK(res1)) {
55924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55925 }
55926 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55927 ecode2 = SWIG_AsVal_int(obj1, &val2);
55928 if (!SWIG_IsOK(ecode2)) {
55929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55930 }
55931 arg2 = static_cast< wxRelationship >(val2);
55932 {
55933 PyThreadState* __tstate = wxPyBeginAllowThreads();
55934 (arg1)->SetRelationship(arg2);
55935 wxPyEndAllowThreads(__tstate);
55936 if (PyErr_Occurred()) SWIG_fail;
55937 }
55938 resultobj = SWIG_Py_Void();
55939 return resultobj;
55940fail:
55941 return NULL;
55942}
55943
55944
55945SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55946 PyObject *resultobj = 0;
55947 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55948 wxWindow *arg2 = (wxWindow *) 0 ;
55949 bool result;
55950 void *argp1 = 0 ;
55951 int res1 = 0 ;
55952 void *argp2 = 0 ;
55953 int res2 = 0 ;
55954 PyObject * obj0 = 0 ;
55955 PyObject * obj1 = 0 ;
55956 char * kwnames[] = {
55957 (char *) "self",(char *) "otherW", NULL
55958 };
55959
55960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
55961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55962 if (!SWIG_IsOK(res1)) {
55963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55964 }
55965 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55966 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55967 if (!SWIG_IsOK(res2)) {
55968 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
55969 }
55970 arg2 = reinterpret_cast< wxWindow * >(argp2);
55971 {
55972 PyThreadState* __tstate = wxPyBeginAllowThreads();
55973 result = (bool)(arg1)->ResetIfWin(arg2);
55974 wxPyEndAllowThreads(__tstate);
55975 if (PyErr_Occurred()) SWIG_fail;
55976 }
55977 {
55978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55979 }
55980 return resultobj;
55981fail:
55982 return NULL;
55983}
55984
55985
55986SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55987 PyObject *resultobj = 0;
55988 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55989 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
55990 wxWindow *arg3 = (wxWindow *) 0 ;
55991 bool result;
55992 void *argp1 = 0 ;
55993 int res1 = 0 ;
55994 void *argp2 = 0 ;
55995 int res2 = 0 ;
55996 void *argp3 = 0 ;
55997 int res3 = 0 ;
55998 PyObject * obj0 = 0 ;
55999 PyObject * obj1 = 0 ;
56000 PyObject * obj2 = 0 ;
56001 char * kwnames[] = {
56002 (char *) "self",(char *) "constraints",(char *) "win", NULL
56003 };
56004
56005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56007 if (!SWIG_IsOK(res1)) {
56008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56009 }
56010 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56011 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56012 if (!SWIG_IsOK(res2)) {
56013 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
56014 }
56015 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
56016 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56017 if (!SWIG_IsOK(res3)) {
56018 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
56019 }
56020 arg3 = reinterpret_cast< wxWindow * >(argp3);
56021 {
56022 PyThreadState* __tstate = wxPyBeginAllowThreads();
56023 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
56024 wxPyEndAllowThreads(__tstate);
56025 if (PyErr_Occurred()) SWIG_fail;
56026 }
56027 {
56028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56029 }
56030 return resultobj;
56031fail:
56032 return NULL;
56033}
56034
56035
56036SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56037 PyObject *resultobj = 0;
56038 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56039 wxEdge arg2 ;
56040 wxWindow *arg3 = (wxWindow *) 0 ;
56041 wxWindow *arg4 = (wxWindow *) 0 ;
56042 int result;
56043 void *argp1 = 0 ;
56044 int res1 = 0 ;
56045 int val2 ;
56046 int ecode2 = 0 ;
56047 void *argp3 = 0 ;
56048 int res3 = 0 ;
56049 void *argp4 = 0 ;
56050 int res4 = 0 ;
56051 PyObject * obj0 = 0 ;
56052 PyObject * obj1 = 0 ;
56053 PyObject * obj2 = 0 ;
56054 PyObject * obj3 = 0 ;
56055 char * kwnames[] = {
56056 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
56057 };
56058
56059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56061 if (!SWIG_IsOK(res1)) {
56062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56063 }
56064 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56065 ecode2 = SWIG_AsVal_int(obj1, &val2);
56066 if (!SWIG_IsOK(ecode2)) {
56067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56068 }
56069 arg2 = static_cast< wxEdge >(val2);
56070 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56071 if (!SWIG_IsOK(res3)) {
56072 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56073 }
56074 arg3 = reinterpret_cast< wxWindow * >(argp3);
56075 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56076 if (!SWIG_IsOK(res4)) {
56077 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56078 }
56079 arg4 = reinterpret_cast< wxWindow * >(argp4);
56080 {
56081 PyThreadState* __tstate = wxPyBeginAllowThreads();
56082 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56083 wxPyEndAllowThreads(__tstate);
56084 if (PyErr_Occurred()) SWIG_fail;
56085 }
56086 resultobj = SWIG_From_int(static_cast< int >(result));
56087 return resultobj;
56088fail:
56089 return NULL;
d55e5bfc
RD
56090}
56091
56092
1bd55598
RD
56093SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56094 PyObject *obj;
56095 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56096 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56097 return SWIG_Py_Void();
d55e5bfc
RD
56098}
56099
1bd55598
RD
56100SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56101 PyObject *resultobj = 0;
56102 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56103 wxIndividualLayoutConstraint *result = 0 ;
56104 void *argp1 = 0 ;
56105 int res1 = 0 ;
56106 PyObject *swig_obj[1] ;
56107
56108 if (!args) SWIG_fail;
56109 swig_obj[0] = args;
56110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56111 if (!SWIG_IsOK(res1)) {
56112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56113 }
56114 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56115 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56117 return resultobj;
56118fail:
56119 return NULL;
56120}
56121
56122
56123SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56124 PyObject *resultobj = 0;
56125 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56126 wxIndividualLayoutConstraint *result = 0 ;
56127 void *argp1 = 0 ;
56128 int res1 = 0 ;
56129 PyObject *swig_obj[1] ;
56130
56131 if (!args) SWIG_fail;
56132 swig_obj[0] = args;
56133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56134 if (!SWIG_IsOK(res1)) {
56135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56136 }
56137 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56138 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56139 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56140 return resultobj;
56141fail:
56142 return NULL;
56143}
56144
56145
56146SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56147 PyObject *resultobj = 0;
56148 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56149 wxIndividualLayoutConstraint *result = 0 ;
56150 void *argp1 = 0 ;
56151 int res1 = 0 ;
56152 PyObject *swig_obj[1] ;
56153
56154 if (!args) SWIG_fail;
56155 swig_obj[0] = args;
56156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56157 if (!SWIG_IsOK(res1)) {
56158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56159 }
56160 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56161 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56163 return resultobj;
56164fail:
56165 return NULL;
56166}
56167
56168
56169SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56170 PyObject *resultobj = 0;
56171 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56172 wxIndividualLayoutConstraint *result = 0 ;
56173 void *argp1 = 0 ;
56174 int res1 = 0 ;
56175 PyObject *swig_obj[1] ;
56176
56177 if (!args) SWIG_fail;
56178 swig_obj[0] = args;
56179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56180 if (!SWIG_IsOK(res1)) {
56181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56182 }
56183 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56184 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56186 return resultobj;
56187fail:
56188 return NULL;
56189}
56190
56191
56192SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56193 PyObject *resultobj = 0;
56194 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56195 wxIndividualLayoutConstraint *result = 0 ;
56196 void *argp1 = 0 ;
56197 int res1 = 0 ;
56198 PyObject *swig_obj[1] ;
56199
56200 if (!args) SWIG_fail;
56201 swig_obj[0] = args;
56202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56203 if (!SWIG_IsOK(res1)) {
56204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56205 }
56206 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56207 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56209 return resultobj;
56210fail:
56211 return NULL;
56212}
56213
56214
56215SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56216 PyObject *resultobj = 0;
56217 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56218 wxIndividualLayoutConstraint *result = 0 ;
56219 void *argp1 = 0 ;
56220 int res1 = 0 ;
56221 PyObject *swig_obj[1] ;
56222
56223 if (!args) SWIG_fail;
56224 swig_obj[0] = args;
56225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56226 if (!SWIG_IsOK(res1)) {
56227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56228 }
56229 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56230 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56232 return resultobj;
56233fail:
56234 return NULL;
56235}
56236
56237
56238SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56239 PyObject *resultobj = 0;
56240 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56241 wxIndividualLayoutConstraint *result = 0 ;
56242 void *argp1 = 0 ;
56243 int res1 = 0 ;
56244 PyObject *swig_obj[1] ;
56245
56246 if (!args) SWIG_fail;
56247 swig_obj[0] = args;
56248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56249 if (!SWIG_IsOK(res1)) {
56250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56251 }
56252 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56253 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56254 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56255 return resultobj;
56256fail:
56257 return NULL;
56258}
56259
56260
56261SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56262 PyObject *resultobj = 0;
56263 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56264 wxIndividualLayoutConstraint *result = 0 ;
56265 void *argp1 = 0 ;
56266 int res1 = 0 ;
56267 PyObject *swig_obj[1] ;
56268
56269 if (!args) SWIG_fail;
56270 swig_obj[0] = args;
56271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56272 if (!SWIG_IsOK(res1)) {
56273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56274 }
56275 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56276 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56278 return resultobj;
56279fail:
56280 return NULL;
d55e5bfc
RD
56281}
56282
56283
1bd55598
RD
56284SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56285 PyObject *resultobj = 0;
56286 wxLayoutConstraints *result = 0 ;
56287
56288 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56289 {
56290 PyThreadState* __tstate = wxPyBeginAllowThreads();
56291 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56292 wxPyEndAllowThreads(__tstate);
56293 if (PyErr_Occurred()) SWIG_fail;
56294 }
56295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56296 return resultobj;
56297fail:
56298 return NULL;
d55e5bfc
RD
56299}
56300
56301
1bd55598
RD
56302SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56303 PyObject *resultobj = 0;
56304 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56305 void *argp1 = 0 ;
56306 int res1 = 0 ;
56307 PyObject *swig_obj[1] ;
56308
56309 if (!args) SWIG_fail;
56310 swig_obj[0] = args;
56311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56312 if (!SWIG_IsOK(res1)) {
56313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56314 }
56315 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56316 {
56317 PyThreadState* __tstate = wxPyBeginAllowThreads();
56318 delete arg1;
d55e5bfc 56319
1bd55598
RD
56320 wxPyEndAllowThreads(__tstate);
56321 if (PyErr_Occurred()) SWIG_fail;
56322 }
56323 resultobj = SWIG_Py_Void();
56324 return resultobj;
56325fail:
56326 return NULL;
56327}
56328
56329
56330SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56331 PyObject *resultobj = 0;
56332 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56333 wxWindow *arg2 = (wxWindow *) 0 ;
56334 int *arg3 = (int *) 0 ;
56335 bool result;
56336 void *argp1 = 0 ;
56337 int res1 = 0 ;
56338 void *argp2 = 0 ;
56339 int res2 = 0 ;
56340 int temp3 ;
56341 int res3 = SWIG_TMPOBJ ;
56342 PyObject * obj0 = 0 ;
56343 PyObject * obj1 = 0 ;
56344 char * kwnames[] = {
56345 (char *) "self",(char *) "win", NULL
56346 };
56347
56348 arg3 = &temp3;
56349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56351 if (!SWIG_IsOK(res1)) {
56352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56353 }
56354 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56355 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56356 if (!SWIG_IsOK(res2)) {
56357 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56358 }
56359 arg2 = reinterpret_cast< wxWindow * >(argp2);
56360 {
56361 PyThreadState* __tstate = wxPyBeginAllowThreads();
56362 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56363 wxPyEndAllowThreads(__tstate);
56364 if (PyErr_Occurred()) SWIG_fail;
56365 }
56366 {
56367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56368 }
56369 if (SWIG_IsTmpObj(res3)) {
56370 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56371 } else {
56372 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56373 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56374 }
56375 return resultobj;
56376fail:
56377 return NULL;
d55e5bfc
RD
56378}
56379
56380
1bd55598
RD
56381SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56382 PyObject *resultobj = 0;
56383 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56384 bool result;
56385 void *argp1 = 0 ;
56386 int res1 = 0 ;
56387 PyObject *swig_obj[1] ;
56388
56389 if (!args) SWIG_fail;
56390 swig_obj[0] = args;
56391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56392 if (!SWIG_IsOK(res1)) {
56393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56394 }
56395 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56396 {
56397 PyThreadState* __tstate = wxPyBeginAllowThreads();
56398 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56399 wxPyEndAllowThreads(__tstate);
56400 if (PyErr_Occurred()) SWIG_fail;
56401 }
56402 {
56403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56404 }
56405 return resultobj;
56406fail:
56407 return NULL;
d55e5bfc
RD
56408}
56409
56410
1bd55598
RD
56411SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56412 PyObject *obj;
56413 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56414 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56415 return SWIG_Py_Void();
d55e5bfc
RD
56416}
56417
1bd55598
RD
56418SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56419 return SWIG_Python_InitShadowInstance(args);
d55e5bfc
RD
56420}
56421
1bd55598
RD
56422static PyMethodDef SwigMethods[] = {
56423 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
1bd55598
RD
56424 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56425 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
8f514ab4 56426 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
56427 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56428 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56429 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56430 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56431 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56432 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56433 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56434 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56435 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56436 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56437 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56438 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56439 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
f5263701
RD
56440 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56441 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
1eeb270e 56442 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
56443 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56444 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56445 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56446 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56447 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56448 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56449 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56450 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56451 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56452 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56453 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56454 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56455 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56456 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56457 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56458 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56459 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56460 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56461 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56462 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56463 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56464 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56465 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56466 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56467 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56468 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56469 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56470 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56471 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56472 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56473 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56474 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56475 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56476 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56477 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56478 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56479 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56480 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56481 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56482 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56483 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56484 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56485 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56486 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56487 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56488 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56489 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56490 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56491 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56492 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56493 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56494 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56495 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56496 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56497 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56498 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56499 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56500 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56501 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56502 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56503 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56504 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
5acb46e0
RD
56505 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56506 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56507 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56508 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
56509 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56510 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56511 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56512 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56513 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56514 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56515 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56516 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56517 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56518 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56519 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56520 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56521 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56522 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56523 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56524 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56525 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56526 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
33d6fd3b
RD
56527 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56528 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56529 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
56530 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56531 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56532 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56533 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56534 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56535 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56536 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56537 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56538 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56539 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56540 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56541 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56542 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56543 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56544 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56545 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56546 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56547 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
b39fe951 56548 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
1bd55598
RD
56549 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56550 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56551 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56552 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56553 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56554 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56555 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56556 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56557 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56558 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56559 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56560 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56561 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56562 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56563 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56564 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56565 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56566 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56567 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56568 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56569 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56570 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56571 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56572 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56573 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
70d7cb34
RD
56574 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56575 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56576 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56577 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56578 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56579 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56580 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56581 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56582 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56583 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56584 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56585 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56586 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56587 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56588 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56589 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56590 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56591 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56592 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56593 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56594 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56595 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56596 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56597 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56598 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56599 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56600 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56601 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56602 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56603 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56604 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56605 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56606 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56607 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56608 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56609 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56610 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56611 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56612 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56613 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56614 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56615 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56616 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56617 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56618 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56619 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56620 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56621 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56622 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56623 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56624 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56625 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56626 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56627 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56628 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56629 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56630 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56631 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56632 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56633 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
1bd55598
RD
56634 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56635 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56636 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56637 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56638 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56639 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56640 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56641 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56642 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56643 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56644 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56645 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56646 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56647 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56648 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56649 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56650 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56651 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56652 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56653 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56654 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56655 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56656 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56657 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56658 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56659 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
ac5d357a 56660 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
1bd55598
RD
56661 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56662 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56663 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56664 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56665 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56666 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
50f151d7 56667 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
1bd55598
RD
56668 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56669 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56670 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56671 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56672 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56673 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56674 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56675 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56676 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56677 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56678 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56679 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56680 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56681 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56682 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56683 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56684 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56685 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56686 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56687 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56688 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56689 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
ac5d357a 56690 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
56691 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56692 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56693 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56694 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56695 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56696 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56697 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56698 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56699 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56700 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56701 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56702 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56703 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56704 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56705 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56706 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56707 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56708 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56709 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56710 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56711 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56712 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56713 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56714 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56715 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56716 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56717 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56718 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56719 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56720 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56721 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56722 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56723 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
b02396e8 56724 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
56725 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56726 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56727 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56728 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56729 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56730 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56731 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56732 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56733 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56734 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56735 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56736 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56737 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56738 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56739 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56740 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56741 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56742 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56743 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56744 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56745 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56746 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56747 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56748 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56749 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56750 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56751 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56752 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56753 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56754 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56755 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56756 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56757 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56758 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56759 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56760 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56761 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56762 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56763 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56764 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56765 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56766 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56767 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56768 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56769 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56770 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56771 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
f5263701
RD
56772 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56773 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56774 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56775 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56776 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
56777 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56778 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56779 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56780 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56781 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56782 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56783 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56784 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56785 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56786 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56787 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56788 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56789 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56790 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56791 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56792 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56793 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56794 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56795 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56796 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56797 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56798 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56799 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56800 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56801 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56802 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
b39fe951 56803 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
1bd55598
RD
56804 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56805 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56806 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56807 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56808 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56809 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56810 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56811 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56812 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56813 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56814 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56815 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56816 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56817 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56818 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56819 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56820 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56821 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56822 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56823 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56824 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56825 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56826 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56827 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56828 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56829 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56830 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56831 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56832 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56833 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56834 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56835 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56836 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56837 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56838 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56839 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56840 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56841 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56842 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56843 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56844 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56845 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56846 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56847 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56848 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56849 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56850 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
fc46b7f3 56851 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
56852 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56853 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56854 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56855 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56856 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56857 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56858 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56859 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56860 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56861 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56862 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56863 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56864 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56865 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56866 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56867 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56868 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56869 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56870 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56871 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56872 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56873 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56874 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56875 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56876 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56877 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56878 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56879 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56880 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56881 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56882 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56883 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56884 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
580080c5
RD
56885 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
56886 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
56887 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
1bd55598
RD
56888 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56889 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56890 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56891 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56892 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56893 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56894 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56895 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56896 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56897 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56898 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56899 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56900 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56901 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56902 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56903 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56904 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56905 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56906 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56907 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56908 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56909 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56910 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56911 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56912 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56913 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56914 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56915 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56916 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56917 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56918 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56919 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56920 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56921 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56922 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56923 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56924 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56925 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56926 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56927 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56928 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56929 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56930 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56931 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56932 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56933 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56934 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56935 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56936 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56937 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56938 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56939 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56940 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56941 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56942 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56943 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56944 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56945 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56946 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56947 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56948 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56949 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56950 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56951 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56952 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56953 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
56954 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
56955 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56956 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56957 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
56958 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
56959 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56960 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
56961 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
56962 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56963 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56964 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
56965 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
56966 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56967 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
56968 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
56969 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
56970 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
56971 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
56972 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
56973 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
56974 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
56975 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
56976 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
56977 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
56978 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
56979 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
56980 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
56981 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
56982 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
56983 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
56984 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
56985 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
56986 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
56987 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
56988 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
56989 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
56990 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
56991 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
56992 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
56993 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
56994 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
56995 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
56996 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
56997 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56998 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
56999 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
57000 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
57001 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
57002 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
57003 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
57004 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
57005 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
57006 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
57007 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
57008 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
57009 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
57010 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
57011 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
57012 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
57013 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
57014 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
57015 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
57016 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
57017 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
57018 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
57019 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
57020 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
57021 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
57022 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
57023 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
57024 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
57025 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
57026 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
57027 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
57028 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
57029 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
57030 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57031 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
57032 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
57033 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57034 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
57035 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
57036 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
57037 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
57038 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57039 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
57040 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
57041 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
57042 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
57043 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
57044 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
57045 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
57046 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
57047 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
b850e7f3 57048 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
57049 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
57050 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
57051 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
57052 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
57053 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
57054 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
57055 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
57056 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
57057 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
57058 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
57059 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
57060 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
57061 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
57062 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
57063 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
57064 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
57065 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
57066 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
57067 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
57068 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57069 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57070 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57071 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57072 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57073 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57074 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57075 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57076 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57077 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57078 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57079 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57080 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57081 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57082 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57083 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57084 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57085 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57086 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57087 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57088 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57089 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57090 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57091 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57092 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57093 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57094 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57095 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57096 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57097 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57098 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57099 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57100 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57101 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57102 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57103 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57104 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57105 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57106 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57107 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57108 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57109 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57110 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57111 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57112 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57113 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57114 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57115 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57116 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57117 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57118 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57119 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57120 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57121 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57122 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57123 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57124 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57125 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57126 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57127 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57128 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57129 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57130 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57131 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57132 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57133 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57134 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57135 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57136 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57137 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57138 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57139 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57140 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57141 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57142 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57143 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57144 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57145 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57146 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57147 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57148 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57149 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57150 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57151 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57152 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57153 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57154 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57155 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57156 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57157 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57158 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57159 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57160 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57161 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57162 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57163 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57164 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57165 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57166 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57167 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57168 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57169 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57170 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57171 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57172 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57173 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57174 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57175 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57176 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57177 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57178 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57179 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
34e0a3bb
RD
57180 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57181 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57182 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
1bd55598
RD
57183 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57184 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57185 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57186 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57187 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57188 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57189 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57190 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57191 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57192 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57193 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57194 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57195 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57196 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57197 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57198 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57199 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57200 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57201 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57202 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57203 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57204 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57205 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57206 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57207 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57208 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57209 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57210 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57211 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57212 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57213 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57214 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57215 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57216 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57217 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57218 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57219 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57220 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57221 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57222 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57223 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57224 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57225 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57226 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57227 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57228 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
2131d850
RD
57229 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57230 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57231 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
1bd55598
RD
57232 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57233 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57234 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57235 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57236 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57237 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57238 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57239 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57240 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57241 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57242 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57243 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57244 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57245 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57246 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57247 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57248 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57249 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57250 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57251 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57252 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57253 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57254 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57255 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57256 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57257 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57258 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57259 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57260 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57261 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57262 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57263 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57264 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
ac5d357a 57265 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
1bd55598
RD
57266 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57267 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57268 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57269 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57270 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57271 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57272 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57273 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57274 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57275 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57276 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57277 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57278 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57279 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57280 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57281 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57282 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57283 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57284 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57285 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57286 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57287 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57288 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57289 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57290 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57291 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57292 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57293 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
33d6fd3b 57294 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
1bd55598
RD
57295 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57296 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57297 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57298 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57299 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57300 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57301 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57302 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57303 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57304 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57305 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57306 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57307 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57308 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57309 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57310 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57311 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57312 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57313 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57314 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57315 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57316 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57317 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57318 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57319 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57320 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57321 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57322 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57323 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57324 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
ac5d357a 57325 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
57326 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57327 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57328 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
ac5d357a
RD
57329 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57330 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57331 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
57332 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57333 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57334 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57335 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
b39fe951 57336 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
1bd55598
RD
57337 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57338 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57339 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57340 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57341 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57342 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57343 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57344 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57345 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57346 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57347 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57348 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57349 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57350 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57351 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57352 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57353 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57354 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57355 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57356 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57357 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57358 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57359 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57360 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57361 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57362 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57363 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57364 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57365 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57366 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57367 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
ac5d357a
RD
57368 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57369 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57370 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
57371 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57372 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57373 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57374 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57375 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57376 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
580080c5 57377 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
57378 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57379 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57380 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57381 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57382 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57383 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57384 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
1c71765a
RD
57385 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57386 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57387 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
1bd55598
RD
57388 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57389 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57390 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57391 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57392 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57393 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57394 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57395 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57396 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57397 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57398 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
580080c5 57399 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
1bd55598
RD
57400 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57401 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57402 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57403 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57404 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57405 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57406 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57407 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57408 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57409 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57410 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57411 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57412 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57413 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57414 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57415 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57416 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57417 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57418 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57419 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
cbdf0fb0 57420 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
1bd55598
RD
57421 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57422 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57423 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57424 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57425 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57426 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57427 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
33d6fd3b 57428 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
1bd55598
RD
57429 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57430 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57431 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57432 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
5917d041 57433 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
57434 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57435 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57436 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57437 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57438 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57439 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57440 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57441 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57442 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57443 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
1bd55598
RD
57444 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57445 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57446 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57447 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57448 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57449 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57450 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57451 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57452 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57453 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
704eda0c 57454 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
57455 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57456 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57457 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57458 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57459 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57460 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57461 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57462 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57463 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57464 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57465 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57466 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57467 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57468 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57469 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57470 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57471 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57472 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57473 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57474 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57475 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57476 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57477 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57478 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57479 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57480 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57481 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57482 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57483 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57484 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57485 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57486 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57487 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
33d6fd3b 57488 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
1bd55598
RD
57489 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57490 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
b39fe951 57491 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
1bd55598
RD
57492 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57493 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57494 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57495 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57496 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57497 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57498 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57499 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57500 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57501 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57502 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57503 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57504 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57505 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57506 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57507 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57508 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57509 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57510 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57511 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57512 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57513 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57514 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57515 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57516 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57517 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57518 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57519 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57520 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57521 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57522 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57523 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57524 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57525 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57526 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57527 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57528 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57529 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57530 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
1eeb270e 57531 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
1bd55598
RD
57532 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57533 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57534 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57535 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57536 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57537 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57538 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57539 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57540 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57541 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57542 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57543 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57544 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57545 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57546 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57547 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57548 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57549 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
b850e7f3 57550 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
57551 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57552 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57553 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57554 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57555 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57556 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57557 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57558 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57559 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57560 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57561 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57562 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57563 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57564 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57565 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57566 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57567 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57568 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57569 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
fc46b7f3
RD
57570 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57571 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
57572 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57573 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57574 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57575 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57576 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57577 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57578 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57579 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57580 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57581 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57582 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57583 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57584 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57585 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57586 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57587 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57588 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57589 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57590 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57591 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57592 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57593 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57594 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57595 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57596 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57597 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57598 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57599 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
da91cb0f 57600 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
57601 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57602 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57603 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57604 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57605 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57606 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57607 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57608 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57609 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57610 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57611 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57612 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57613 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57614 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57615 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57616 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57617 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57618 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57619 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57620 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57621 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57622 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57623 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57624 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57625 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57626 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57627 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57628 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57629 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57630 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57631 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57632 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57633 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57634 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57635 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57636 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57637 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57638 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57639 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57640 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57641 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57642 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57643 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57644 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57645 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57646 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57647 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57648 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57649 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57650 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57651 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57652 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57653 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57654 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57655 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57656 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57657 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57658 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57659 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57660 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57661 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57662 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57663 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57664 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57665 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57666 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57667 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57668 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57669 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57670 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57671 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57672 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57673 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57674 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57675 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57676 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
587d0f36 57677 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
1bd55598
RD
57678 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57679 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57680 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57681 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57682 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57683 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57684 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57685 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57686 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57687 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57688 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57689 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57690 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57691 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57692 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57693 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57694 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57695 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57696 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57697 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57698 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57699 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57700 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57701 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57702 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57703 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57704 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57705 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57706 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57707 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57708 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57709 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57710 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57711 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57712 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57713 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57714 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57715 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57716 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57717 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57718 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57719 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57720 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57721 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57722 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57723 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57724 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57725 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57726 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57727 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57728 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57729 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57730 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
1eeb270e 57731 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
34e0a3bb 57732 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
1bd55598 57733 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
1bd55598
RD
57734 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57735 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57736 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57737 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57738 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57739 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57740 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57741 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57742 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57743 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57744 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57745 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57746 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57747 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57748 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57749 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57750 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57751 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57752 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57753 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57754 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57755 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57756 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57757 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57758 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57759 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57760 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57761 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57762 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57763 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57764 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57765 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57766 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57767 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57768 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57769 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57770 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57771 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57772 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57773 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57774 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57775 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57776 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57777 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57778 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57779 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57780 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57781 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57782 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57783 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57784 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57785 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57786 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57787 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57788 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57789 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57790 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57791 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57792 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57793 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57794 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57795 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57796 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57797 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57798 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57799 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57800 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57801 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57802 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57803 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57804 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57805 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
ac5d357a
RD
57806 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57807 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57808 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57809 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57810 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
1bd55598
RD
57811 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57812 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57813 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57814 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57815 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57816 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57817 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57818 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57819 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57820 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57821 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57822 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57823 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57824 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57825 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57826 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57827 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57828 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57829 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57830 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57831 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57832 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57833 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57834 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57835 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57836 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57837 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57838 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57839 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57840 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57841 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57842 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57843 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57844 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57845 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57846 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57847 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57848 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57849 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57850 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57851 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57852 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57853 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57854 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57855 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57856 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57857 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57858 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57859 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57860 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57861 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57862 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57863 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57864 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57865 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57866 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57867 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57868 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57869 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57870 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57871 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57872 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57873 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57874 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57875 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57876 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57877 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57878 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57879 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57880 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57881 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57882 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57883 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57884 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57885 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57886 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57887 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57888 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57889 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57890 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57891 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57892 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57893 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57894 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57895 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57896 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57897 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57898 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57899 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57900 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57901 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57902 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57903 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57904 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57905 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57906 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57907 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57908 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57909 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57910 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57911 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57912 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57913 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57914 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57915 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57916 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57917 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57918 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57919 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57920 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57921 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57922 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57923 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57924 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57925 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57926 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57927 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57928 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57929 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57930 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57931 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57932 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57933 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57934 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57935 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57936 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57937 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57938 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57939 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57940 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57941 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57942 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57943 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57944 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57945 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57946 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57947 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57948 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57949 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57950 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57951 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57952 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57953 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
57954 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
57955 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
57956 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
57957 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
57958 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
57959 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
57960 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
57961 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
57962 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
57963 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
57964 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
57965 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57966 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
57967 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
57968 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
57969 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
57970 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
57971 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
57972 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
57973 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
57974 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
57975 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
57976 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
57977 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57978 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
57979 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
57980 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
57981 { NULL, NULL, 0, NULL }
57982};
57983
57984
57985/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
57986
57987static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
57988 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
57989}
57990static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
57991 return (void *)((wxSizer *) ((wxBoxSizer *) x));
57992}
57993static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
57994 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
57995}
57996static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
57997 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57998}
57999static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
58000 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58001}
58002static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
58003 return (void *)((wxSizer *) ((wxGridSizer *) x));
58004}
58005static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
58006 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
58007}
58008static void *_p_wxPySizerTo_p_wxSizer(void *x) {
58009 return (void *)((wxSizer *) ((wxPySizer *) x));
58010}
58011static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
58012 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
58013}
58014static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
58015 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58016}
58017static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
58018 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
58019}
58020static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
58021 return (void *)((wxEvent *) ((wxMenuEvent *) x));
58022}
58023static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
58024 return (void *)((wxEvent *) ((wxCloseEvent *) x));
58025}
58026static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
58027 return (void *)((wxEvent *) ((wxMouseEvent *) x));
58028}
58029static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
58030 return (void *)((wxEvent *) ((wxEraseEvent *) x));
58031}
58032static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
58033 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
58034}
58035static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
58036 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
58037}
58038static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
58039 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
58040}
1bd55598
RD
58041static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
58042 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
58043}
34e0a3bb
RD
58044static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
58045 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
58046}
2131d850
RD
58047static void *_p_wxPyEventTo_p_wxEvent(void *x) {
58048 return (void *)((wxEvent *) ((wxPyEvent *) x));
58049}
1bd55598
RD
58050static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
58051 return (void *)((wxEvent *) ((wxIdleEvent *) x));
58052}
58053static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
58054 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
58055}
58056static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
58057 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
58058}
58059static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
58060 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
58061}
58062static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
58063 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
58064}
58065static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
58066 return (void *)((wxEvent *) ((wxActivateEvent *) x));
58067}
58068static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
58069 return (void *)((wxEvent *) ((wxSizeEvent *) x));
58070}
58071static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58072 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58073}
58074static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58075 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58076}
58077static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58078 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58079}
58080static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58081 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58082}
34e0a3bb
RD
58083static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58084 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58085}
1bd55598
RD
58086static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58087 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58088}
58089static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58090 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58091}
58092static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58093 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58094}
58095static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58096 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58097}
58098static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58099 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58100}
58101static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58102 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58103}
58104static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58105 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58106}
58107static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58108 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58109}
58110static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58111 return (void *)((wxEvent *) ((wxShowEvent *) x));
58112}
58113static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58114 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58115}
58116static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58117 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58118}
58119static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58120 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58121}
58122static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58123 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58124}
58125static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58126 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58127}
58128static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58129 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58130}
58131static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58132 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58133}
58134static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58135 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58136}
58137static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58138 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58139}
58140static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58141 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58142}
58143static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58144 return (void *)((wxControl *) ((wxControlWithItems *) x));
58145}
58146static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58147 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58148}
58149static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58150 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58151}
58152static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58153 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58154}
58155static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58156 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58157}
58158static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58159 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58160}
58161static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58162 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58163}
58164static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58165 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58166}
58167static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58168 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58169}
58170static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58171 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58172}
58173static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58174 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58175}
58176static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58177 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58178}
58179static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58180 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58181}
58182static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58183 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58184}
58185static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58186 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58187}
58188static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58189 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58190}
58191static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58192 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58193}
58194static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58195 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58196}
58197static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58198 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58199}
58200static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58201 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58202}
58203static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58204 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58205}
58206static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58207 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58208}
58209static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58210 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58211}
58212static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58213 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58214}
58215static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58216 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58217}
58218static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58219 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58220}
58221static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58222 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58223}
580080c5
RD
58224static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
58225 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
58226}
1bd55598
RD
58227static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58228 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58229}
58230static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58231 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58232}
58233static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58234 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58235}
58236static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58237 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58238}
58239static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58240 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58241}
1bd55598
RD
58242static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58243 return (void *)((wxObject *) ((wxSizerItem *) x));
58244}
34e0a3bb
RD
58245static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58246 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58247}
1bd55598
RD
58248static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58249 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58250}
58251static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58252 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58253}
58254static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58255 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58256}
58257static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58258 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58259}
58260static void *_p_wxSizerTo_p_wxObject(void *x) {
58261 return (void *)((wxObject *) ((wxSizer *) x));
58262}
58263static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58264 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58265}
58266static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58267 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58268}
58269static void *_p_wxEventTo_p_wxObject(void *x) {
58270 return (void *)((wxObject *) ((wxEvent *) x));
58271}
58272static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58273 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58274}
58275static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58276 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58277}
58278static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58279 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58280}
2131d850
RD
58281static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58282 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58283}
1bd55598
RD
58284static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58285 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58286}
58287static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58288 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58289}
58290static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58291 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58292}
58293static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58294 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58295}
58296static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58297 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58298}
58299static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58300 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58301}
58302static void *_p_wxControlTo_p_wxObject(void *x) {
58303 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58304}
58305static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58306 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58307}
58308static void *_p_wxFSFileTo_p_wxObject(void *x) {
58309 return (void *)((wxObject *) ((wxFSFile *) x));
58310}
58311static void *_p_wxPySizerTo_p_wxObject(void *x) {
58312 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58313}
58314static void *_p_wxPyEventTo_p_wxObject(void *x) {
58315 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58316}
58317static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58318 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58319}
58320static void *_p_wxShowEventTo_p_wxObject(void *x) {
58321 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58322}
58323static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58324 return (void *)((wxObject *) ((wxMenuItem *) x));
58325}
58326static void *_p_wxDateEventTo_p_wxObject(void *x) {
58327 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58328}
58329static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58330 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58331}
58332static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58333 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58334}
58335static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58336 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58337}
58338static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58339 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58340}
58341static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58342 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58343}
58344static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58345 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58346}
58347static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58348 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58349}
58350static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58351 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58352}
58353static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58354 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58355}
58356static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58357 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58358}
58359static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58360 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58361}
58362static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58363 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58364}
58365static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58366 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58367}
58368static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58369 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58370}
58371static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58372 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58373}
58374static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58375 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58376}
58377static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58378 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58379}
58380static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58381 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58382}
58383static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58384 return (void *)((wxObject *) ((wxImageHandler *) x));
58385}
58386static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58387 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58388}
58389static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58390 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58391}
580080c5
RD
58392static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
58393 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
58394}
1bd55598
RD
58395static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58396 return (void *)((wxObject *) ((wxEvtHandler *) x));
58397}
34e0a3bb
RD
58398static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58399 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58400}
1bd55598
RD
58401static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58402 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58403}
580080c5
RD
58404static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58405 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58406}
1bd55598
RD
58407static void *_p_wxImageTo_p_wxObject(void *x) {
58408 return (void *)((wxObject *) ((wxImage *) x));
58409}
58410static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58411 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58412}
58413static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58414 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58415}
58416static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58417 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58418}
58419static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58420 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58421}
58422static void *_p_wxWindowTo_p_wxObject(void *x) {
58423 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58424}
58425static void *_p_wxMenuTo_p_wxObject(void *x) {
58426 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58427}
58428static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58429 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58430}
58431static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58432 return (void *)((wxObject *) ((wxFileSystem *) x));
58433}
58434static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58435 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58436}
58437static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58438 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58439}
58440static void *_p_wxPyAppTo_p_wxObject(void *x) {
58441 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58442}
58443static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58444 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58445}
58446static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58447 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58448}
58449static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58450 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58451}
58452static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58453 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58454}
58455static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58456 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58457}
58458static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58459 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58460}
58461static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58462 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58463}
58464static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58465 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58466}
58467static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58468 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58469}
58470static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58471 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58472}
58473static void *_p_wxValidatorTo_p_wxObject(void *x) {
58474 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58475}
58476static void *_p_wxControlTo_p_wxWindow(void *x) {
58477 return (void *)((wxWindow *) ((wxControl *) x));
58478}
58479static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58480 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58481}
58482static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58483 return (void *)((wxWindow *) ((wxMenuBar *) x));
58484}
58485static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58486 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58487}
58488static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58489 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58490}
58491static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58492 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58493}
58494static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58495 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58496}
58497static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58498 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58499}
2131d850
RD
58500static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58501 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58502}
1bd55598
RD
58503static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58504 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58505}
58506static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58507 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58508}
58509static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58510 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58511}
58512static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58513 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58514}
58515static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58516 return (void *)((wxValidator *) ((wxPyValidator *) x));
58517}
58518static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58519static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58520static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, (void*)0, 0};
58521static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58522static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58523static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58524static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58525static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58526static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58527static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58528static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58529static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58530static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58531static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58532static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58533static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58534static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58535static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58536static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58537static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58538static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
2131d850 58539static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
1bd55598
RD
58540static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58541static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58542static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58543static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58544static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58545static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58546static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58547static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58548static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58549static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58550static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
70d7cb34 58551static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
1bd55598
RD
58552static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58553static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58554static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58555static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58556static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58557static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58558static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58559static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58560static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58561static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58562static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58563static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58564static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58565static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58566static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58567static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58568static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58569static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58570static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58571static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
b850e7f3 58572static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
1bd55598
RD
58573static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58574static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58575static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58576static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58577static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58578static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58579static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58580static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58581static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58582static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58583static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58584static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58585static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58586static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58587static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58588static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58589static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58590static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58591static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58592static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58593static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58594static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58595static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58596static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
34e0a3bb 58597static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
1bd55598
RD
58598static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58599static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58600static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58601static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58602static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58603static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58604static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58605static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58606static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58607static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58608static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58609static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58610static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58611static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58612static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58613static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58614static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58615static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58616static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58617static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58618static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58619static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58620static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58621static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58622static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58623static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58624static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58625static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58626static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58627static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
70d7cb34 58628static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
1bd55598
RD
58629static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58630static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58631static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58632static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58633static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58634static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58635static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58636static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58637static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58638static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58639static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58640static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58641static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
580080c5 58642static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
1bd55598
RD
58643static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58644static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58645static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58646static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58647static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58648static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58649static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58650static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58651static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58652static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58653
58654static swig_type_info *swig_type_initial[] = {
58655 &_swigt__p_buffer,
58656 &_swigt__p_char,
58657 &_swigt__p_form_ops_t,
58658 &_swigt__p_int,
58659 &_swigt__p_long,
58660 &_swigt__p_unsigned_char,
58661 &_swigt__p_unsigned_int,
58662 &_swigt__p_unsigned_long,
58663 &_swigt__p_wxANIHandler,
58664 &_swigt__p_wxAcceleratorEntry,
58665 &_swigt__p_wxAcceleratorTable,
58666 &_swigt__p_wxActivateEvent,
58667 &_swigt__p_wxAppTraits,
58668 &_swigt__p_wxArrayString,
58669 &_swigt__p_wxBMPHandler,
58670 &_swigt__p_wxBitmap,
58671 &_swigt__p_wxBoxSizer,
58672 &_swigt__p_wxButton,
58673 &_swigt__p_wxCURHandler,
58674 &_swigt__p_wxCaret,
58675 &_swigt__p_wxChildFocusEvent,
2131d850 58676 &_swigt__p_wxClipboardTextEvent,
1bd55598
RD
58677 &_swigt__p_wxCloseEvent,
58678 &_swigt__p_wxColour,
58679 &_swigt__p_wxCommandEvent,
58680 &_swigt__p_wxContextMenuEvent,
58681 &_swigt__p_wxControl,
58682 &_swigt__p_wxControlWithItems,
58683 &_swigt__p_wxCursor,
58684 &_swigt__p_wxDC,
58685 &_swigt__p_wxDateEvent,
58686 &_swigt__p_wxDateTime,
58687 &_swigt__p_wxDisplayChangedEvent,
70d7cb34 58688 &_swigt__p_wxDouble,
1bd55598
RD
58689 &_swigt__p_wxDropFilesEvent,
58690 &_swigt__p_wxDuplexMode,
58691 &_swigt__p_wxEraseEvent,
58692 &_swigt__p_wxEvent,
58693 &_swigt__p_wxEventLoop,
58694 &_swigt__p_wxEventLoopActivator,
58695 &_swigt__p_wxEvtHandler,
58696 &_swigt__p_wxFSFile,
58697 &_swigt__p_wxFileSystem,
58698 &_swigt__p_wxFileSystemHandler,
58699 &_swigt__p_wxFlexGridSizer,
58700 &_swigt__p_wxFocusEvent,
58701 &_swigt__p_wxFont,
58702 &_swigt__p_wxFrame,
58703 &_swigt__p_wxGBPosition,
58704 &_swigt__p_wxGBSizerItem,
58705 &_swigt__p_wxGBSpan,
58706 &_swigt__p_wxGIFHandler,
58707 &_swigt__p_wxGridBagSizer,
58708 &_swigt__p_wxGridSizer,
b850e7f3 58709 &_swigt__p_wxHelpEvent__Origin,
1bd55598
RD
58710 &_swigt__p_wxICOHandler,
58711 &_swigt__p_wxIconizeEvent,
58712 &_swigt__p_wxIdleEvent,
58713 &_swigt__p_wxImage,
58714 &_swigt__p_wxImageHandler,
58715 &_swigt__p_wxImageHistogram,
58716 &_swigt__p_wxImage_HSVValue,
58717 &_swigt__p_wxImage_RGBValue,
58718 &_swigt__p_wxIndividualLayoutConstraint,
58719 &_swigt__p_wxInitDialogEvent,
58720 &_swigt__p_wxInputStream,
58721 &_swigt__p_wxInternetFSHandler,
58722 &_swigt__p_wxItemContainer,
58723 &_swigt__p_wxJPEGHandler,
58724 &_swigt__p_wxKeyEvent,
58725 &_swigt__p_wxLayoutConstraints,
58726 &_swigt__p_wxMaximizeEvent,
58727 &_swigt__p_wxMemoryFSHandler,
58728 &_swigt__p_wxMenu,
58729 &_swigt__p_wxMenuBar,
58730 &_swigt__p_wxMenuBarBase,
58731 &_swigt__p_wxMenuEvent,
58732 &_swigt__p_wxMenuItem,
58733 &_swigt__p_wxMouseCaptureChangedEvent,
34e0a3bb 58734 &_swigt__p_wxMouseCaptureLostEvent,
1bd55598
RD
58735 &_swigt__p_wxMouseEvent,
58736 &_swigt__p_wxMoveEvent,
58737 &_swigt__p_wxNavigationKeyEvent,
58738 &_swigt__p_wxNcPaintEvent,
58739 &_swigt__p_wxNotifyEvent,
58740 &_swigt__p_wxObject,
58741 &_swigt__p_wxOutputStream,
58742 &_swigt__p_wxPCXHandler,
58743 &_swigt__p_wxPNGHandler,
58744 &_swigt__p_wxPNMHandler,
58745 &_swigt__p_wxPaintEvent,
58746 &_swigt__p_wxPaletteChangedEvent,
58747 &_swigt__p_wxPaperSize,
58748 &_swigt__p_wxPoint,
58749 &_swigt__p_wxPoint2D,
58750 &_swigt__p_wxPropagateOnce,
58751 &_swigt__p_wxPropagationDisabler,
58752 &_swigt__p_wxPyApp,
58753 &_swigt__p_wxPyCommandEvent,
58754 &_swigt__p_wxPyDropTarget,
58755 &_swigt__p_wxPyEvent,
58756 &_swigt__p_wxPyFileSystemHandler,
58757 &_swigt__p_wxPyImageHandler,
58758 &_swigt__p_wxPyInputStream,
58759 &_swigt__p_wxPySizer,
58760 &_swigt__p_wxPyValidator,
58761 &_swigt__p_wxQuantize,
58762 &_swigt__p_wxQueryNewPaletteEvent,
58763 &_swigt__p_wxRealPoint,
58764 &_swigt__p_wxRect,
70d7cb34 58765 &_swigt__p_wxRect2D,
1bd55598
RD
58766 &_swigt__p_wxRegion,
58767 &_swigt__p_wxScrollEvent,
58768 &_swigt__p_wxScrollWinEvent,
58769 &_swigt__p_wxSetCursorEvent,
58770 &_swigt__p_wxShowEvent,
58771 &_swigt__p_wxSize,
58772 &_swigt__p_wxSizeEvent,
58773 &_swigt__p_wxSizer,
58774 &_swigt__p_wxSizerItem,
58775 &_swigt__p_wxStaticBox,
58776 &_swigt__p_wxStaticBoxSizer,
58777 &_swigt__p_wxStdDialogButtonSizer,
58778 &_swigt__p_wxSysColourChangedEvent,
580080c5 58779 &_swigt__p_wxTGAHandler,
1bd55598
RD
58780 &_swigt__p_wxTIFFHandler,
58781 &_swigt__p_wxToolTip,
58782 &_swigt__p_wxUpdateUIEvent,
58783 &_swigt__p_wxValidator,
58784 &_swigt__p_wxVisualAttributes,
58785 &_swigt__p_wxWindow,
58786 &_swigt__p_wxWindowCreateEvent,
58787 &_swigt__p_wxWindowDestroyEvent,
58788 &_swigt__p_wxXPMHandler,
58789 &_swigt__p_wxZipFSHandler,
58790};
58791
58792static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58793static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58794static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58795static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58796static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58797static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58798static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58799static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58800static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58801static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58802static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58803static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58804static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58805static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58806static 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}};
58807static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58808static 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}};
58809static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58810static 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}};
58811static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58812static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
2131d850 58813static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
1bd55598
RD
58814static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58815static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
2131d850 58816static 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}};
1bd55598
RD
58817static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58818static 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}};
58819static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58820static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58821static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58822static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58823static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58824static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
70d7cb34 58825static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
1bd55598
RD
58826static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58827static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58828static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
34e0a3bb 58829static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
1bd55598
RD
58830static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58831static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58832static 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}};
58833static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58834static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58835static 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}};
58836static 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}};
58837static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58838static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58839static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58840static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58841static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58842static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58843static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58844static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58845static 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}};
b850e7f3 58846static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
1bd55598
RD
58847static 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}};
58848static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58849static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58850static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
580080c5 58851static swig_cast_info _swigc__p_wxImageHandler[] = { {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
1bd55598
RD
58852static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58853static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58854static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58855static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58856static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58857static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58858static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58859static 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}};
58860static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58861static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58862static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58863static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58864static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58865static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58866static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58867static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58868static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58869static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58870static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
34e0a3bb 58871static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
1bd55598
RD
58872static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58873static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58874static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58875static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58876static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
580080c5 58877static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
1bd55598
RD
58878static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58879static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58880static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58881static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58882static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58883static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58884static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58885static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58886static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58887static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58888static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58889static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58890static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58891static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58892static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58893static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58894static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58895static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58896static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58897static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58898static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58899static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58900static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58901static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
70d7cb34 58902static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
1bd55598
RD
58903static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58904static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58905static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58906static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58907static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58908static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58909static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58910static 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}};
58911static 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}};
58912static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58913static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58914static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58915static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
580080c5 58916static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
1bd55598
RD
58917static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58918static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58919static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58920static 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}};
58921static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58922static 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}};
58923static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58924static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58925static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58926static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58927
58928static swig_cast_info *swig_cast_initial[] = {
58929 _swigc__p_buffer,
58930 _swigc__p_char,
58931 _swigc__p_form_ops_t,
58932 _swigc__p_int,
58933 _swigc__p_long,
58934 _swigc__p_unsigned_char,
58935 _swigc__p_unsigned_int,
58936 _swigc__p_unsigned_long,
58937 _swigc__p_wxANIHandler,
58938 _swigc__p_wxAcceleratorEntry,
58939 _swigc__p_wxAcceleratorTable,
58940 _swigc__p_wxActivateEvent,
58941 _swigc__p_wxAppTraits,
58942 _swigc__p_wxArrayString,
58943 _swigc__p_wxBMPHandler,
58944 _swigc__p_wxBitmap,
58945 _swigc__p_wxBoxSizer,
58946 _swigc__p_wxButton,
58947 _swigc__p_wxCURHandler,
58948 _swigc__p_wxCaret,
58949 _swigc__p_wxChildFocusEvent,
2131d850 58950 _swigc__p_wxClipboardTextEvent,
1bd55598
RD
58951 _swigc__p_wxCloseEvent,
58952 _swigc__p_wxColour,
58953 _swigc__p_wxCommandEvent,
58954 _swigc__p_wxContextMenuEvent,
58955 _swigc__p_wxControl,
58956 _swigc__p_wxControlWithItems,
58957 _swigc__p_wxCursor,
58958 _swigc__p_wxDC,
58959 _swigc__p_wxDateEvent,
58960 _swigc__p_wxDateTime,
58961 _swigc__p_wxDisplayChangedEvent,
70d7cb34 58962 _swigc__p_wxDouble,
1bd55598
RD
58963 _swigc__p_wxDropFilesEvent,
58964 _swigc__p_wxDuplexMode,
58965 _swigc__p_wxEraseEvent,
58966 _swigc__p_wxEvent,
58967 _swigc__p_wxEventLoop,
58968 _swigc__p_wxEventLoopActivator,
58969 _swigc__p_wxEvtHandler,
58970 _swigc__p_wxFSFile,
58971 _swigc__p_wxFileSystem,
58972 _swigc__p_wxFileSystemHandler,
58973 _swigc__p_wxFlexGridSizer,
58974 _swigc__p_wxFocusEvent,
58975 _swigc__p_wxFont,
58976 _swigc__p_wxFrame,
58977 _swigc__p_wxGBPosition,
58978 _swigc__p_wxGBSizerItem,
58979 _swigc__p_wxGBSpan,
58980 _swigc__p_wxGIFHandler,
58981 _swigc__p_wxGridBagSizer,
58982 _swigc__p_wxGridSizer,
b850e7f3 58983 _swigc__p_wxHelpEvent__Origin,
1bd55598
RD
58984 _swigc__p_wxICOHandler,
58985 _swigc__p_wxIconizeEvent,
58986 _swigc__p_wxIdleEvent,
58987 _swigc__p_wxImage,
58988 _swigc__p_wxImageHandler,
58989 _swigc__p_wxImageHistogram,
58990 _swigc__p_wxImage_HSVValue,
58991 _swigc__p_wxImage_RGBValue,
58992 _swigc__p_wxIndividualLayoutConstraint,
58993 _swigc__p_wxInitDialogEvent,
58994 _swigc__p_wxInputStream,
58995 _swigc__p_wxInternetFSHandler,
58996 _swigc__p_wxItemContainer,
58997 _swigc__p_wxJPEGHandler,
58998 _swigc__p_wxKeyEvent,
58999 _swigc__p_wxLayoutConstraints,
59000 _swigc__p_wxMaximizeEvent,
59001 _swigc__p_wxMemoryFSHandler,
59002 _swigc__p_wxMenu,
59003 _swigc__p_wxMenuBar,
59004 _swigc__p_wxMenuBarBase,
59005 _swigc__p_wxMenuEvent,
59006 _swigc__p_wxMenuItem,
59007 _swigc__p_wxMouseCaptureChangedEvent,
34e0a3bb 59008 _swigc__p_wxMouseCaptureLostEvent,
1bd55598
RD
59009 _swigc__p_wxMouseEvent,
59010 _swigc__p_wxMoveEvent,
59011 _swigc__p_wxNavigationKeyEvent,
59012 _swigc__p_wxNcPaintEvent,
59013 _swigc__p_wxNotifyEvent,
59014 _swigc__p_wxObject,
59015 _swigc__p_wxOutputStream,
59016 _swigc__p_wxPCXHandler,
59017 _swigc__p_wxPNGHandler,
59018 _swigc__p_wxPNMHandler,
59019 _swigc__p_wxPaintEvent,
59020 _swigc__p_wxPaletteChangedEvent,
59021 _swigc__p_wxPaperSize,
59022 _swigc__p_wxPoint,
59023 _swigc__p_wxPoint2D,
59024 _swigc__p_wxPropagateOnce,
59025 _swigc__p_wxPropagationDisabler,
59026 _swigc__p_wxPyApp,
59027 _swigc__p_wxPyCommandEvent,
59028 _swigc__p_wxPyDropTarget,
59029 _swigc__p_wxPyEvent,
59030 _swigc__p_wxPyFileSystemHandler,
59031 _swigc__p_wxPyImageHandler,
59032 _swigc__p_wxPyInputStream,
59033 _swigc__p_wxPySizer,
59034 _swigc__p_wxPyValidator,
59035 _swigc__p_wxQuantize,
59036 _swigc__p_wxQueryNewPaletteEvent,
59037 _swigc__p_wxRealPoint,
59038 _swigc__p_wxRect,
70d7cb34 59039 _swigc__p_wxRect2D,
1bd55598
RD
59040 _swigc__p_wxRegion,
59041 _swigc__p_wxScrollEvent,
59042 _swigc__p_wxScrollWinEvent,
59043 _swigc__p_wxSetCursorEvent,
59044 _swigc__p_wxShowEvent,
59045 _swigc__p_wxSize,
59046 _swigc__p_wxSizeEvent,
59047 _swigc__p_wxSizer,
59048 _swigc__p_wxSizerItem,
59049 _swigc__p_wxStaticBox,
59050 _swigc__p_wxStaticBoxSizer,
59051 _swigc__p_wxStdDialogButtonSizer,
59052 _swigc__p_wxSysColourChangedEvent,
580080c5 59053 _swigc__p_wxTGAHandler,
1bd55598
RD
59054 _swigc__p_wxTIFFHandler,
59055 _swigc__p_wxToolTip,
59056 _swigc__p_wxUpdateUIEvent,
59057 _swigc__p_wxValidator,
59058 _swigc__p_wxVisualAttributes,
59059 _swigc__p_wxWindow,
59060 _swigc__p_wxWindowCreateEvent,
59061 _swigc__p_wxWindowDestroyEvent,
59062 _swigc__p_wxXPMHandler,
59063 _swigc__p_wxZipFSHandler,
59064};
59065
59066
59067/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
59068
59069static swig_const_info swig_const_table[] = {
59070{0, 0, 0, 0.0, 0, 0}};
59071
59072#ifdef __cplusplus
59073}
59074#endif
59075/* -----------------------------------------------------------------------------
59076 * Type initialization:
59077 * This problem is tough by the requirement that no dynamic
59078 * memory is used. Also, since swig_type_info structures store pointers to
59079 * swig_cast_info structures and swig_cast_info structures store pointers back
59080 * to swig_type_info structures, we need some lookup code at initialization.
59081 * The idea is that swig generates all the structures that are needed.
59082 * The runtime then collects these partially filled structures.
59083 * The SWIG_InitializeModule function takes these initial arrays out of
59084 * swig_module, and does all the lookup, filling in the swig_module.types
59085 * array with the correct data and linking the correct swig_cast_info
59086 * structures together.
59087 *
59088 * The generated swig_type_info structures are assigned staticly to an initial
59089 * array. We just loop though that array, and handle each type individually.
59090 * First we lookup if this type has been already loaded, and if so, use the
59091 * loaded structure instead of the generated one. Then we have to fill in the
59092 * cast linked list. The cast data is initially stored in something like a
59093 * two-dimensional array. Each row corresponds to a type (there are the same
59094 * number of rows as there are in the swig_type_initial array). Each entry in
59095 * a column is one of the swig_cast_info structures for that type.
59096 * The cast_initial array is actually an array of arrays, because each row has
59097 * a variable number of columns. So to actually build the cast linked list,
59098 * we find the array of casts associated with the type, and loop through it
59099 * adding the casts to the list. The one last trick we need to do is making
59100 * sure the type pointer in the swig_cast_info struct is correct.
59101 *
59102 * First off, we lookup the cast->type name to see if it is already loaded.
59103 * There are three cases to handle:
59104 * 1) If the cast->type has already been loaded AND the type we are adding
59105 * casting info to has not been loaded (it is in this module), THEN we
59106 * replace the cast->type pointer with the type pointer that has already
59107 * been loaded.
59108 * 2) If BOTH types (the one we are adding casting info to, and the
59109 * cast->type) are loaded, THEN the cast info has already been loaded by
59110 * the previous module so we just ignore it.
59111 * 3) Finally, if cast->type has not already been loaded, then we add that
59112 * swig_cast_info to the linked list (because the cast->type) pointer will
59113 * be correct.
59114 * ----------------------------------------------------------------------------- */
59115
59116#ifdef __cplusplus
59117extern "C" {
59118#if 0
59119} /* c-mode */
59120#endif
59121#endif
59122
59123#if 0
59124#define SWIGRUNTIME_DEBUG
59125#endif
59126
59127SWIGRUNTIME void
59128SWIG_InitializeModule(void *clientdata) {
59129 size_t i;
59130 swig_module_info *module_head;
59131 static int init_run = 0;
59132
59133 clientdata = clientdata;
59134
59135 if (init_run) return;
59136 init_run = 1;
59137
59138 /* Initialize the swig_module */
59139 swig_module.type_initial = swig_type_initial;
59140 swig_module.cast_initial = swig_cast_initial;
59141
59142 /* Try and load any already created modules */
59143 module_head = SWIG_GetModule(clientdata);
59144 if (module_head) {
59145 swig_module.next = module_head->next;
59146 module_head->next = &swig_module;
59147 } else {
59148 /* This is the first module loaded */
59149 swig_module.next = &swig_module;
59150 SWIG_SetModule(clientdata, &swig_module);
59151 }
59152
59153 /* Now work on filling in swig_module.types */
59154#ifdef SWIGRUNTIME_DEBUG
59155 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59156#endif
59157 for (i = 0; i < swig_module.size; ++i) {
59158 swig_type_info *type = 0;
59159 swig_type_info *ret;
59160 swig_cast_info *cast;
59161
59162#ifdef SWIGRUNTIME_DEBUG
59163 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59164#endif
59165
59166 /* if there is another module already loaded */
59167 if (swig_module.next != &swig_module) {
59168 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
36ed4f51 59169 }
1bd55598
RD
59170 if (type) {
59171 /* Overwrite clientdata field */
59172#ifdef SWIGRUNTIME_DEBUG
59173 printf("SWIG_InitializeModule: found type %s\n", type->name);
59174#endif
59175 if (swig_module.type_initial[i]->clientdata) {
59176 type->clientdata = swig_module.type_initial[i]->clientdata;
59177#ifdef SWIGRUNTIME_DEBUG
59178 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59179#endif
59180 }
59181 } else {
59182 type = swig_module.type_initial[i];
36ed4f51 59183 }
1bd55598
RD
59184
59185 /* Insert casting types */
59186 cast = swig_module.cast_initial[i];
59187 while (cast->type) {
59188 /* Don't need to add information already in the list */
59189 ret = 0;
59190#ifdef SWIGRUNTIME_DEBUG
59191 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59192#endif
59193 if (swig_module.next != &swig_module) {
59194 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59195#ifdef SWIGRUNTIME_DEBUG
59196 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59197#endif
59198 }
59199 if (ret) {
59200 if (type == swig_module.type_initial[i]) {
59201#ifdef SWIGRUNTIME_DEBUG
59202 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59203#endif
59204 cast->type = ret;
59205 ret = 0;
59206 } else {
59207 /* Check for casting already in the list */
59208 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59209#ifdef SWIGRUNTIME_DEBUG
59210 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59211#endif
59212 if (!ocast) ret = 0;
59213 }
59214 }
59215
59216 if (!ret) {
59217#ifdef SWIGRUNTIME_DEBUG
59218 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59219#endif
59220 if (type->cast) {
59221 type->cast->prev = cast;
59222 cast->next = type->cast;
59223 }
59224 type->cast = cast;
59225 }
59226 cast++;
36ed4f51 59227 }
1bd55598
RD
59228 /* Set entry in modules->types array equal to the type */
59229 swig_module.types[i] = type;
59230 }
59231 swig_module.types[i] = 0;
59232
59233#ifdef SWIGRUNTIME_DEBUG
59234 printf("**** SWIG_InitializeModule: Cast List ******\n");
59235 for (i = 0; i < swig_module.size; ++i) {
59236 int j = 0;
59237 swig_cast_info *cast = swig_module.cast_initial[i];
59238 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59239 while (cast->type) {
59240 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59241 cast++;
59242 ++j;
59243 }
59244 printf("---- Total casts: %d\n",j);
59245 }
59246 printf("**** SWIG_InitializeModule: Cast List ******\n");
59247#endif
59248}
59249
59250/* This function will propagate the clientdata field of type to
59251* any new swig_type_info structures that have been added into the list
59252* of equivalent types. It is like calling
59253* SWIG_TypeClientData(type, clientdata) a second time.
59254*/
59255SWIGRUNTIME void
59256SWIG_PropagateClientData(void) {
59257 size_t i;
59258 swig_cast_info *equiv;
59259 static int init_run = 0;
59260
59261 if (init_run) return;
59262 init_run = 1;
59263
59264 for (i = 0; i < swig_module.size; i++) {
59265 if (swig_module.types[i]->clientdata) {
59266 equiv = swig_module.types[i]->cast;
59267 while (equiv) {
59268 if (!equiv->converter) {
59269 if (equiv->type && !equiv->type->clientdata)
59270 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59271 }
59272 equiv = equiv->next;
59273 }
36ed4f51 59274 }
1bd55598
RD
59275 }
59276}
59277
59278#ifdef __cplusplus
59279#if 0
59280{
59281 /* c-mode */
59282#endif
59283}
59284#endif
59285
59286
59287
59288#ifdef __cplusplus
59289extern "C" {
59290#endif
59291
59292 /* Python-specific SWIG API */
59293#define SWIG_newvarlink() SWIG_Python_newvarlink()
59294#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59295#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59296
59297 /* -----------------------------------------------------------------------------
59298 * global variable support code.
59299 * ----------------------------------------------------------------------------- */
59300
59301 typedef struct swig_globalvar {
59302 char *name; /* Name of global variable */
59303 PyObject *(*get_attr)(void); /* Return the current value */
59304 int (*set_attr)(PyObject *); /* Set the value */
59305 struct swig_globalvar *next;
59306 } swig_globalvar;
59307
59308 typedef struct swig_varlinkobject {
59309 PyObject_HEAD
59310 swig_globalvar *vars;
59311 } swig_varlinkobject;
59312
59313 SWIGINTERN PyObject *
59314 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59315 return PyString_FromString("<Swig global variables>");
59316 }
59317
59318 SWIGINTERN PyObject *
59319 swig_varlink_str(swig_varlinkobject *v) {
59320 PyObject *str = PyString_FromString("(");
59321 swig_globalvar *var;
59322 for (var = v->vars; var; var=var->next) {
59323 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59324 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59325 }
59326 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59327 return str;
59328 }
59329
59330 SWIGINTERN int
59331 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59332 PyObject *str = swig_varlink_str(v);
59333 fprintf(fp,"Swig global variables ");
59334 fprintf(fp,"%s\n", PyString_AsString(str));
59335 Py_DECREF(str);
59336 return 0;
59337 }
59338
59339 SWIGINTERN void
59340 swig_varlink_dealloc(swig_varlinkobject *v) {
59341 swig_globalvar *var = v->vars;
59342 while (var) {
59343 swig_globalvar *n = var->next;
59344 free(var->name);
59345 free(var);
59346 var = n;
36ed4f51 59347 }
1bd55598
RD
59348 }
59349
59350 SWIGINTERN PyObject *
59351 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59352 PyObject *res = NULL;
59353 swig_globalvar *var = v->vars;
59354 while (var) {
59355 if (strcmp(var->name,n) == 0) {
59356 res = (*var->get_attr)();
59357 break;
59358 }
59359 var = var->next;
36ed4f51 59360 }
1bd55598
RD
59361 if (res == NULL && !PyErr_Occurred()) {
59362 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
36ed4f51 59363 }
1bd55598
RD
59364 return res;
59365 }
59366
59367 SWIGINTERN int
59368 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59369 int res = 1;
59370 swig_globalvar *var = v->vars;
59371 while (var) {
59372 if (strcmp(var->name,n) == 0) {
59373 res = (*var->set_attr)(p);
59374 break;
59375 }
59376 var = var->next;
36ed4f51 59377 }
1bd55598
RD
59378 if (res == 1 && !PyErr_Occurred()) {
59379 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
36ed4f51 59380 }
1bd55598
RD
59381 return res;
59382 }
59383
59384 SWIGINTERN PyTypeObject*
59385 swig_varlink_type(void) {
59386 static char varlink__doc__[] = "Swig var link object";
59387 static PyTypeObject varlink_type;
59388 static int type_init = 0;
59389 if (!type_init) {
59390 const PyTypeObject tmp
59391 = {
59392 PyObject_HEAD_INIT(NULL)
59393 0, /* Number of items in variable part (ob_size) */
59394 (char *)"swigvarlink", /* Type name (tp_name) */
59395 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59396 0, /* Itemsize (tp_itemsize) */
59397 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59398 (printfunc) swig_varlink_print, /* Print (tp_print) */
59399 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59400 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59401 0, /* tp_compare */
59402 (reprfunc) swig_varlink_repr, /* tp_repr */
59403 0, /* tp_as_number */
59404 0, /* tp_as_sequence */
59405 0, /* tp_as_mapping */
59406 0, /* tp_hash */
59407 0, /* tp_call */
59408 (reprfunc)swig_varlink_str, /* tp_str */
59409 0, /* tp_getattro */
59410 0, /* tp_setattro */
59411 0, /* tp_as_buffer */
59412 0, /* tp_flags */
59413 varlink__doc__, /* tp_doc */
59414 0, /* tp_traverse */
59415 0, /* tp_clear */
59416 0, /* tp_richcompare */
59417 0, /* tp_weaklistoffset */
59418#if PY_VERSION_HEX >= 0x02020000
59419 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59420#endif
59421#if PY_VERSION_HEX >= 0x02030000
59422 0, /* tp_del */
59423#endif
59424#ifdef COUNT_ALLOCS
59425 0,0,0,0 /* tp_alloc -> tp_next */
59426#endif
59427 };
59428 varlink_type = tmp;
59429 varlink_type.ob_type = &PyType_Type;
59430 type_init = 1;
36ed4f51 59431 }
1bd55598
RD
59432 return &varlink_type;
59433 }
59434
59435 /* Create a variable linking object for use later */
59436 SWIGINTERN PyObject *
59437 SWIG_Python_newvarlink(void) {
59438 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59439 if (result) {
59440 result->vars = 0;
59441 }
59442 return ((PyObject*) result);
59443 }
59444
59445 SWIGINTERN void
59446 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59447 swig_varlinkobject *v = (swig_varlinkobject *) p;
59448 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59449 if (gv) {
59450 size_t size = strlen(name)+1;
59451 gv->name = (char *)malloc(size);
59452 if (gv->name) {
59453 strncpy(gv->name,name,size);
59454 gv->get_attr = get_attr;
59455 gv->set_attr = set_attr;
59456 gv->next = v->vars;
59457 }
36ed4f51 59458 }
1bd55598
RD
59459 v->vars = gv;
59460 }
59461
59462 SWIGINTERN PyObject *
59463 SWIG_globals() {
59464 static PyObject *_SWIG_globals = 0;
59465 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59466 return _SWIG_globals;
59467 }
59468
59469 /* -----------------------------------------------------------------------------
59470 * constants/methods manipulation
59471 * ----------------------------------------------------------------------------- */
59472
59473 /* Install Constants */
59474 SWIGINTERN void
59475 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59476 PyObject *obj = 0;
59477 size_t i;
59478 for (i = 0; constants[i].type; ++i) {
59479 switch(constants[i].type) {
59480 case SWIG_PY_POINTER:
59481 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59482 break;
59483 case SWIG_PY_BINARY:
59484 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59485 break;
59486 default:
59487 obj = 0;
59488 break;
59489 }
59490 if (obj) {
59491 PyDict_SetItemString(d, constants[i].name, obj);
59492 Py_DECREF(obj);
59493 }
36ed4f51 59494 }
1bd55598
RD
59495 }
59496
59497 /* -----------------------------------------------------------------------------*/
59498 /* Fix SwigMethods to carry the callback ptrs when needed */
59499 /* -----------------------------------------------------------------------------*/
59500
59501 SWIGINTERN void
59502 SWIG_Python_FixMethods(PyMethodDef *methods,
59503 swig_const_info *const_table,
59504 swig_type_info **types,
59505 swig_type_info **types_initial) {
59506 size_t i;
59507 for (i = 0; methods[i].ml_name; ++i) {
3d6c9062 59508 const char *c = methods[i].ml_doc;
1bd55598
RD
59509 if (c && (c = strstr(c, "swig_ptr: "))) {
59510 int j;
59511 swig_const_info *ci = 0;
3d6c9062 59512 const char *name = c + 10;
1bd55598
RD
59513 for (j = 0; const_table[j].type; ++j) {
59514 if (strncmp(const_table[j].name, name,
59515 strlen(const_table[j].name)) == 0) {
59516 ci = &(const_table[j]);
59517 break;
59518 }
59519 }
59520 if (ci) {
59521 size_t shift = (ci->ptype) - types;
59522 swig_type_info *ty = types_initial[shift];
59523 size_t ldoc = (c - methods[i].ml_doc);
59524 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59525 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59526 if (ndoc) {
59527 char *buff = ndoc;
59528 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59529 if (ptr) {
59530 strncpy(buff, methods[i].ml_doc, ldoc);
59531 buff += ldoc;
59532 strncpy(buff, "swig_ptr: ", 10);
59533 buff += 10;
59534 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59535 methods[i].ml_doc = ndoc;
59536 }
59537 }
59538 }
59539 }
36ed4f51 59540 }
1bd55598
RD
59541 }
59542
59543#ifdef __cplusplus
59544}
59545#endif
59546
59547/* -----------------------------------------------------------------------------*
59548 * Partial Init method
59549 * -----------------------------------------------------------------------------*/
59550
59551#ifdef __cplusplus
59552extern "C"
59553#endif
59554SWIGEXPORT void SWIG_init(void) {
59555 PyObject *m, *d;
59556
59557 /* Fix SwigMethods to carry the callback ptrs when needed */
59558 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59559
59560 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59561 d = PyModule_GetDict(m);
59562
59563 SWIG_InitializeModule(0);
59564 SWIG_InstallConstants(d,swig_const_table);
59565
59566
59567
59568#ifndef wxPyUSE_EXPORT
59569 // Make our API structure a CObject so other modules can import it
59570 // from this module.
59571 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59572 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59573 Py_XDECREF(cobj);
59574#endif
59575
59576 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59577 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59578 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59579 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59580 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59581 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59582 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59583 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59584 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59585 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59586 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59587 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59588 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59589 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59590 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59591 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59592 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59593 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59594 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59595 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59596 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59597 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
092f0ed7 59598 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
1bd55598
RD
59599 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59600 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59601 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59602 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59603 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59604 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59605 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59606 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59607 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59608 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59609 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59610 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59611 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59612 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59613 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59614 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59615 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59616 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59617 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59618 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59619 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59620 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59621 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59622 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59623 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59624 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59625 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59626 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59627 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59628 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59629 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
e9d6f3a4
RD
59630 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59631 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
1bd55598
RD
59632 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59633 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59634 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59635 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59636 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59637 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59638 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59639 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59640 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59641 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59642 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59643 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59644 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59645 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59646 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59647 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59648 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59649 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59650 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59651 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59652 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59653 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59654 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59655 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59656 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59657 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59658 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59659 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59660 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59661 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59662 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59663 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59664 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59665 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59666 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59667 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59668 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59669 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59670 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59671 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59672 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59673 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59674 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59675 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59676 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59677 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59678 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59679 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59680 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59681 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59682 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59683 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59684 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59685 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59686 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59687 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59688 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59689 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
fc46b7f3 59690 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
1bd55598
RD
59691 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59692 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59693 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59694 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59695 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59696 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
1eeb270e
RD
59697 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59698 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
1bd55598
RD
59699 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59700 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
ac5d357a 59701 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
1bd55598
RD
59702 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59703 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59704 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59705 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59706 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59707 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59708 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59709 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59710 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59711 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59712 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59713 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59714 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59715 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59716 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59717 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59718 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59719 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59720 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
ac5d357a 59721 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
1bd55598
RD
59722 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59723 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59724 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59725 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59726 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59727 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59728 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59729 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59730 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59731 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59732 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59733 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59734 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59735 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59736 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59737 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59738 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59739 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59740 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59741 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59742 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59743 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59744 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59745 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59746 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59747 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59748 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59749 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59750 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59751 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59752 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59753 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59754 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59755 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59756 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59757 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59758 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59759 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59760 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59761 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59762 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59763 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59764 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59765 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59766 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59767 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59768 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59769 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59770 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59771 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59772 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
1bd55598
RD
59773 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59774 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59775 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59776 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59777 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59778 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59779 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59780 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59781 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59782 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59783 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59784 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59785 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59786 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59787 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59788 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59789 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59790 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59791 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59792 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59793 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59794 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59795 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59796 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59797 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59798 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59799 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59800 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59801 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59802 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59803 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59804 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59805 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59806 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59807 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59808 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59809 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59810 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59811 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59812 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59813 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59814 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59815 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59816 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59817 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59818 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59819 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59820 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59821 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59822 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59823 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59824 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59825 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59826 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59827 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59828 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59829 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59830 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59831 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59832 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59833 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59834 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59835 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59836 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59837 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59838 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59839 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59840 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59841 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59842 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59843 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59844 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59845 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59846 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59847 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59848 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59849 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59850 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59851 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59852 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59853 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59854 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59855 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59856 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59857 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59858 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59859 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59860 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59861 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59862 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59863 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59864 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59865 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59866 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59867 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59868 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59869 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59870 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59871 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59872 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59873 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59874 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59875 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59876 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59877 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59878 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59879 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59880 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59881 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59882 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59883 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59884 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59885 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59886 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59887 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59888 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59889 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59890 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59891 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59892 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59893 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59894 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59895 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59896 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59897 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59898 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59899 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59900 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59901 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59902 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59903 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59904 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59905 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59906 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59907 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59908 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59909 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59910 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59911 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59912 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59913 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59914 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59915 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59916 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59917 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59918 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59919 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59920 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59921 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59922 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59923 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59924 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59925 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59926 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59927 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59928 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59929 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59930 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59931 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59932 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59933 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59934 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59935 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59936 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59937 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59938 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59939 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59940 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59941 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59942 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59943 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59944 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59945 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59946 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59947 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59948 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59949 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59950 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59951 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59952 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59953 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
59954 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
59955 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
59956 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
59957 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
59958 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
59959 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
59960 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
59961 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
59962 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
59963 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
59964 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
59965 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
59966 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
59967 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
59968 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
59969 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
59970 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
59971 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
59972 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
59973 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
59974 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
59975 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
59976 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
59977 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
59978 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
59979 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
59980 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
59981 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
59982 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
59983 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
59984 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
59985 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
59986 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
59987 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
59988 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
59989 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
59990 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
59991 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
59992 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
59993 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
59994 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
59995 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
59996 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
59997 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
59998 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
59999 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
60000 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
60001 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
60002 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
60003 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
60004 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
60005 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
60006 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
60007 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
60008 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
60009 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
60010 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
60011 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
60012 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
60013 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
60014 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
60015 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
60016 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
60017 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
60018 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
60019 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
60020 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
60021 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
60022 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
60023 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
60024 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
60025 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
60026 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
60027 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
60028 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
60029 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
60030 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
60031 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
60032 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
60033 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
60034 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
60035 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
60036 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
60037 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
60038 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
60039 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
60040 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
60041 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
60042 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
60043 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
60044 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
60045 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
60046 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
60047 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
60048 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
60049 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
60050 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
60051 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
60052 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
60053 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
60054 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
60055 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
60056 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
60057 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
60058 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
60059 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
60060 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
60061 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
60062 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
60063 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
60064 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
60065 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
60066 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
60067 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
60068 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
60069 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
60070 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60071 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60072 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60073 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60074 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60075 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60076 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60077 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60078 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60079 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60080 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60081 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60082 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60083 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60084 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60085 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60086 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60087 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60088 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60089 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60090 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60091 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60092 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60093 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60094 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60095 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60096 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60097 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60098 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60099 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60100 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60101 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60102 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60103 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60104 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60105 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60106 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60107 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60108 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60109 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60110 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60111 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60112 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60113 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60114 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60115 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60116 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60117 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60118 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60119 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60120 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60121 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60122 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60123 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60124 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60125 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60126 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60127 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60128 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60129 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60130 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60131 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60132 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60133 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60134 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60135 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60136 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60137 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60138 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60139 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60140 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60141 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60142 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60143 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60144 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60145 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60146 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60147 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60148 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60149 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60150 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60151 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60152 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60153 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60154 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60155 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60156 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60157 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60158 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60159 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60160 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60161 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60162 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60163 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60164 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60165 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60166 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60167 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60168 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60169 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60170 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60171 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60172 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60173 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
994453b8
RD
60174 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60175 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60176 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
1bd55598
RD
60177 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60178 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60179 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60180 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60181 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60182 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60183 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60184 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60185 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60186 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60187 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60188 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60189 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60190 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60191 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60192 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60193 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60194 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60195 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60196 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
8f514ab4 60197 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
1bd55598
RD
60198 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60199 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60200 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60201 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60202 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60203 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60204 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60205 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60206 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60207 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60208 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60209 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60210 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60211 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60212 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60213 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60214 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60215 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60216 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60217 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60218 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60219 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60220 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60221 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60222 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60223 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60224 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60225 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60226 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60227 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60228 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60229 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60230 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
70d7cb34
RD
60231 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60232 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60233 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60234 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60235 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
1bd55598
RD
60236 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60237 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60238 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60239 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60240 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60241
60242 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60243
60244
60245 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60246
60247 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60248 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60249 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
f5263701
RD
60250 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60251 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
1bd55598
RD
60252 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60253 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60254 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60255 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60256 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60257 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60258 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60259 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60260 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60261 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60262 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60263 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60264 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60265 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60266 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60267 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60268 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60269 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60270 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60271 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60272 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60273 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60274 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60275 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60276 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60277 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60278 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60279 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60280 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60281 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60282 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60283 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60284 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60285 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60286 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60287 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60288 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60289 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60290 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60291 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60292 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60293 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60294 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60295 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60296 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60297 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60298 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60299 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60300 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60301 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60302 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60303 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60304 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60305 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60306 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60307 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60308 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60309 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60310 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60311 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60312 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60313 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60314 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60315 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60316 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60317 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60318 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60319 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60320 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60321 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60322 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60323 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60324 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60325 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60326 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60327 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60328 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60329 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60330 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60331 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60332 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60333 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60334 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60335 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60336 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60337 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60338 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60339 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60340 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60341 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60342 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60343 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60344 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60345 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60346 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60347 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60348 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60349 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60350 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60351 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60352 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60353 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60354 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60355 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60356 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60357 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60358 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60359 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60360 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60361 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60362 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
1bd55598
RD
60363 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60364 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60365 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60366 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60367 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60368 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60369 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
34e0a3bb 60370 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
1bd55598
RD
60371 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60372 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60373 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60374 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60375 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60376 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60377 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60378 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60379 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60380 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60381 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60382 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60383 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60384 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60385 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60386 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60387 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60388 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60389 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60390 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60391 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60392 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60393 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
2131d850
RD
60394 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60395 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60396 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
1bd55598
RD
60397 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60398 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60399 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60400 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60401 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60402 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60403 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60404 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60405 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60406 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60407 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60408 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60409 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60410 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60411 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60412 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60413 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60414 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60415 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60416 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60417 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60418 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60419 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60420 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60421 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60422 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60423 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
eec1c382
RD
60424 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60425 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60426 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60427 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60428 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
1bd55598
RD
60429 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60430 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60431 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60432 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60433 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60434 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60435 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60436 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60437 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60438 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60439 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60440 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60441 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60442 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60443 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60444 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60445 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60446 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60447 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60448 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60449 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60450 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60451 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60452 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60453 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60454 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60455 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60456 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60457 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60458 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60459 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60460 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60461
60462 // Initialize threading, some globals and such
60463 __wxPyPreStart(d);
60464
60465
60466 // Although these are defined in __version__ they need to be here too so
60467 // that an assert can be done to ensure that the wxPython and the wxWindows
60468 // versions match.
60469 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60470 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60471 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60472
d55e5bfc
RD
60473}
60474